1caee0dccffb77a003681345ab3281bcf8684526cChris Lattner//===- BitcodeReader.cpp - Internal BitcodeReader implementation ----------===// 2caee0dccffb77a003681345ab3281bcf8684526cChris Lattner// 3caee0dccffb77a003681345ab3281bcf8684526cChris Lattner// The LLVM Compiler Infrastructure 4caee0dccffb77a003681345ab3281bcf8684526cChris Lattner// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7caee0dccffb77a003681345ab3281bcf8684526cChris Lattner// 8caee0dccffb77a003681345ab3281bcf8684526cChris Lattner//===----------------------------------------------------------------------===// 9caee0dccffb77a003681345ab3281bcf8684526cChris Lattner 10c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner#include "llvm/Bitcode/ReaderWriter.h" 11caee0dccffb77a003681345ab3281bcf8684526cChris Lattner#include "BitcodeReader.h" 12d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/SmallString.h" 13d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/SmallVector.h" 14d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/AutoUpgrade.h" 150b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Constants.h" 160b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/DerivedTypes.h" 170b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/InlineAsm.h" 180b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/IntrinsicInst.h" 190b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Module.h" 200b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/OperandTraits.h" 210b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Operator.h" 222ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff#include "llvm/Support/DataStream.h" 230eef08046e0758f1800f32c63b817fd22264577bChris Lattner#include "llvm/Support/MathExtras.h" 24c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner#include "llvm/Support/MemoryBuffer.h" 25caee0dccffb77a003681345ab3281bcf8684526cChris Lattnerusing namespace llvm; 26caee0dccffb77a003681345ab3281bcf8684526cChris Lattner 271cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiyenum { 281cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy SWITCH_INST_MAGIC = 0x4B5 // May 2012 => 1205 => Hex 291cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy}; 301cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy 3147f79bb58e42f1a08a7f388b8b1596ded7d49bbbRafael Espindolavoid BitcodeReader::materializeForwardReferencedFunctions() { 3247f79bb58e42f1a08a7f388b8b1596ded7d49bbbRafael Espindola while (!BlockAddrFwdRefs.empty()) { 3347f79bb58e42f1a08a7f388b8b1596ded7d49bbbRafael Espindola Function *F = BlockAddrFwdRefs.begin()->first; 3447f79bb58e42f1a08a7f388b8b1596ded7d49bbbRafael Espindola F->Materialize(); 3547f79bb58e42f1a08a7f388b8b1596ded7d49bbbRafael Espindola } 3647f79bb58e42f1a08a7f388b8b1596ded7d49bbbRafael Espindola} 3747f79bb58e42f1a08a7f388b8b1596ded7d49bbbRafael Espindola 38b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattnervoid BitcodeReader::FreeState() { 39f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin if (BufferOwned) 40f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin delete Buffer; 41b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner Buffer = 0; 421afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner std::vector<Type*>().swap(TypeList); 43b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner ValueList.clear(); 44d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel MDValueList.clear(); 45a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 4699faa3b4ec6d03ac7808fe4ff3fbf3d04e375502Bill Wendling std::vector<AttributeSet>().swap(MAttributes); 47b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner std::vector<BasicBlock*>().swap(FunctionBBs); 48b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner std::vector<Function*>().swap(FunctionsWithBodies); 49b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner DeferredFunctionInfo.clear(); 5019538d1e9fb4f8198b94f8450c6fc43528d8b868Dan Gohman MDKindMap.clear(); 51122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer 52122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer assert(BlockAddrFwdRefs.empty() && "Unresolved blockaddress fwd references"); 53c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner} 54c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner 5548c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner//===----------------------------------------------------------------------===// 5648c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner// Helper functions to implement forward reference resolution, etc. 5748c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner//===----------------------------------------------------------------------===// 58c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner 59caee0dccffb77a003681345ab3281bcf8684526cChris Lattner/// ConvertToString - Convert a string from a record into an std::string, return 60caee0dccffb77a003681345ab3281bcf8684526cChris Lattner/// true on failure. 610b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattnertemplate<typename StrTy> 62f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramerstatic bool ConvertToString(ArrayRef<uint64_t> Record, unsigned Idx, 630b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner StrTy &Result) { 6415e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner if (Idx > Record.size()) 65caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return true; 66a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 6715e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner for (unsigned i = Idx, e = Record.size(); i != e; ++i) 6815e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner Result += (char)Record[i]; 69caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return false; 70caee0dccffb77a003681345ab3281bcf8684526cChris Lattner} 71caee0dccffb77a003681345ab3281bcf8684526cChris Lattner 72caee0dccffb77a003681345ab3281bcf8684526cChris Lattnerstatic GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) { 73caee0dccffb77a003681345ab3281bcf8684526cChris Lattner switch (Val) { 74caee0dccffb77a003681345ab3281bcf8684526cChris Lattner default: // Map unknown/new linkages to external 753d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case 0: return GlobalValue::ExternalLinkage; 763d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case 1: return GlobalValue::WeakAnyLinkage; 773d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case 2: return GlobalValue::AppendingLinkage; 783d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case 3: return GlobalValue::InternalLinkage; 793d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case 4: return GlobalValue::LinkOnceAnyLinkage; 803d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case 5: return GlobalValue::DLLImportLinkage; 813d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case 6: return GlobalValue::DLLExportLinkage; 823d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case 7: return GlobalValue::ExternalWeakLinkage; 833d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case 8: return GlobalValue::CommonLinkage; 843d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case 9: return GlobalValue::PrivateLinkage; 85667d4b8de6dea70195ff12ef39a4deebffa2f5c7Duncan Sands case 10: return GlobalValue::WeakODRLinkage; 86667d4b8de6dea70195ff12ef39a4deebffa2f5c7Duncan Sands case 11: return GlobalValue::LinkOnceODRLinkage; 87266c7bbbbcc4b326dea82e577de1a415d6acc23eChris Lattner case 12: return GlobalValue::AvailableExternallyLinkage; 883d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case 13: return GlobalValue::LinkerPrivateLinkage; 895e721d768254a920b78b9129d79a84c0163cb3f4Bill Wendling case 14: return GlobalValue::LinkerPrivateWeakLinkage; 9032811bef956e0fae4329e6515420d85f7e510660Bill Wendling case 15: return GlobalValue::LinkOnceODRAutoHideLinkage; 91caee0dccffb77a003681345ab3281bcf8684526cChris Lattner } 92caee0dccffb77a003681345ab3281bcf8684526cChris Lattner} 93caee0dccffb77a003681345ab3281bcf8684526cChris Lattner 94caee0dccffb77a003681345ab3281bcf8684526cChris Lattnerstatic GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) { 95caee0dccffb77a003681345ab3281bcf8684526cChris Lattner switch (Val) { 96caee0dccffb77a003681345ab3281bcf8684526cChris Lattner default: // Map unknown visibilities to default. 97caee0dccffb77a003681345ab3281bcf8684526cChris Lattner case 0: return GlobalValue::DefaultVisibility; 98caee0dccffb77a003681345ab3281bcf8684526cChris Lattner case 1: return GlobalValue::HiddenVisibility; 999cd3ccf5065a8a139e458d016c88a8512471598bAnton Korobeynikov case 2: return GlobalValue::ProtectedVisibility; 100caee0dccffb77a003681345ab3281bcf8684526cChris Lattner } 101caee0dccffb77a003681345ab3281bcf8684526cChris Lattner} 102caee0dccffb77a003681345ab3281bcf8684526cChris Lattner 103ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborgstatic GlobalVariable::ThreadLocalMode GetDecodedThreadLocalMode(unsigned Val) { 104ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg switch (Val) { 105ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg case 0: return GlobalVariable::NotThreadLocal; 106ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg default: // Map unknown non-zero value to general dynamic. 107ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg case 1: return GlobalVariable::GeneralDynamicTLSModel; 108ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg case 2: return GlobalVariable::LocalDynamicTLSModel; 109ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg case 3: return GlobalVariable::InitialExecTLSModel; 110ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg case 4: return GlobalVariable::LocalExecTLSModel; 111ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg } 112ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg} 113ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg 114f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattnerstatic int GetDecodedCastOpcode(unsigned Val) { 115f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner switch (Val) { 116f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner default: return -1; 117f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CAST_TRUNC : return Instruction::Trunc; 118f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CAST_ZEXT : return Instruction::ZExt; 119f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CAST_SEXT : return Instruction::SExt; 120f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CAST_FPTOUI : return Instruction::FPToUI; 121f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CAST_FPTOSI : return Instruction::FPToSI; 122f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CAST_UITOFP : return Instruction::UIToFP; 123f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CAST_SITOFP : return Instruction::SIToFP; 124f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CAST_FPTRUNC : return Instruction::FPTrunc; 125f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CAST_FPEXT : return Instruction::FPExt; 126f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CAST_PTRTOINT: return Instruction::PtrToInt; 127f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CAST_INTTOPTR: return Instruction::IntToPtr; 128f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CAST_BITCAST : return Instruction::BitCast; 129f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner } 130f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner} 131db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic int GetDecodedBinaryOpcode(unsigned Val, Type *Ty) { 132f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner switch (Val) { 133f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner default: return -1; 134ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case bitc::BINOP_ADD: 135b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands return Ty->isFPOrFPVectorTy() ? Instruction::FAdd : Instruction::Add; 136ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case bitc::BINOP_SUB: 137b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands return Ty->isFPOrFPVectorTy() ? Instruction::FSub : Instruction::Sub; 138ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case bitc::BINOP_MUL: 139b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands return Ty->isFPOrFPVectorTy() ? Instruction::FMul : Instruction::Mul; 140f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::BINOP_UDIV: return Instruction::UDiv; 141f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::BINOP_SDIV: 142b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands return Ty->isFPOrFPVectorTy() ? Instruction::FDiv : Instruction::SDiv; 143f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::BINOP_UREM: return Instruction::URem; 144f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::BINOP_SREM: 145b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands return Ty->isFPOrFPVectorTy() ? Instruction::FRem : Instruction::SRem; 146f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::BINOP_SHL: return Instruction::Shl; 147f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::BINOP_LSHR: return Instruction::LShr; 148f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::BINOP_ASHR: return Instruction::AShr; 149f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::BINOP_AND: return Instruction::And; 150f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::BINOP_OR: return Instruction::Or; 151f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::BINOP_XOR: return Instruction::Xor; 152f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner } 153f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner} 154f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner 155ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedmanstatic AtomicRMWInst::BinOp GetDecodedRMWOperation(unsigned Val) { 156ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman switch (Val) { 157ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman default: return AtomicRMWInst::BAD_BINOP; 158ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman case bitc::RMW_XCHG: return AtomicRMWInst::Xchg; 159ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman case bitc::RMW_ADD: return AtomicRMWInst::Add; 160ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman case bitc::RMW_SUB: return AtomicRMWInst::Sub; 161ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman case bitc::RMW_AND: return AtomicRMWInst::And; 162ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman case bitc::RMW_NAND: return AtomicRMWInst::Nand; 163ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman case bitc::RMW_OR: return AtomicRMWInst::Or; 164ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman case bitc::RMW_XOR: return AtomicRMWInst::Xor; 165ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman case bitc::RMW_MAX: return AtomicRMWInst::Max; 166ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman case bitc::RMW_MIN: return AtomicRMWInst::Min; 167ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman case bitc::RMW_UMAX: return AtomicRMWInst::UMax; 168ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman case bitc::RMW_UMIN: return AtomicRMWInst::UMin; 169ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman } 170ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman} 171ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman 17247f3513dd574535aeb40c9eb11134f0899e92269Eli Friedmanstatic AtomicOrdering GetDecodedOrdering(unsigned Val) { 17347f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman switch (Val) { 17447f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman case bitc::ORDERING_NOTATOMIC: return NotAtomic; 17547f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman case bitc::ORDERING_UNORDERED: return Unordered; 17647f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman case bitc::ORDERING_MONOTONIC: return Monotonic; 17747f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman case bitc::ORDERING_ACQUIRE: return Acquire; 17847f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman case bitc::ORDERING_RELEASE: return Release; 17947f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman case bitc::ORDERING_ACQREL: return AcquireRelease; 18047f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman default: // Map unknown orderings to sequentially-consistent. 18147f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman case bitc::ORDERING_SEQCST: return SequentiallyConsistent; 18247f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman } 18347f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman} 18447f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman 18547f3513dd574535aeb40c9eb11134f0899e92269Eli Friedmanstatic SynchronizationScope GetDecodedSynchScope(unsigned Val) { 18647f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman switch (Val) { 18747f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman case bitc::SYNCHSCOPE_SINGLETHREAD: return SingleThread; 18847f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman default: // Map unknown scopes to cross-thread. 18947f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman case bitc::SYNCHSCOPE_CROSSTHREAD: return CrossThread; 19047f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman } 19147f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman} 19247f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman 193efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greifnamespace llvm { 194522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattnernamespace { 195522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner /// @brief A class for maintaining the slot number definition 196522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner /// as a placeholder for the actual definition for forward constants defs. 197522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner class ConstantPlaceHolder : public ConstantExpr { 19886a1c32e67b23c5e9e42dff9eb86e99ba15bb42fCraig Topper void operator=(const ConstantPlaceHolder &) LLVM_DELETED_FUNCTION; 199051a950000e21935165db56695e35bade668193bGabor Greif public: 200051a950000e21935165db56695e35bade668193bGabor Greif // allocate space for exactly one operand 201051a950000e21935165db56695e35bade668193bGabor Greif void *operator new(size_t s) { 202051a950000e21935165db56695e35bade668193bGabor Greif return User::operator new(s, 1); 203051a950000e21935165db56695e35bade668193bGabor Greif } 204db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner explicit ConstantPlaceHolder(Type *Ty, LLVMContext& Context) 205efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) { 2061d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Op<0>() = UndefValue::get(Type::getInt32Ty(Context)); 207522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner } 208a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 209ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner /// @brief Methods to support type inquiry through isa, cast, and dyn_cast. 210ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner static bool classof(const Value *V) { 211a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar return isa<ConstantExpr>(V) && 212ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1; 213ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner } 214a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 215a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 216efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif /// Provide fast operand accessors 21746e7740a4433383e6e5561f089a091c22125bd07Chris Lattner //DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 218522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner }; 219522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner} 220522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner 22146e7740a4433383e6e5561f089a091c22125bd07Chris Lattner// FIXME: can we inherit this from ConstantExpr? 222efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greiftemplate <> 22367c619ba3eae68dcdb3f9340d82b33173aa0c256Jay Foadstruct OperandTraits<ConstantPlaceHolder> : 22467c619ba3eae68dcdb3f9340d82b33173aa0c256Jay Foad public FixedNumOperandTraits<ConstantPlaceHolder, 1> { 225efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif}; 226efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif} 227efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif 22846e7740a4433383e6e5561f089a091c22125bd07Chris Lattner 22946e7740a4433383e6e5561f089a091c22125bd07Chris Lattnervoid BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) { 23046e7740a4433383e6e5561f089a091c22125bd07Chris Lattner if (Idx == size()) { 23146e7740a4433383e6e5561f089a091c22125bd07Chris Lattner push_back(V); 23246e7740a4433383e6e5561f089a091c22125bd07Chris Lattner return; 23346e7740a4433383e6e5561f089a091c22125bd07Chris Lattner } 234a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 23546e7740a4433383e6e5561f089a091c22125bd07Chris Lattner if (Idx >= size()) 23646e7740a4433383e6e5561f089a091c22125bd07Chris Lattner resize(Idx+1); 237a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 23846e7740a4433383e6e5561f089a091c22125bd07Chris Lattner WeakVH &OldV = ValuePtrs[Idx]; 23946e7740a4433383e6e5561f089a091c22125bd07Chris Lattner if (OldV == 0) { 24046e7740a4433383e6e5561f089a091c22125bd07Chris Lattner OldV = V; 24146e7740a4433383e6e5561f089a091c22125bd07Chris Lattner return; 24246e7740a4433383e6e5561f089a091c22125bd07Chris Lattner } 243a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 24446e7740a4433383e6e5561f089a091c22125bd07Chris Lattner // Handle constants and non-constants (e.g. instrs) differently for 24546e7740a4433383e6e5561f089a091c22125bd07Chris Lattner // efficiency. 24646e7740a4433383e6e5561f089a091c22125bd07Chris Lattner if (Constant *PHC = dyn_cast<Constant>(&*OldV)) { 24746e7740a4433383e6e5561f089a091c22125bd07Chris Lattner ResolveConstants.push_back(std::make_pair(PHC, Idx)); 24846e7740a4433383e6e5561f089a091c22125bd07Chris Lattner OldV = V; 24946e7740a4433383e6e5561f089a091c22125bd07Chris Lattner } else { 25046e7740a4433383e6e5561f089a091c22125bd07Chris Lattner // If there was a forward reference to this value, replace it. 25146e7740a4433383e6e5561f089a091c22125bd07Chris Lattner Value *PrevVal = OldV; 25246e7740a4433383e6e5561f089a091c22125bd07Chris Lattner OldV->replaceAllUsesWith(V); 25346e7740a4433383e6e5561f089a091c22125bd07Chris Lattner delete PrevVal; 254efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif } 255efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif} 256a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 257efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif 258522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris LattnerConstant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, 259db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 26046e7740a4433383e6e5561f089a091c22125bd07Chris Lattner if (Idx >= size()) 261efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif resize(Idx + 1); 262522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner 26346e7740a4433383e6e5561f089a091c22125bd07Chris Lattner if (Value *V = ValuePtrs[Idx]) { 264a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner assert(Ty == V->getType() && "Type mismatch in constant table!"); 265a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner return cast<Constant>(V); 266f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner } 267522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner 268522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner // Create and return a placeholder, which will later be RAUW'd. 26974a77812d1785ad6c62226c52dcd4d129b3cdd0bOwen Anderson Constant *C = new ConstantPlaceHolder(Ty, Context); 27046e7740a4433383e6e5561f089a091c22125bd07Chris Lattner ValuePtrs[Idx] = C; 271522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner return C; 272522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner} 273522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner 274db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerValue *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty) { 27546e7740a4433383e6e5561f089a091c22125bd07Chris Lattner if (Idx >= size()) 276efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif resize(Idx + 1); 277a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 27846e7740a4433383e6e5561f089a091c22125bd07Chris Lattner if (Value *V = ValuePtrs[Idx]) { 279a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!"); 280a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner return V; 281a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner } 282a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 28301ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner // No type specified, must be invalid reference. 28401ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner if (Ty == 0) return 0; 285a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 286a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner // Create and return a placeholder, which will later be RAUW'd. 287a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner Value *V = new Argument(Ty); 28846e7740a4433383e6e5561f089a091c22125bd07Chris Lattner ValuePtrs[Idx] = V; 289a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner return V; 290a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner} 291a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner 292ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner/// ResolveConstantForwardRefs - Once all constants are read, this method bulk 293ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner/// resolves any forward references. The idea behind this is that we sometimes 294ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner/// get constants (such as large arrays) which reference *many* forward ref 295ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner/// constants. Replacing each of these causes a lot of thrashing when 296ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner/// building/reuniquing the constant. Instead of doing this, we look at all the 297ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner/// uses and rewrite all the place holders at once for any constant that uses 298ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner/// a placeholder. 299ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattnervoid BitcodeReaderValueList::ResolveConstantForwardRefs() { 300a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar // Sort the values by-pointer so that they are efficient to look up with a 301ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner // binary search. 302ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner std::sort(ResolveConstants.begin(), ResolveConstants.end()); 303a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 304ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner SmallVector<Constant*, 64> NewOps; 305a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 306ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner while (!ResolveConstants.empty()) { 30746e7740a4433383e6e5561f089a091c22125bd07Chris Lattner Value *RealVal = operator[](ResolveConstants.back().second); 308ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner Constant *Placeholder = ResolveConstants.back().first; 309ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner ResolveConstants.pop_back(); 310a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 311ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner // Loop over all users of the placeholder, updating them to reference the 312ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner // new value. If they reference more than one placeholder, update them all 313ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner // at once. 314ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner while (!Placeholder->use_empty()) { 315b6135a054d46c00e2ba604e8f509de48e6dcfde6Chris Lattner Value::use_iterator UI = Placeholder->use_begin(); 316c654d1b8c195a13413537a668f669fd9b0c7f226Gabor Greif User *U = *UI; 317a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 318ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner // If the using object isn't uniqued, just update the operands. This 319ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner // handles instructions and initializers for global variables. 320c654d1b8c195a13413537a668f669fd9b0c7f226Gabor Greif if (!isa<Constant>(U) || isa<GlobalValue>(U)) { 321b6135a054d46c00e2ba604e8f509de48e6dcfde6Chris Lattner UI.getUse().set(RealVal); 322ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner continue; 323ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner } 324a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 325ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner // Otherwise, we have a constant that uses the placeholder. Replace that 326ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner // constant with a new constant that has *all* placeholder uses updated. 327c654d1b8c195a13413537a668f669fd9b0c7f226Gabor Greif Constant *UserC = cast<Constant>(U); 328ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner for (User::op_iterator I = UserC->op_begin(), E = UserC->op_end(); 329ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner I != E; ++I) { 330ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner Value *NewOp; 331ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner if (!isa<ConstantPlaceHolder>(*I)) { 332ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner // Not a placeholder reference. 333ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner NewOp = *I; 334ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner } else if (*I == Placeholder) { 335ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner // Common case is that it just references this one placeholder. 336ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner NewOp = RealVal; 337ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner } else { 338ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner // Otherwise, look up the placeholder in ResolveConstants. 339a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar ResolveConstantsTy::iterator It = 340a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar std::lower_bound(ResolveConstants.begin(), ResolveConstants.end(), 341ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner std::pair<Constant*, unsigned>(cast<Constant>(*I), 342ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner 0)); 343ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner assert(It != ResolveConstants.end() && It->first == *I); 34446e7740a4433383e6e5561f089a091c22125bd07Chris Lattner NewOp = operator[](It->second); 345ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner } 346ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner 347ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner NewOps.push_back(cast<Constant>(NewOp)); 348ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner } 349ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner 350ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner // Make the new constant. 351ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner Constant *NewC; 352ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) { 353267010864e139781ef5949939e081c41f954de0aJay Foad NewC = ConstantArray::get(UserCA->getType(), NewOps); 354ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) { 355b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner NewC = ConstantStruct::get(UserCS->getType(), NewOps); 356ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner } else if (isa<ConstantVector>(UserC)) { 3572ca5c8644e6c35b3a7910a576ed89cddb7b82c3bChris Lattner NewC = ConstantVector::get(NewOps); 358cb33799b9f4e152e3460faa83e59b53ff604c87dNick Lewycky } else { 359cb33799b9f4e152e3460faa83e59b53ff604c87dNick Lewycky assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr."); 360b81e457eb02b67a9ef5fb9edc1604b177acb821dJay Foad NewC = cast<ConstantExpr>(UserC)->getWithOperands(NewOps); 361ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner } 362a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 363ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner UserC->replaceAllUsesWith(NewC); 364ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner UserC->destroyConstant(); 365ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner NewOps.clear(); 366ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner } 367a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 368cb33799b9f4e152e3460faa83e59b53ff604c87dNick Lewycky // Update all ValueHandles, they should be the only users at this point. 369cb33799b9f4e152e3460faa83e59b53ff604c87dNick Lewycky Placeholder->replaceAllUsesWith(RealVal); 370ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner delete Placeholder; 371ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner } 372ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner} 373ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner 374d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patelvoid BitcodeReaderMDValueList::AssignValue(Value *V, unsigned Idx) { 375d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel if (Idx == size()) { 376d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel push_back(V); 377d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel return; 378d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel } 379a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 380d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel if (Idx >= size()) 381d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel resize(Idx+1); 382a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 383d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel WeakVH &OldV = MDValuePtrs[Idx]; 384d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel if (OldV == 0) { 385d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel OldV = V; 386d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel return; 387d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel } 388a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 389d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel // If there was a forward reference to this value, replace it. 390489b29b0a4ee4526e3d50ad88d3d48745baf5042Dan Gohman MDNode *PrevVal = cast<MDNode>(OldV); 391d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel OldV->replaceAllUsesWith(V); 392489b29b0a4ee4526e3d50ad88d3d48745baf5042Dan Gohman MDNode::deleteTemporary(PrevVal); 393c0ff8c85dcc0bb3c58c15890b180dedaa726cb76Devang Patel // Deleting PrevVal sets Idx value in MDValuePtrs to null. Set new 394c0ff8c85dcc0bb3c58c15890b180dedaa726cb76Devang Patel // value for Idx. 395c0ff8c85dcc0bb3c58c15890b180dedaa726cb76Devang Patel MDValuePtrs[Idx] = V; 396d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel} 397d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel 398d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang PatelValue *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { 399d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel if (Idx >= size()) 400d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel resize(Idx + 1); 401a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 402d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel if (Value *V = MDValuePtrs[Idx]) { 403cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner assert(V->getType()->isMetadataTy() && "Type mismatch in value table!"); 404d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel return V; 405d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel } 406a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 407d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel // Create and return a placeholder, which will later be RAUW'd. 408ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay Foad Value *V = MDNode::getTemporary(Context, ArrayRef<Value*>()); 409d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel MDValuePtrs[Idx] = V; 410d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel return V; 411d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel} 412caee0dccffb77a003681345ab3281bcf8684526cChris Lattner 4131afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris LattnerType *BitcodeReader::getTypeByID(unsigned ID) { 4141afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // The type table size is always specified correctly. 4151afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (ID >= TypeList.size()) 4161afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return 0; 417fccf0623ee35e0bbbbf0ba963a5500b7fd87fa11Derek Schuff 4181afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (Type *Ty = TypeList[ID]) 4191afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return Ty; 4201afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 4211afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If we have a forward reference, the only possible case is when it is to a 4221afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // named struct. Just create a placeholder for now. 4233ebb64946bc8e7c8feba1b2044e7a47f80b3a83fChris Lattner return TypeList[ID] = StructType::create(Context); 4241afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner} 4251afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 4261afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 42748c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner//===----------------------------------------------------------------------===// 42848c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner// Functions for parsing blocks from the bitcode file 42948c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner//===----------------------------------------------------------------------===// 43048c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner 431f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling 432f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling/// \brief This fills an AttrBuilder object with the LLVM attributes that have 433f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling/// been decoded from the given integer. This function must stay in sync with 434f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling/// 'encodeLLVMAttributesForBitcode'. 435f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendlingstatic void decodeLLVMAttributesForBitcode(AttrBuilder &B, 436f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling uint64_t EncodedAttrs) { 437f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling // FIXME: Remove in 4.0. 438f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling 439f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling // The alignment is stored as a 16-bit raw value from bits 31--16. We shift 440f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling // the bits above 31 down by 11 bits. 441f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16; 442f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling assert((!Alignment || isPowerOf2_32(Alignment)) && 443f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling "Alignment must be a power of two."); 444f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling 445f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling if (Alignment) 446f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling B.addAlignmentAttr(Alignment); 447ab39afa9d9b99c61842c8e3d0eb706bd16efdcf3Kostya Serebryany B.addRawValue(((EncodedAttrs & (0xfffffULL << 32)) >> 11) | 448f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling (EncodedAttrs & 0xffff)); 449f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling} 450f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling 4510598866c052147c31b808391f58434ce3dbfb838Devang Patelbool BitcodeReader::ParseAttributeBlock() { 452e17b658c792abd4a1552144b8a8808e44970da76Chris Lattner if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) 45348c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner return Error("Malformed block record"); 454a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 45519c874638d9478a5d5028854817a5ee72293bb2bDevang Patel if (!MAttributes.empty()) 45648c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner return Error("Multiple PARAMATTR blocks found!"); 457a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 45848c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner SmallVector<uint64_t, 64> Record; 459a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 4600c2f0ff9ccee3d711893b963b1dd8426beb7ddfeBill Wendling SmallVector<AttributeSet, 8> Attrs; 461a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 46248c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner // Read all the records. 46348c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner while (1) { 4645a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 465acb6194f93440425776cdd730a2726fd95499505Joe Abbey 4665a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Entry.Kind) { 4675a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::SubBlock: // Handled for us already. 4685a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Error: 4695a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return Error("Error at end of PARAMATTR block"); 4705a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::EndBlock: 47148c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner return false; 4725a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Record: 4735a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner // The interesting case. 4745a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner break; 47548c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner } 476acb6194f93440425776cdd730a2726fd95499505Joe Abbey 47748c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner // Read a record. 47848c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner Record.clear(); 4795a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Stream.readRecord(Entry.ID, Record)) { 48048c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner default: // Default behavior: ignore. 48148c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner break; 482f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling case bitc::PARAMATTR_CODE_ENTRY_OLD: { // ENTRY: [paramidx0, attr0, ...] 483f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling // FIXME: Remove in 4.0. 48448c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner if (Record.size() & 1) 48548c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner return Error("Invalid ENTRY record"); 48648c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner 48748c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 4888232ece5c1e57efe54342fb35610497d50bf894fBill Wendling AttrBuilder B; 489f9271ea159b97e2febedcf095c3c4122cb24d077Bill Wendling decodeLLVMAttributesForBitcode(B, Record[i+1]); 4908232ece5c1e57efe54342fb35610497d50bf894fBill Wendling Attrs.push_back(AttributeSet::get(Context, Record[i], B)); 49148c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner } 492461edd937e9ec95193022629314c66d2c1e984d2Chris Lattner 49399faa3b4ec6d03ac7808fe4ff3fbf3d04e375502Bill Wendling MAttributes.push_back(AttributeSet::get(Context, Attrs)); 49448c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner Attrs.clear(); 49548c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner break; 49648c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner } 49748fbcfe6b959df628a6455e00ac8d94fa6ade87aBill Wendling case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [attrgrp0, attrgrp1, ...] 49848fbcfe6b959df628a6455e00ac8d94fa6ade87aBill Wendling for (unsigned i = 0, e = Record.size(); i != e; ++i) 49948fbcfe6b959df628a6455e00ac8d94fa6ade87aBill Wendling Attrs.push_back(MAttributeGroups[Record[i]]); 50048fbcfe6b959df628a6455e00ac8d94fa6ade87aBill Wendling 50148fbcfe6b959df628a6455e00ac8d94fa6ade87aBill Wendling MAttributes.push_back(AttributeSet::get(Context, Attrs)); 50248fbcfe6b959df628a6455e00ac8d94fa6ade87aBill Wendling Attrs.clear(); 50348fbcfe6b959df628a6455e00ac8d94fa6ade87aBill Wendling break; 50448fbcfe6b959df628a6455e00ac8d94fa6ade87aBill Wendling } 5055e41f6569918a6e001cadf8dea96819686cf301cDuncan Sands } 50648c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner } 50748c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner} 50848c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner 509c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendlingbool BitcodeReader::ParseAttributeGroupBlock() { 510c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling if (Stream.EnterSubBlock(bitc::PARAMATTR_GROUP_BLOCK_ID)) 511c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling return Error("Malformed block record"); 512c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling 513c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling if (!MAttributeGroups.empty()) 514c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling return Error("Multiple PARAMATTR_GROUP blocks found!"); 515c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling 516c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling SmallVector<uint64_t, 64> Record; 517c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling 518c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling // Read all the records. 519c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling while (1) { 520c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 521c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling 522c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling switch (Entry.Kind) { 523c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling case BitstreamEntry::SubBlock: // Handled for us already. 524c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling case BitstreamEntry::Error: 525c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling return Error("Error at end of PARAMATTR_GROUP block"); 526c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling case BitstreamEntry::EndBlock: 527c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling return false; 528c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling case BitstreamEntry::Record: 529c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling // The interesting case. 530c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling break; 531c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling } 532c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling 533c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling // Read a record. 534c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling Record.clear(); 535c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling switch (Stream.readRecord(Entry.ID, Record)) { 536c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling default: // Default behavior: ignore. 537c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling break; 538c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...] 539c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling if (Record.size() < 3) 540c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling return Error("Invalid ENTRY record"); 541c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling 54204ef4be048934f8acf15c4ed6e3ebdd410c252bbBill Wendling uint64_t GrpID = Record[0]; 543c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling uint64_t Idx = Record[1]; // Index of the object this attribute refers to. 544c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling 545c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling AttrBuilder B; 546c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling for (unsigned i = 2, e = Record.size(); i != e; ++i) { 547c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling if (Record[i] == 0) { // Enum attribute 548c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling B.addAttribute(Attribute::AttrKind(Record[++i])); 549c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling } else if (Record[i] == 1) { // Align attribute 550c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling if (Attribute::AttrKind(Record[++i]) == Attribute::Alignment) 551c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling B.addAlignmentAttr(Record[++i]); 552c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling else 553c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling B.addStackAlignmentAttr(Record[++i]); 554c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling } else { // String attribute 55504ef4be048934f8acf15c4ed6e3ebdd410c252bbBill Wendling assert((Record[i] == 3 || Record[i] == 4) && 55604ef4be048934f8acf15c4ed6e3ebdd410c252bbBill Wendling "Invalid attribute group entry"); 557c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling bool HasValue = (Record[i++] == 4); 558c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling SmallString<64> KindStr; 559c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling SmallString<64> ValStr; 560c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling 561c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling while (Record[i] != 0 && i != e) 562c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling KindStr += Record[i++]; 56304ef4be048934f8acf15c4ed6e3ebdd410c252bbBill Wendling assert(Record[i] == 0 && "Kind string not null terminated"); 564c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling 565c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling if (HasValue) { 566c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling // Has a value associated with it. 56704ef4be048934f8acf15c4ed6e3ebdd410c252bbBill Wendling ++i; // Skip the '0' that terminates the "kind" string. 568c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling while (Record[i] != 0 && i != e) 569c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling ValStr += Record[i++]; 57004ef4be048934f8acf15c4ed6e3ebdd410c252bbBill Wendling assert(Record[i] == 0 && "Value string not null terminated"); 571c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling } 572c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling 573c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling B.addAttribute(KindStr.str(), ValStr.str()); 574c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling } 575c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling } 576c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling 57704ef4be048934f8acf15c4ed6e3ebdd410c252bbBill Wendling MAttributeGroups[GrpID] = AttributeSet::get(Context, Idx, B); 578c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling break; 579c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling } 580c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling } 581c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling } 582c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling} 583c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling 584866971474ced63f725bd3dbf10fdb9e3badb7d9eChris Lattnerbool BitcodeReader::ParseTypeTable() { 5851afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW)) 586caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Malformed block record"); 587fccf0623ee35e0bbbbf0ba963a5500b7fd87fa11Derek Schuff 5881afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return ParseTypeTableBody(); 5891afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner} 590a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 5911afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnerbool BitcodeReader::ParseTypeTableBody() { 592caee0dccffb77a003681345ab3281bcf8684526cChris Lattner if (!TypeList.empty()) 593caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Multiple TYPE_BLOCKs found!"); 594caee0dccffb77a003681345ab3281bcf8684526cChris Lattner 595caee0dccffb77a003681345ab3281bcf8684526cChris Lattner SmallVector<uint64_t, 64> Record; 596caee0dccffb77a003681345ab3281bcf8684526cChris Lattner unsigned NumRecords = 0; 597caee0dccffb77a003681345ab3281bcf8684526cChris Lattner 5981afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SmallString<64> TypeName; 599fccf0623ee35e0bbbbf0ba963a5500b7fd87fa11Derek Schuff 600caee0dccffb77a003681345ab3281bcf8684526cChris Lattner // Read all the records for this type table. 601caee0dccffb77a003681345ab3281bcf8684526cChris Lattner while (1) { 6025a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 603acb6194f93440425776cdd730a2726fd95499505Joe Abbey 6045a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Entry.Kind) { 6055a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::SubBlock: // Handled for us already. 6065a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Error: 6075a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner Error("Error in the type table block"); 6085a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return true; 6095a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::EndBlock: 610caee0dccffb77a003681345ab3281bcf8684526cChris Lattner if (NumRecords != TypeList.size()) 611caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Invalid type forward reference in TYPE_BLOCK"); 612f66d20da61af8672b2fe648283604408d42836ceChris Lattner return false; 6135a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Record: 6145a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner // The interesting case. 6155a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner break; 616caee0dccffb77a003681345ab3281bcf8684526cChris Lattner } 617a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 618caee0dccffb77a003681345ab3281bcf8684526cChris Lattner // Read a record. 619caee0dccffb77a003681345ab3281bcf8684526cChris Lattner Record.clear(); 6201afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Type *ResultTy = 0; 6215a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Stream.readRecord(Entry.ID, Record)) { 6221afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner default: return Error("unknown type in type table"); 623caee0dccffb77a003681345ab3281bcf8684526cChris Lattner case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 624caee0dccffb77a003681345ab3281bcf8684526cChris Lattner // TYPE_CODE_NUMENTRY contains a count of the number of types in the 625caee0dccffb77a003681345ab3281bcf8684526cChris Lattner // type list. This allows us to reserve space. 626caee0dccffb77a003681345ab3281bcf8684526cChris Lattner if (Record.size() < 1) 627caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Invalid TYPE_CODE_NUMENTRY record"); 6281afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner TypeList.resize(Record[0]); 629caee0dccffb77a003681345ab3281bcf8684526cChris Lattner continue; 630caee0dccffb77a003681345ab3281bcf8684526cChris Lattner case bitc::TYPE_CODE_VOID: // VOID 6311d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson ResultTy = Type::getVoidTy(Context); 632caee0dccffb77a003681345ab3281bcf8684526cChris Lattner break; 633ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman case bitc::TYPE_CODE_HALF: // HALF 634ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman ResultTy = Type::getHalfTy(Context); 635ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman break; 636caee0dccffb77a003681345ab3281bcf8684526cChris Lattner case bitc::TYPE_CODE_FLOAT: // FLOAT 6371d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson ResultTy = Type::getFloatTy(Context); 638caee0dccffb77a003681345ab3281bcf8684526cChris Lattner break; 639caee0dccffb77a003681345ab3281bcf8684526cChris Lattner case bitc::TYPE_CODE_DOUBLE: // DOUBLE 6401d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson ResultTy = Type::getDoubleTy(Context); 641caee0dccffb77a003681345ab3281bcf8684526cChris Lattner break; 642320fc8a39e17f5725f5711248e06bcb36f122687Dale Johannesen case bitc::TYPE_CODE_X86_FP80: // X86_FP80 6431d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson ResultTy = Type::getX86_FP80Ty(Context); 644320fc8a39e17f5725f5711248e06bcb36f122687Dale Johannesen break; 645320fc8a39e17f5725f5711248e06bcb36f122687Dale Johannesen case bitc::TYPE_CODE_FP128: // FP128 6461d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson ResultTy = Type::getFP128Ty(Context); 647320fc8a39e17f5725f5711248e06bcb36f122687Dale Johannesen break; 648320fc8a39e17f5725f5711248e06bcb36f122687Dale Johannesen case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 6491d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson ResultTy = Type::getPPC_FP128Ty(Context); 650320fc8a39e17f5725f5711248e06bcb36f122687Dale Johannesen break; 651caee0dccffb77a003681345ab3281bcf8684526cChris Lattner case bitc::TYPE_CODE_LABEL: // LABEL 6521d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson ResultTy = Type::getLabelTy(Context); 653caee0dccffb77a003681345ab3281bcf8684526cChris Lattner break; 6547a0370f66ab5739f42ffe822f33494e0de9b182bNick Lewycky case bitc::TYPE_CODE_METADATA: // METADATA 6551d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson ResultTy = Type::getMetadataTy(Context); 6567a0370f66ab5739f42ffe822f33494e0de9b182bNick Lewycky break; 657bb811a244567aa8a1522203f15588f4d001b7353Dale Johannesen case bitc::TYPE_CODE_X86_MMX: // X86_MMX 658bb811a244567aa8a1522203f15588f4d001b7353Dale Johannesen ResultTy = Type::getX86_MMXTy(Context); 659bb811a244567aa8a1522203f15588f4d001b7353Dale Johannesen break; 660caee0dccffb77a003681345ab3281bcf8684526cChris Lattner case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 661caee0dccffb77a003681345ab3281bcf8684526cChris Lattner if (Record.size() < 1) 662caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Invalid Integer type record"); 663a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 6641d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson ResultTy = IntegerType::get(Context, Record[0]); 665caee0dccffb77a003681345ab3281bcf8684526cChris Lattner break; 666a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 667fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb // [pointee type, address space] 668caee0dccffb77a003681345ab3281bcf8684526cChris Lattner if (Record.size() < 1) 669caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Invalid POINTER type record"); 670fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb unsigned AddressSpace = 0; 671fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb if (Record.size() == 2) 672fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb AddressSpace = Record[1]; 6731afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ResultTy = getTypeByID(Record[0]); 6741afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (ResultTy == 0) return Error("invalid element type in pointer type"); 6751afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ResultTy = PointerType::get(ResultTy, AddressSpace); 676caee0dccffb77a003681345ab3281bcf8684526cChris Lattner break; 677fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb } 678ee8100d70a81c154487cb715925c1adf46f7653eNuno Lopes case bitc::TYPE_CODE_FUNCTION_OLD: { 679ee8100d70a81c154487cb715925c1adf46f7653eNuno Lopes // FIXME: attrid is dead, remove it in LLVM 4.0 680ee8100d70a81c154487cb715925c1adf46f7653eNuno Lopes // FUNCTION: [vararg, attrid, retty, paramty x N] 681ee8100d70a81c154487cb715925c1adf46f7653eNuno Lopes if (Record.size() < 3) 682ee8100d70a81c154487cb715925c1adf46f7653eNuno Lopes return Error("Invalid FUNCTION type record"); 683ee8100d70a81c154487cb715925c1adf46f7653eNuno Lopes SmallVector<Type*, 8> ArgTys; 684ee8100d70a81c154487cb715925c1adf46f7653eNuno Lopes for (unsigned i = 3, e = Record.size(); i != e; ++i) { 685ee8100d70a81c154487cb715925c1adf46f7653eNuno Lopes if (Type *T = getTypeByID(Record[i])) 686ee8100d70a81c154487cb715925c1adf46f7653eNuno Lopes ArgTys.push_back(T); 687ee8100d70a81c154487cb715925c1adf46f7653eNuno Lopes else 688ee8100d70a81c154487cb715925c1adf46f7653eNuno Lopes break; 689ee8100d70a81c154487cb715925c1adf46f7653eNuno Lopes } 690407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 691ee8100d70a81c154487cb715925c1adf46f7653eNuno Lopes ResultTy = getTypeByID(Record[2]); 692ee8100d70a81c154487cb715925c1adf46f7653eNuno Lopes if (ResultTy == 0 || ArgTys.size() < Record.size()-3) 693ee8100d70a81c154487cb715925c1adf46f7653eNuno Lopes return Error("invalid type in function type"); 694ee8100d70a81c154487cb715925c1adf46f7653eNuno Lopes 695ee8100d70a81c154487cb715925c1adf46f7653eNuno Lopes ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 696ee8100d70a81c154487cb715925c1adf46f7653eNuno Lopes break; 697ee8100d70a81c154487cb715925c1adf46f7653eNuno Lopes } 698cde546497067bf2ed40b9473582212df4ccd8141Chad Rosier case bitc::TYPE_CODE_FUNCTION: { 699cde546497067bf2ed40b9473582212df4ccd8141Chad Rosier // FUNCTION: [vararg, retty, paramty x N] 700cde546497067bf2ed40b9473582212df4ccd8141Chad Rosier if (Record.size() < 2) 701cde546497067bf2ed40b9473582212df4ccd8141Chad Rosier return Error("Invalid FUNCTION type record"); 702d629efa0642110fbc90c28d4be3da54ffb359750Chris Lattner SmallVector<Type*, 8> ArgTys; 703cde546497067bf2ed40b9473582212df4ccd8141Chad Rosier for (unsigned i = 2, e = Record.size(); i != e; ++i) { 704cde546497067bf2ed40b9473582212df4ccd8141Chad Rosier if (Type *T = getTypeByID(Record[i])) 705cde546497067bf2ed40b9473582212df4ccd8141Chad Rosier ArgTys.push_back(T); 706cde546497067bf2ed40b9473582212df4ccd8141Chad Rosier else 707cde546497067bf2ed40b9473582212df4ccd8141Chad Rosier break; 708cde546497067bf2ed40b9473582212df4ccd8141Chad Rosier } 709407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 710cde546497067bf2ed40b9473582212df4ccd8141Chad Rosier ResultTy = getTypeByID(Record[1]); 711cde546497067bf2ed40b9473582212df4ccd8141Chad Rosier if (ResultTy == 0 || ArgTys.size() < Record.size()-2) 712cde546497067bf2ed40b9473582212df4ccd8141Chad Rosier return Error("invalid type in function type"); 713cde546497067bf2ed40b9473582212df4ccd8141Chad Rosier 714cde546497067bf2ed40b9473582212df4ccd8141Chad Rosier ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 715cde546497067bf2ed40b9473582212df4ccd8141Chad Rosier break; 716cde546497067bf2ed40b9473582212df4ccd8141Chad Rosier } 7171afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N] 7187108dce324eed700ba32a8a5e0a65b1161a00232Chris Lattner if (Record.size() < 1) 719caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Invalid STRUCT type record"); 720d629efa0642110fbc90c28d4be3da54ffb359750Chris Lattner SmallVector<Type*, 8> EltTys; 7211afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (unsigned i = 1, e = Record.size(); i != e; ++i) { 7221afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (Type *T = getTypeByID(Record[i])) 7231afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner EltTys.push_back(T); 7241afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner else 7251afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner break; 7261afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } 7271afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (EltTys.size() != Record.size()-1) 7281afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return Error("invalid type in struct type"); 729d7f2a6cb3fbc012763adb42fd967f6fefbb22a37Owen Anderson ResultTy = StructType::get(Context, EltTys, Record[0]); 730caee0dccffb77a003681345ab3281bcf8684526cChris Lattner break; 731caee0dccffb77a003681345ab3281bcf8684526cChris Lattner } 7321afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N] 7331afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (ConvertToString(Record, 0, TypeName)) 7341afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return Error("Invalid STRUCT_NAME record"); 7351afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner continue; 7361afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 7371afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N] 7381afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (Record.size() < 1) 7391afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return Error("Invalid STRUCT type record"); 740407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 7411afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (NumRecords >= TypeList.size()) 7421afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return Error("invalid TYPE table"); 743407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 7441afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Check to see if this was forward referenced, if so fill in the temp. 7451afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 7461afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (Res) { 7471afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Res->setName(TypeName); 7481afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner TypeList[NumRecords] = 0; 7491afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } else // Otherwise, create a new struct. 7503ebb64946bc8e7c8feba1b2044e7a47f80b3a83fChris Lattner Res = StructType::create(Context, TypeName); 7511afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner TypeName.clear(); 752407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 7531afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SmallVector<Type*, 8> EltTys; 7541afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (unsigned i = 1, e = Record.size(); i != e; ++i) { 7551afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (Type *T = getTypeByID(Record[i])) 7561afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner EltTys.push_back(T); 7571afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner else 7581afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner break; 7591afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } 7601afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (EltTys.size() != Record.size()-1) 7611afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return Error("invalid STRUCT type record"); 7621afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Res->setBody(EltTys, Record[0]); 7631afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ResultTy = Res; 7641afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner break; 7651afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } 7661afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: [] 7671afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (Record.size() != 1) 7681afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return Error("Invalid OPAQUE type record"); 7691afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 7701afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (NumRecords >= TypeList.size()) 7711afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return Error("invalid TYPE table"); 772407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 7731afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Check to see if this was forward referenced, if so fill in the temp. 7741afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 7751afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (Res) { 7761afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Res->setName(TypeName); 7771afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner TypeList[NumRecords] = 0; 7781afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } else // Otherwise, create a new struct with no body. 7793ebb64946bc8e7c8feba1b2044e7a47f80b3a83fChris Lattner Res = StructType::create(Context, TypeName); 7801afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner TypeName.clear(); 7811afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ResultTy = Res; 7821afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner break; 783407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman } 784caee0dccffb77a003681345ab3281bcf8684526cChris Lattner case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 785caee0dccffb77a003681345ab3281bcf8684526cChris Lattner if (Record.size() < 2) 786caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Invalid ARRAY type record"); 7871afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if ((ResultTy = getTypeByID(Record[1]))) 7881afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ResultTy = ArrayType::get(ResultTy, Record[0]); 7891afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner else 7901afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return Error("Invalid ARRAY type element"); 791caee0dccffb77a003681345ab3281bcf8684526cChris Lattner break; 792caee0dccffb77a003681345ab3281bcf8684526cChris Lattner case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 793caee0dccffb77a003681345ab3281bcf8684526cChris Lattner if (Record.size() < 2) 794caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Invalid VECTOR type record"); 7951afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if ((ResultTy = getTypeByID(Record[1]))) 7961afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ResultTy = VectorType::get(ResultTy, Record[0]); 7971afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner else 7981afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return Error("Invalid ARRAY type element"); 799caee0dccffb77a003681345ab3281bcf8684526cChris Lattner break; 800caee0dccffb77a003681345ab3281bcf8684526cChris Lattner } 801a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 8021afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (NumRecords >= TypeList.size()) 8031afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return Error("invalid TYPE table"); 8041afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner assert(ResultTy && "Didn't read a type?"); 8051afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner assert(TypeList[NumRecords] == 0 && "Already read type?"); 8061afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner TypeList[NumRecords++] = ResultTy; 8071afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } 8081afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner} 8091afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 810866971474ced63f725bd3dbf10fdb9e3badb7d9eChris Lattnerbool BitcodeReader::ParseValueSymbolTable() { 811e17b658c792abd4a1552144b8a8808e44970da76Chris Lattner if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) 8120b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner return Error("Malformed block record"); 8130b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner 8140b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner SmallVector<uint64_t, 64> Record; 815a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 8160b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner // Read all the records for this value table. 8170b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner SmallString<128> ValueName; 8180b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner while (1) { 8195a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 820acb6194f93440425776cdd730a2726fd95499505Joe Abbey 8215a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Entry.Kind) { 8225a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::SubBlock: // Handled for us already. 8235a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Error: 8245a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return Error("malformed value symbol table block"); 8255a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::EndBlock: 826f66d20da61af8672b2fe648283604408d42836ceChris Lattner return false; 8275a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Record: 8285a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner // The interesting case. 8295a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner break; 8300b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner } 831a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 8320b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner // Read a record. 8330b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner Record.clear(); 8345a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Stream.readRecord(Entry.ID, Record)) { 8350b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner default: // Default behavior: unknown type. 8360b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner break; 83715e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N] 8380b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner if (ConvertToString(Record, 1, ValueName)) 83988b7293f49b6f341e5f672c4bb24d7be17bc4a1fNick Lewycky return Error("Invalid VST_ENTRY record"); 8400b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner unsigned ValueID = Record[0]; 8410b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner if (ValueID >= ValueList.size()) 8420b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner return Error("Invalid Value ID in VST_ENTRY record"); 8430b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner Value *V = ValueList[ValueID]; 844a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 8453f53fa9a51c4ce7ba81170ca7ab2e49bd37281b0Daniel Dunbar V->setName(StringRef(ValueName.data(), ValueName.size())); 8460b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner ValueName.clear(); 8470b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner break; 848c8f8a242e40b22871241e37a2b1a935c2db7fe1bReid Spencer } 8495d7a5a4f53304869ae5b76771ab67213447b65a5Bill Wendling case bitc::VST_CODE_BBENTRY: { 850e825ed5a031937ad27d83bca12acf5533d7e0faeChris Lattner if (ConvertToString(Record, 1, ValueName)) 851e825ed5a031937ad27d83bca12acf5533d7e0faeChris Lattner return Error("Invalid VST_BBENTRY record"); 852e825ed5a031937ad27d83bca12acf5533d7e0faeChris Lattner BasicBlock *BB = getBasicBlock(Record[0]); 853e825ed5a031937ad27d83bca12acf5533d7e0faeChris Lattner if (BB == 0) 854e825ed5a031937ad27d83bca12acf5533d7e0faeChris Lattner return Error("Invalid BB ID in VST_BBENTRY record"); 855a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 8563f53fa9a51c4ce7ba81170ca7ab2e49bd37281b0Daniel Dunbar BB->setName(StringRef(ValueName.data(), ValueName.size())); 857e825ed5a031937ad27d83bca12acf5533d7e0faeChris Lattner ValueName.clear(); 858e825ed5a031937ad27d83bca12acf5533d7e0faeChris Lattner break; 8590b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner } 860c8f8a242e40b22871241e37a2b1a935c2db7fe1bReid Spencer } 8610b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner } 8620b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner} 8630b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner 864e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patelbool BitcodeReader::ParseMetadata() { 86523598502efa6a0c2daaa6c6efc519867c8445e8fDevang Patel unsigned NextMDValueNo = MDValueList.size(); 866e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel 867e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) 868e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel return Error("Malformed block record"); 869a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 870e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel SmallVector<uint64_t, 64> Record; 871a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 872e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel // Read all the records. 873e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel while (1) { 8745a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 875acb6194f93440425776cdd730a2726fd95499505Joe Abbey 8765a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Entry.Kind) { 8775a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::SubBlock: // Handled for us already. 8785a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Error: 8795a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner Error("malformed metadata block"); 8805a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return true; 8815a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::EndBlock: 882e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel return false; 8835a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Record: 8845a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner // The interesting case. 8855a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner break; 886e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel } 887a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 88824e64df7ec25b55aa872c2ef33728dfbb8c353c4Victor Hernandez bool IsFunctionLocal = false; 889e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel // Read a record. 890e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel Record.clear(); 8915a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner unsigned Code = Stream.readRecord(Entry.ID, Record); 8929b10dfb7d6ffb0e4466f908cd7d18212a45cfdacDan Gohman switch (Code) { 893e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel default: // Default behavior: ignore. 894e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel break; 895aa993142518648c1ffa61e7f52ff6d3a95d413fbDevang Patel case bitc::METADATA_NAME: { 8961ca114a66b666f932741d00d74636dc35ea1d466Chris Lattner // Read name of the named metadata. 897f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer SmallString<8> Name(Record.begin(), Record.end()); 898aa993142518648c1ffa61e7f52ff6d3a95d413fbDevang Patel Record.clear(); 899aa993142518648c1ffa61e7f52ff6d3a95d413fbDevang Patel Code = Stream.ReadCode(); 900aa993142518648c1ffa61e7f52ff6d3a95d413fbDevang Patel 9019d61dd9a088be975df4beb4632a39ed009bd0ef5Chris Lattner // METADATA_NAME is always followed by METADATA_NAMED_NODE. 9025a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner unsigned NextBitCode = Stream.readRecord(Code, Record); 9039d61dd9a088be975df4beb4632a39ed009bd0ef5Chris Lattner assert(NextBitCode == bitc::METADATA_NAMED_NODE); (void)NextBitCode; 904aa993142518648c1ffa61e7f52ff6d3a95d413fbDevang Patel 905aa993142518648c1ffa61e7f52ff6d3a95d413fbDevang Patel // Read named metadata elements. 906aa993142518648c1ffa61e7f52ff6d3a95d413fbDevang Patel unsigned Size = Record.size(); 90717aa92c92a925b4a674440c7ef088c223990e854Dan Gohman NamedMDNode *NMD = TheModule->getOrInsertNamedMetadata(Name); 908aa993142518648c1ffa61e7f52ff6d3a95d413fbDevang Patel for (unsigned i = 0; i != Size; ++i) { 90970644e92d810f36710bc289cda11e982b399fc88Chris Lattner MDNode *MD = dyn_cast<MDNode>(MDValueList.getValueFwdRef(Record[i])); 91070644e92d810f36710bc289cda11e982b399fc88Chris Lattner if (MD == 0) 91170644e92d810f36710bc289cda11e982b399fc88Chris Lattner return Error("Malformed metadata record"); 91217aa92c92a925b4a674440c7ef088c223990e854Dan Gohman NMD->addOperand(MD); 913aa993142518648c1ffa61e7f52ff6d3a95d413fbDevang Patel } 914aa993142518648c1ffa61e7f52ff6d3a95d413fbDevang Patel break; 915aa993142518648c1ffa61e7f52ff6d3a95d413fbDevang Patel } 9169d61dd9a088be975df4beb4632a39ed009bd0ef5Chris Lattner case bitc::METADATA_FN_NODE: 91724e64df7ec25b55aa872c2ef33728dfbb8c353c4Victor Hernandez IsFunctionLocal = true; 91824e64df7ec25b55aa872c2ef33728dfbb8c353c4Victor Hernandez // fall-through 9199d61dd9a088be975df4beb4632a39ed009bd0ef5Chris Lattner case bitc::METADATA_NODE: { 920ac80975ea4103fcceab38cde69d98d3fb3b01db4Dan Gohman if (Record.size() % 2 == 1) 9219d61dd9a088be975df4beb4632a39ed009bd0ef5Chris Lattner return Error("Invalid METADATA_NODE record"); 922a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 923104cf9e02b0ed94d4173869a598af6c6972a8660Devang Patel unsigned Size = Record.size(); 924104cf9e02b0ed94d4173869a598af6c6972a8660Devang Patel SmallVector<Value*, 8> Elts; 925104cf9e02b0ed94d4173869a598af6c6972a8660Devang Patel for (unsigned i = 0; i != Size; i += 2) { 926db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = getTypeByID(Record[i]); 9279d61dd9a088be975df4beb4632a39ed009bd0ef5Chris Lattner if (!Ty) return Error("Invalid METADATA_NODE record"); 928cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Ty->isMetadataTy()) 929d5ac40457b62f37f0abfb1d61064f7c7300e91eeDevang Patel Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); 930f012705c7e4ca8cf90b6b734ce1d5355daca5ba5Benjamin Kramer else if (!Ty->isVoidTy()) 931104cf9e02b0ed94d4173869a598af6c6972a8660Devang Patel Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty)); 932104cf9e02b0ed94d4173869a598af6c6972a8660Devang Patel else 933104cf9e02b0ed94d4173869a598af6c6972a8660Devang Patel Elts.push_back(NULL); 934104cf9e02b0ed94d4173869a598af6c6972a8660Devang Patel } 935ec9186bcf975c9ffa3ec7ca97867f0ec6eb55115Jay Foad Value *V = MDNode::getWhenValsUnresolved(Context, Elts, IsFunctionLocal); 93624e64df7ec25b55aa872c2ef33728dfbb8c353c4Victor Hernandez IsFunctionLocal = false; 93723598502efa6a0c2daaa6c6efc519867c8445e8fDevang Patel MDValueList.AssignValue(V, NextMDValueNo++); 938104cf9e02b0ed94d4173869a598af6c6972a8660Devang Patel break; 939104cf9e02b0ed94d4173869a598af6c6972a8660Devang Patel } 940e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel case bitc::METADATA_STRING: { 941f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer SmallString<8> String(Record.begin(), Record.end()); 942f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer Value *V = MDString::get(Context, String); 94323598502efa6a0c2daaa6c6efc519867c8445e8fDevang Patel MDValueList.AssignValue(V, NextMDValueNo++); 944e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel break; 945e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel } 946e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel case bitc::METADATA_KIND: { 947f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer if (Record.size() < 2) 948a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar return Error("Invalid METADATA_KIND record"); 949f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer 950a2148402ce39fb3aad09e98a32078d3853a01ae9Devang Patel unsigned Kind = Record[0]; 951f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer SmallString<8> Name(Record.begin()+1, Record.end()); 952f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer 953081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner unsigned NewKind = TheModule->getMDKindID(Name.str()); 95419538d1e9fb4f8198b94f8450c6fc43528d8b868Dan Gohman if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) 95519538d1e9fb4f8198b94f8450c6fc43528d8b868Dan Gohman return Error("Conflicting METADATA_KIND records"); 956e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel break; 957e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel } 958e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel } 959e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel } 960e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel} 961e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel 962d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung/// decodeSignRotatedValue - Decode a signed value stored with the sign bit in 9630eef08046e0758f1800f32c63b817fd22264577bChris Lattner/// the LSB for dense VBR encoding. 964d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Vounguint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) { 9650eef08046e0758f1800f32c63b817fd22264577bChris Lattner if ((V & 1) == 0) 9660eef08046e0758f1800f32c63b817fd22264577bChris Lattner return V >> 1; 967a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar if (V != 1) 9680eef08046e0758f1800f32c63b817fd22264577bChris Lattner return -(V >> 1); 9690eef08046e0758f1800f32c63b817fd22264577bChris Lattner // There is no such thing as -0 with integers. "-0" really means MININT. 9700eef08046e0758f1800f32c63b817fd22264577bChris Lattner return 1ULL << 63; 9710eef08046e0758f1800f32c63b817fd22264577bChris Lattner} 9720eef08046e0758f1800f32c63b817fd22264577bChris Lattner 97307d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner/// ResolveGlobalAndAliasInits - Resolve all of the initializers for global 97407d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner/// values and aliases that we can. 97507d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattnerbool BitcodeReader::ResolveGlobalAndAliasInits() { 97607d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist; 97707d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist; 978a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 97907d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner GlobalInitWorklist.swap(GlobalInits); 98007d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner AliasInitWorklist.swap(AliasInits); 98107d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner 98207d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner while (!GlobalInitWorklist.empty()) { 983198f34ac359c48018c6e1f784cf3770ead63b253Chris Lattner unsigned ValID = GlobalInitWorklist.back().second; 98407d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner if (ValID >= ValueList.size()) { 98507d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner // Not ready to resolve this yet, it requires something later in the file. 986198f34ac359c48018c6e1f784cf3770ead63b253Chris Lattner GlobalInits.push_back(GlobalInitWorklist.back()); 98707d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner } else { 98807d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 98907d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner GlobalInitWorklist.back().first->setInitializer(C); 99007d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner else 99107d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner return Error("Global variable initializer is not a constant!"); 99207d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner } 993a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar GlobalInitWorklist.pop_back(); 99407d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner } 99507d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner 99607d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner while (!AliasInitWorklist.empty()) { 99707d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner unsigned ValID = AliasInitWorklist.back().second; 99807d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner if (ValID >= ValueList.size()) { 99907d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner AliasInits.push_back(AliasInitWorklist.back()); 100007d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner } else { 100107d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 10027dde0ff0ba0afbf9d5e9b274533b05b79003b15fAnton Korobeynikov AliasInitWorklist.back().first->setAliasee(C); 100307d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner else 100407d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner return Error("Alias initializer is not a constant!"); 100507d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner } 1006a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar AliasInitWorklist.pop_back(); 100707d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner } 100807d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner return false; 100907d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner} 101007d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner 1011f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramerstatic APInt ReadWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) { 1012f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer SmallVector<uint64_t, 8> Words(Vals.size()); 1013f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer std::transform(Vals.begin(), Vals.end(), Words.begin(), 1014d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung BitcodeReader::decodeSignRotatedValue); 1015f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer 10161cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy return APInt(TypeBits, Words); 10171cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy} 10181cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy 1019866971474ced63f725bd3dbf10fdb9e3badb7d9eChris Lattnerbool BitcodeReader::ParseConstants() { 1020e17b658c792abd4a1552144b8a8808e44970da76Chris Lattner if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) 1021e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner return Error("Malformed block record"); 1022e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner 1023e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner SmallVector<uint64_t, 64> Record; 1024a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1025e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner // Read all the records for this value table. 1026db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *CurTy = Type::getInt32Ty(Context); 1027522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner unsigned NextCstNo = ValueList.size(); 1028e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner while (1) { 10295a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 1030acb6194f93440425776cdd730a2726fd95499505Joe Abbey 10315a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Entry.Kind) { 10325a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::SubBlock: // Handled for us already. 10335a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Error: 10345a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return Error("malformed block record in AST file"); 10355a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::EndBlock: 10365a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner if (NextCstNo != ValueList.size()) 10375a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return Error("Invalid constant reference!"); 1038acb6194f93440425776cdd730a2726fd95499505Joe Abbey 10395a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner // Once all the constants have been read, go through and resolve forward 10405a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner // references. 10415a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner ValueList.ResolveConstantForwardRefs(); 10425a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return false; 10435a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Record: 10445a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner // The interesting case. 1045ea693dfab48ee6fc07cc21abc20f487df5057a6bChris Lattner break; 1046e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner } 1047a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1048e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner // Read a record. 1049e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner Record.clear(); 1050e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner Value *V = 0; 10515a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner unsigned BitCode = Stream.readRecord(Entry.ID, Record); 10521224c386981f7948f298ed9ad444c40609570f2eDan Gohman switch (BitCode) { 1053e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner default: // Default behavior: unknown constant 1054e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner case bitc::CST_CODE_UNDEF: // UNDEF 10559e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson V = UndefValue::get(CurTy); 1056e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner break; 1057e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] 1058e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner if (Record.empty()) 1059e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner return Error("Malformed CST_SETTYPE record"); 1060e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner if (Record[0] >= TypeList.size()) 1061e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner return Error("Invalid Type ID in CST_SETTYPE record"); 1062e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner CurTy = TypeList[Record[0]]; 10630eef08046e0758f1800f32c63b817fd22264577bChris Lattner continue; // Skip the ValueList manipulation. 1064e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner case bitc::CST_CODE_NULL: // NULL 1065a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson V = Constant::getNullValue(CurTy); 1066e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner break; 1067e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner case bitc::CST_CODE_INTEGER: // INTEGER: [intval] 10681df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands if (!CurTy->isIntegerTy() || Record.empty()) 10690eef08046e0758f1800f32c63b817fd22264577bChris Lattner return Error("Invalid CST_INTEGER record"); 1070d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0])); 10710eef08046e0758f1800f32c63b817fd22264577bChris Lattner break; 107215e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval] 10731df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands if (!CurTy->isIntegerTy() || Record.empty()) 10740eef08046e0758f1800f32c63b817fd22264577bChris Lattner return Error("Invalid WIDE_INTEGER record"); 1075a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1076f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer APInt VInt = ReadWideAPInt(Record, 1077f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer cast<IntegerType>(CurTy)->getBitWidth()); 10781cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy V = ConstantInt::get(Context, VInt); 1079407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 10800eef08046e0758f1800f32c63b817fd22264577bChris Lattner break; 10810eef08046e0758f1800f32c63b817fd22264577bChris Lattner } 10823f6eb7419de437436265831fce92f62498556e08Dale Johannesen case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] 10830eef08046e0758f1800f32c63b817fd22264577bChris Lattner if (Record.empty()) 10840eef08046e0758f1800f32c63b817fd22264577bChris Lattner return Error("Invalid FLOAT record"); 1085ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman if (CurTy->isHalfTy()) 10860a29cb045444c13160e90fe7942a9d7c720185edTim Northover V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf, 10870a29cb045444c13160e90fe7942a9d7c720185edTim Northover APInt(16, (uint16_t)Record[0]))); 1088ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman else if (CurTy->isFloatTy()) 10890a29cb045444c13160e90fe7942a9d7c720185edTim Northover V = ConstantFP::get(Context, APFloat(APFloat::IEEEsingle, 10900a29cb045444c13160e90fe7942a9d7c720185edTim Northover APInt(32, (uint32_t)Record[0]))); 1091cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner else if (CurTy->isDoubleTy()) 10920a29cb045444c13160e90fe7942a9d7c720185edTim Northover V = ConstantFP::get(Context, APFloat(APFloat::IEEEdouble, 10930a29cb045444c13160e90fe7942a9d7c720185edTim Northover APInt(64, Record[0]))); 1094cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner else if (CurTy->isX86_FP80Ty()) { 10951b25cb2416c46a6cebf2a6c52235e9fe46a10d11Dale Johannesen // Bits are not stored the same way as a normal i80 APInt, compensate. 10961b25cb2416c46a6cebf2a6c52235e9fe46a10d11Dale Johannesen uint64_t Rearrange[2]; 10971b25cb2416c46a6cebf2a6c52235e9fe46a10d11Dale Johannesen Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16); 10981b25cb2416c46a6cebf2a6c52235e9fe46a10d11Dale Johannesen Rearrange[1] = Record[0] >> 48; 10990a29cb045444c13160e90fe7942a9d7c720185edTim Northover V = ConstantFP::get(Context, APFloat(APFloat::x87DoubleExtended, 11000a29cb045444c13160e90fe7942a9d7c720185edTim Northover APInt(80, Rearrange))); 1101cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner } else if (CurTy->isFP128Ty()) 11020a29cb045444c13160e90fe7942a9d7c720185edTim Northover V = ConstantFP::get(Context, APFloat(APFloat::IEEEquad, 11030a29cb045444c13160e90fe7942a9d7c720185edTim Northover APInt(128, Record))); 1104cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner else if (CurTy->isPPC_FP128Ty()) 11050a29cb045444c13160e90fe7942a9d7c720185edTim Northover V = ConstantFP::get(Context, APFloat(APFloat::PPCDoubleDouble, 11060a29cb045444c13160e90fe7942a9d7c720185edTim Northover APInt(128, Record))); 1107e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner else 11089e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson V = UndefValue::get(CurTy); 1109e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner break; 11103f6eb7419de437436265831fce92f62498556e08Dale Johannesen } 1111a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 111215e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] 111315e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner if (Record.empty()) 1114522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner return Error("Invalid CST_AGGREGATE record"); 1115a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 111615e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner unsigned Size = Record.size(); 1117d629efa0642110fbc90c28d4be3da54ffb359750Chris Lattner SmallVector<Constant*, 16> Elts; 1118a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1119db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *STy = dyn_cast<StructType>(CurTy)) { 1120522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner for (unsigned i = 0; i != Size; ++i) 112115e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner Elts.push_back(ValueList.getConstantFwdRef(Record[i], 1122522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner STy->getElementType(i))); 11238fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson V = ConstantStruct::get(STy, Elts); 1124db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner } else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) { 1125db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *EltTy = ATy->getElementType(); 1126522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner for (unsigned i = 0; i != Size; ++i) 112715e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 11281fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson V = ConstantArray::get(ATy, Elts); 1129db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner } else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) { 1130db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *EltTy = VTy->getElementType(); 1131522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner for (unsigned i = 0; i != Size; ++i) 113215e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 1133af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson V = ConstantVector::get(Elts); 1134522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner } else { 11359e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson V = UndefValue::get(CurTy); 1136522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner } 1137f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner break; 1138f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner } 11392237f8473580180c2a9571124f87c93991de342aChris Lattner case bitc::CST_CODE_STRING: // STRING: [values] 1140cb3d91b05b36a144dd0f3103ce4fda4cab356ad6Chris Lattner case bitc::CST_CODE_CSTRING: { // CSTRING: [values] 1141cb3d91b05b36a144dd0f3103ce4fda4cab356ad6Chris Lattner if (Record.empty()) 11422237f8473580180c2a9571124f87c93991de342aChris Lattner return Error("Invalid CST_STRING record"); 1143a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1144f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer SmallString<16> Elts(Record.begin(), Record.end()); 11452237f8473580180c2a9571124f87c93991de342aChris Lattner V = ConstantDataArray::getString(Context, Elts, 11462237f8473580180c2a9571124f87c93991de342aChris Lattner BitCode == bitc::CST_CODE_CSTRING); 1147ff7fc5dabef6931e7d23ee0613aa60e1d09dfbb0Chris Lattner break; 1148ff7fc5dabef6931e7d23ee0613aa60e1d09dfbb0Chris Lattner } 1149d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner case bitc::CST_CODE_DATA: {// DATA: [n x value] 1150d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner if (Record.empty()) 1151d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner return Error("Invalid CST_DATA record"); 1152407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 1153d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner Type *EltTy = cast<SequentialType>(CurTy)->getElementType(); 1154d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner unsigned Size = Record.size(); 1155407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 1156d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner if (EltTy->isIntegerTy(8)) { 1157d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner SmallVector<uint8_t, 16> Elts(Record.begin(), Record.end()); 1158d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner if (isa<VectorType>(CurTy)) 1159d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner V = ConstantDataVector::get(Context, Elts); 1160d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner else 1161d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner V = ConstantDataArray::get(Context, Elts); 1162d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner } else if (EltTy->isIntegerTy(16)) { 1163d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end()); 1164d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner if (isa<VectorType>(CurTy)) 1165d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner V = ConstantDataVector::get(Context, Elts); 1166d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner else 1167d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner V = ConstantDataArray::get(Context, Elts); 1168d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner } else if (EltTy->isIntegerTy(32)) { 1169d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner SmallVector<uint32_t, 16> Elts(Record.begin(), Record.end()); 1170d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner if (isa<VectorType>(CurTy)) 1171d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner V = ConstantDataVector::get(Context, Elts); 1172d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner else 1173d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner V = ConstantDataArray::get(Context, Elts); 1174d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner } else if (EltTy->isIntegerTy(64)) { 1175d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner SmallVector<uint64_t, 16> Elts(Record.begin(), Record.end()); 1176d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner if (isa<VectorType>(CurTy)) 1177d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner V = ConstantDataVector::get(Context, Elts); 1178d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner else 1179d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner V = ConstantDataArray::get(Context, Elts); 1180d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner } else if (EltTy->isFloatTy()) { 1181f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer SmallVector<float, 16> Elts(Size); 1182f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer std::transform(Record.begin(), Record.end(), Elts.begin(), BitsToFloat); 1183d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner if (isa<VectorType>(CurTy)) 1184d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner V = ConstantDataVector::get(Context, Elts); 1185d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner else 1186d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner V = ConstantDataArray::get(Context, Elts); 1187d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner } else if (EltTy->isDoubleTy()) { 1188f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer SmallVector<double, 16> Elts(Size); 1189f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer std::transform(Record.begin(), Record.end(), Elts.begin(), 1190f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer BitsToDouble); 1191d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner if (isa<VectorType>(CurTy)) 1192d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner V = ConstantDataVector::get(Context, Elts); 1193d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner else 1194d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner V = ConstantDataArray::get(Context, Elts); 1195d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner } else { 1196d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner return Error("Unknown element type in CE_DATA"); 1197d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner } 1198d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner break; 1199d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner } 1200d408f06048797a43b17a7740acb766cc5f0adfbbChris Lattner 1201f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] 1202f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner if (Record.size() < 3) return Error("Invalid CE_BINOP record"); 1203f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner int Opc = GetDecodedBinaryOpcode(Record[0], CurTy); 1204f66d20da61af8672b2fe648283604408d42836ceChris Lattner if (Opc < 0) { 12059e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson V = UndefValue::get(CurTy); // Unknown binop. 1206f66d20da61af8672b2fe648283604408d42836ceChris Lattner } else { 1207f66d20da61af8672b2fe648283604408d42836ceChris Lattner Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy); 1208f66d20da61af8672b2fe648283604408d42836ceChris Lattner Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy); 1209f8dbee7cea072eb63ae343759975109553697bcbDan Gohman unsigned Flags = 0; 1210f8dbee7cea072eb63ae343759975109553697bcbDan Gohman if (Record.size() >= 4) { 1211f8dbee7cea072eb63ae343759975109553697bcbDan Gohman if (Opc == Instruction::Add || 1212f8dbee7cea072eb63ae343759975109553697bcbDan Gohman Opc == Instruction::Sub || 1213f067d584a81ae771d301304ea885e55e2de8ee9aChris Lattner Opc == Instruction::Mul || 1214f067d584a81ae771d301304ea885e55e2de8ee9aChris Lattner Opc == Instruction::Shl) { 1215f8dbee7cea072eb63ae343759975109553697bcbDan Gohman if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 1216f8dbee7cea072eb63ae343759975109553697bcbDan Gohman Flags |= OverflowingBinaryOperator::NoSignedWrap; 1217f8dbee7cea072eb63ae343759975109553697bcbDan Gohman if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 1218f8dbee7cea072eb63ae343759975109553697bcbDan Gohman Flags |= OverflowingBinaryOperator::NoUnsignedWrap; 121935bda8914c0d1c02a6f90f42e7810c83150737e1Chris Lattner } else if (Opc == Instruction::SDiv || 1220f067d584a81ae771d301304ea885e55e2de8ee9aChris Lattner Opc == Instruction::UDiv || 1221f067d584a81ae771d301304ea885e55e2de8ee9aChris Lattner Opc == Instruction::LShr || 1222f067d584a81ae771d301304ea885e55e2de8ee9aChris Lattner Opc == Instruction::AShr) { 122335bda8914c0d1c02a6f90f42e7810c83150737e1Chris Lattner if (Record[3] & (1 << bitc::PEO_EXACT)) 1224f8dbee7cea072eb63ae343759975109553697bcbDan Gohman Flags |= SDivOperator::IsExact; 1225f8dbee7cea072eb63ae343759975109553697bcbDan Gohman } 1226f8dbee7cea072eb63ae343759975109553697bcbDan Gohman } 1227f8dbee7cea072eb63ae343759975109553697bcbDan Gohman V = ConstantExpr::get(Opc, LHS, RHS, Flags); 1228f66d20da61af8672b2fe648283604408d42836ceChris Lattner } 1229f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner break; 1230a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar } 1231f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] 1232f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner if (Record.size() < 3) return Error("Invalid CE_CAST record"); 1233f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner int Opc = GetDecodedCastOpcode(Record[0]); 1234f66d20da61af8672b2fe648283604408d42836ceChris Lattner if (Opc < 0) { 12359e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson V = UndefValue::get(CurTy); // Unknown cast. 1236f66d20da61af8672b2fe648283604408d42836ceChris Lattner } else { 1237db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *OpTy = getTypeByID(Record[1]); 1238bfcc38040b6a0667b7b7df9674d8a0ed1d104814Chris Lattner if (!OpTy) return Error("Invalid CE_CAST record"); 1239f66d20da61af8672b2fe648283604408d42836ceChris Lattner Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); 1240baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson V = ConstantExpr::getCast(Opc, Op, CurTy); 1241f66d20da61af8672b2fe648283604408d42836ceChris Lattner } 1242f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner break; 1243a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar } 1244dd8004dc73d091ccb3927dbbc3b41639a3738ae3Dan Gohman case bitc::CST_CODE_CE_INBOUNDS_GEP: 1245f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands] 124615e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner if (Record.size() & 1) return Error("Invalid CE_GEP record"); 1247f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner SmallVector<Constant*, 16> Elts; 124815e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 1249db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ElTy = getTypeByID(Record[i]); 1250f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner if (!ElTy) return Error("Invalid CE_GEP record"); 1251f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); 1252f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner } 1253dab3d29605a5c83db41b28176273ef55961120c1Jay Foad ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end()); 12544b5e207bf24ea9799547a0634acaf7398b32897cJay Foad V = ConstantExpr::getGetElementPtr(Elts[0], Indices, 12554b5e207bf24ea9799547a0634acaf7398b32897cJay Foad BitCode == 12564b5e207bf24ea9799547a0634acaf7398b32897cJay Foad bitc::CST_CODE_CE_INBOUNDS_GEP); 1257f66d20da61af8672b2fe648283604408d42836ceChris Lattner break; 1258f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner } 1259f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CST_CODE_CE_SELECT: // CE_SELECT: [opval#, opval#, opval#] 1260f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner if (Record.size() < 3) return Error("Invalid CE_SELECT record"); 1261e46b14acab1fcb7434783d2f0e00cfee681335f0Joe Abbey V = ConstantExpr::getSelect( 1262e46b14acab1fcb7434783d2f0e00cfee681335f0Joe Abbey ValueList.getConstantFwdRef(Record[0], 1263e46b14acab1fcb7434783d2f0e00cfee681335f0Joe Abbey Type::getInt1Ty(Context)), 1264e46b14acab1fcb7434783d2f0e00cfee681335f0Joe Abbey ValueList.getConstantFwdRef(Record[1],CurTy), 1265e46b14acab1fcb7434783d2f0e00cfee681335f0Joe Abbey ValueList.getConstantFwdRef(Record[2],CurTy)); 1266f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner break; 1267f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval] 1268f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner if (Record.size() < 3) return Error("Invalid CE_EXTRACTELT record"); 1269db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner VectorType *OpTy = 1270f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1271f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner if (OpTy == 0) return Error("Invalid CE_EXTRACTELT record"); 1272f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1273170a15e98dc6900df1ae40d03c5f0622d792fb45Joe Abbey Constant *Op1 = ValueList.getConstantFwdRef(Record[2], 1274e46b14acab1fcb7434783d2f0e00cfee681335f0Joe Abbey Type::getInt32Ty(Context)); 1275baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson V = ConstantExpr::getExtractElement(Op0, Op1); 1276f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner break; 1277f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner } 1278f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval] 1279db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1280f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner if (Record.size() < 3 || OpTy == 0) 1281f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner return Error("Invalid CE_INSERTELT record"); 1282f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 1283f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner Constant *Op1 = ValueList.getConstantFwdRef(Record[1], 1284f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner OpTy->getElementType()); 1285170a15e98dc6900df1ae40d03c5f0622d792fb45Joe Abbey Constant *Op2 = ValueList.getConstantFwdRef(Record[2], 1286e46b14acab1fcb7434783d2f0e00cfee681335f0Joe Abbey Type::getInt32Ty(Context)); 1287baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson V = ConstantExpr::getInsertElement(Op0, Op1, Op2); 1288f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner break; 1289f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner } 1290f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] 1291db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1292f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner if (Record.size() < 3 || OpTy == 0) 12930f123cf732ad249117b7471e37bf819633b76a6eNate Begeman return Error("Invalid CE_SHUFFLEVEC record"); 1294f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 1295f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); 1296db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 129774a77812d1785ad6c62226c52dcd4d129b3cdd0bOwen Anderson OpTy->getNumElements()); 1298f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy); 1299baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 1300f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner break; 1301f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner } 13020f123cf732ad249117b7471e37bf819633b76a6eNate Begeman case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval] 1303db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner VectorType *RTy = dyn_cast<VectorType>(CurTy); 1304db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner VectorType *OpTy = 1305f22b74608ede59dabc55fab66f2142f369f9dbfbDuncan Sands dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 13060f123cf732ad249117b7471e37bf819633b76a6eNate Begeman if (Record.size() < 4 || RTy == 0 || OpTy == 0) 13070f123cf732ad249117b7471e37bf819633b76a6eNate Begeman return Error("Invalid CE_SHUFVEC_EX record"); 13080f123cf732ad249117b7471e37bf819633b76a6eNate Begeman Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 13090f123cf732ad249117b7471e37bf819633b76a6eNate Begeman Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 1310db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 131174a77812d1785ad6c62226c52dcd4d129b3cdd0bOwen Anderson RTy->getNumElements()); 13120f123cf732ad249117b7471e37bf819633b76a6eNate Begeman Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy); 1313baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 13140f123cf732ad249117b7471e37bf819633b76a6eNate Begeman break; 13150f123cf732ad249117b7471e37bf819633b76a6eNate Begeman } 1316f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] 1317f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner if (Record.size() < 4) return Error("Invalid CE_CMP record"); 1318db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *OpTy = getTypeByID(Record[0]); 1319f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner if (OpTy == 0) return Error("Invalid CE_CMP record"); 1320f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1321f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 1322f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner 1323b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands if (OpTy->isFPOrFPVectorTy()) 1324baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson V = ConstantExpr::getFCmp(Record[3], Op0, Op1); 1325ac80ade1580378e484e24c9f66d2fa5b058e5891Nate Begeman else 1326baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson V = ConstantExpr::getICmp(Record[3], Op0, Op1); 1327f581c3b81ee793ce1dcce4b4755393e56148ea68Chris Lattner break; 1328522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner } 1329581600bfc3060ee13afb278cd87e25da5b5f7db2Chad Rosier // This maintains backward compatibility, pre-asm dialect keywords. 133027b25c2076cc6bcc5c319053e2cfd71f5a847010Chad Rosier // FIXME: Remove with the 4.0 release. 1331f16ae5889140e42aa9092016e99aa706221e11edChad Rosier case bitc::CST_CODE_INLINEASM_OLD: { 13322bce93a2ae0b944e9e83b01c5c5bcbe5962a5a8dChris Lattner if (Record.size() < 2) return Error("Invalid INLINEASM record"); 13332bce93a2ae0b944e9e83b01c5c5bcbe5962a5a8dChris Lattner std::string AsmStr, ConstrStr; 13344360298d2bf3c1ba8595a415cfa235df0bc76335Dale Johannesen bool HasSideEffects = Record[0] & 1; 13358ba2d5befc05ca73d3bac8708819bbbe759e2cf9Dale Johannesen bool IsAlignStack = Record[0] >> 1; 13362bce93a2ae0b944e9e83b01c5c5bcbe5962a5a8dChris Lattner unsigned AsmStrSize = Record[1]; 13372bce93a2ae0b944e9e83b01c5c5bcbe5962a5a8dChris Lattner if (2+AsmStrSize >= Record.size()) 13382bce93a2ae0b944e9e83b01c5c5bcbe5962a5a8dChris Lattner return Error("Invalid INLINEASM record"); 13392bce93a2ae0b944e9e83b01c5c5bcbe5962a5a8dChris Lattner unsigned ConstStrSize = Record[2+AsmStrSize]; 13402bce93a2ae0b944e9e83b01c5c5bcbe5962a5a8dChris Lattner if (3+AsmStrSize+ConstStrSize > Record.size()) 13412bce93a2ae0b944e9e83b01c5c5bcbe5962a5a8dChris Lattner return Error("Invalid INLINEASM record"); 1342a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 13432bce93a2ae0b944e9e83b01c5c5bcbe5962a5a8dChris Lattner for (unsigned i = 0; i != AsmStrSize; ++i) 13442bce93a2ae0b944e9e83b01c5c5bcbe5962a5a8dChris Lattner AsmStr += (char)Record[2+i]; 13452bce93a2ae0b944e9e83b01c5c5bcbe5962a5a8dChris Lattner for (unsigned i = 0; i != ConstStrSize; ++i) 13462bce93a2ae0b944e9e83b01c5c5bcbe5962a5a8dChris Lattner ConstrStr += (char)Record[3+AsmStrSize+i]; 1347db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType *PTy = cast<PointerType>(CurTy); 13482bce93a2ae0b944e9e83b01c5c5bcbe5962a5a8dChris Lattner V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), 13498ba2d5befc05ca73d3bac8708819bbbe759e2cf9Dale Johannesen AsmStr, ConstrStr, HasSideEffects, IsAlignStack); 13502bce93a2ae0b944e9e83b01c5c5bcbe5962a5a8dChris Lattner break; 13512bce93a2ae0b944e9e83b01c5c5bcbe5962a5a8dChris Lattner } 1352581600bfc3060ee13afb278cd87e25da5b5f7db2Chad Rosier // This version adds support for the asm dialect keywords (e.g., 1353581600bfc3060ee13afb278cd87e25da5b5f7db2Chad Rosier // inteldialect). 1354f16ae5889140e42aa9092016e99aa706221e11edChad Rosier case bitc::CST_CODE_INLINEASM: { 1355f16ae5889140e42aa9092016e99aa706221e11edChad Rosier if (Record.size() < 2) return Error("Invalid INLINEASM record"); 1356f16ae5889140e42aa9092016e99aa706221e11edChad Rosier std::string AsmStr, ConstrStr; 1357f16ae5889140e42aa9092016e99aa706221e11edChad Rosier bool HasSideEffects = Record[0] & 1; 1358f16ae5889140e42aa9092016e99aa706221e11edChad Rosier bool IsAlignStack = (Record[0] >> 1) & 1; 1359f16ae5889140e42aa9092016e99aa706221e11edChad Rosier unsigned AsmDialect = Record[0] >> 2; 1360f16ae5889140e42aa9092016e99aa706221e11edChad Rosier unsigned AsmStrSize = Record[1]; 1361f16ae5889140e42aa9092016e99aa706221e11edChad Rosier if (2+AsmStrSize >= Record.size()) 1362f16ae5889140e42aa9092016e99aa706221e11edChad Rosier return Error("Invalid INLINEASM record"); 1363f16ae5889140e42aa9092016e99aa706221e11edChad Rosier unsigned ConstStrSize = Record[2+AsmStrSize]; 1364f16ae5889140e42aa9092016e99aa706221e11edChad Rosier if (3+AsmStrSize+ConstStrSize > Record.size()) 1365f16ae5889140e42aa9092016e99aa706221e11edChad Rosier return Error("Invalid INLINEASM record"); 1366f16ae5889140e42aa9092016e99aa706221e11edChad Rosier 1367f16ae5889140e42aa9092016e99aa706221e11edChad Rosier for (unsigned i = 0; i != AsmStrSize; ++i) 1368f16ae5889140e42aa9092016e99aa706221e11edChad Rosier AsmStr += (char)Record[2+i]; 1369f16ae5889140e42aa9092016e99aa706221e11edChad Rosier for (unsigned i = 0; i != ConstStrSize; ++i) 1370f16ae5889140e42aa9092016e99aa706221e11edChad Rosier ConstrStr += (char)Record[3+AsmStrSize+i]; 1371f16ae5889140e42aa9092016e99aa706221e11edChad Rosier PointerType *PTy = cast<PointerType>(CurTy); 1372f16ae5889140e42aa9092016e99aa706221e11edChad Rosier V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), 1373f16ae5889140e42aa9092016e99aa706221e11edChad Rosier AsmStr, ConstrStr, HasSideEffects, IsAlignStack, 1374581600bfc3060ee13afb278cd87e25da5b5f7db2Chad Rosier InlineAsm::AsmDialect(AsmDialect)); 1375f16ae5889140e42aa9092016e99aa706221e11edChad Rosier break; 1376f16ae5889140e42aa9092016e99aa706221e11edChad Rosier } 137750b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner case bitc::CST_CODE_BLOCKADDRESS:{ 137850b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner if (Record.size() < 3) return Error("Invalid CE_BLOCKADDRESS record"); 1379db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *FnTy = getTypeByID(Record[0]); 138050b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner if (FnTy == 0) return Error("Invalid CE_BLOCKADDRESS record"); 138150b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner Function *Fn = 138250b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy)); 138350b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner if (Fn == 0) return Error("Invalid CE_BLOCKADDRESS record"); 1384122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer 1385122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer // If the function is already parsed we can insert the block address right 1386122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer // away. 1387122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer if (!Fn->empty()) { 1388122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer Function::iterator BBI = Fn->begin(), BBE = Fn->end(); 1389122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer for (size_t I = 0, E = Record[2]; I != E; ++I) { 1390122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer if (BBI == BBE) 1391122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer return Error("Invalid blockaddress block #"); 1392122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer ++BBI; 1393122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer } 1394122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer V = BlockAddress::get(Fn, BBI); 1395122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer } else { 1396122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer // Otherwise insert a placeholder and remember it so it can be inserted 1397122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer // when the function is parsed. 1398122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer GlobalVariable *FwdRef = new GlobalVariable(*Fn->getParent(), 1399122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer Type::getInt8Ty(Context), 140050b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner false, GlobalValue::InternalLinkage, 1401122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer 0, ""); 1402122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer BlockAddrFwdRefs[Fn].push_back(std::make_pair(Record[2], FwdRef)); 1403122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer V = FwdRef; 1404122f5e5a5b04e3c364d13913c14ee14f9b7ba387Benjamin Kramer } 140550b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner break; 1406407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman } 1407522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner } 1408a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1409a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner ValueList.AssignValue(V, NextCstNo); 1410522b7b104c864da81c19d8b16c43b7a1f6a2fc40Chris Lattner ++NextCstNo; 1411e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner } 1412e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner} 1413caee0dccffb77a003681345ab3281bcf8684526cChris Lattner 1414cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosierbool BitcodeReader::ParseUseLists() { 1415cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier if (Stream.EnterSubBlock(bitc::USELIST_BLOCK_ID)) 1416cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier return Error("Malformed block record"); 1417cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier 1418cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier SmallVector<uint64_t, 64> Record; 1419407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 1420cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier // Read all the records. 1421cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier while (1) { 14225a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 1423acb6194f93440425776cdd730a2726fd95499505Joe Abbey 14245a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Entry.Kind) { 14255a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::SubBlock: // Handled for us already. 14265a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Error: 14275a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return Error("malformed use list block"); 14285a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::EndBlock: 1429cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier return false; 14305a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Record: 14315a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner // The interesting case. 14325a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner break; 1433cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier } 1434407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 1435cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier // Read a use list record. 1436cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier Record.clear(); 14375a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Stream.readRecord(Entry.ID, Record)) { 1438cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier default: // Default behavior: unknown type. 1439cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier break; 1440cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier case bitc::USELIST_CODE_ENTRY: { // USELIST_CODE_ENTRY: TBD. 1441cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier unsigned RecordLength = Record.size(); 1442cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier if (RecordLength < 1) 1443cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier return Error ("Invalid UseList reader!"); 1444cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier UseListRecords.push_back(Record); 1445cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier break; 1446cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier } 1447cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier } 1448cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier } 1449cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier} 1450cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier 1451980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner/// RememberAndSkipFunctionBody - When we see the block for a function body, 1452980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner/// remember where it is and then skip it. This lets us lazily deserialize the 1453980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner/// functions. 1454980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattnerbool BitcodeReader::RememberAndSkipFunctionBody() { 145548f848716e80d01619b239111db48bfac77baad1Chris Lattner // Get the function we are talking about. 145648f848716e80d01619b239111db48bfac77baad1Chris Lattner if (FunctionsWithBodies.empty()) 145748f848716e80d01619b239111db48bfac77baad1Chris Lattner return Error("Insufficient function protos"); 1458a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 145948f848716e80d01619b239111db48bfac77baad1Chris Lattner Function *Fn = FunctionsWithBodies.back(); 146048f848716e80d01619b239111db48bfac77baad1Chris Lattner FunctionsWithBodies.pop_back(); 1461a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 146248f848716e80d01619b239111db48bfac77baad1Chris Lattner // Save the current stream state. 146348f848716e80d01619b239111db48bfac77baad1Chris Lattner uint64_t CurBit = Stream.GetCurrentBitNo(); 1464f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin DeferredFunctionInfo[Fn] = CurBit; 1465a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 146648f848716e80d01619b239111db48bfac77baad1Chris Lattner // Skip over the function block for now. 146748f848716e80d01619b239111db48bfac77baad1Chris Lattner if (Stream.SkipBlock()) 146848f848716e80d01619b239111db48bfac77baad1Chris Lattner return Error("Malformed block record"); 146948f848716e80d01619b239111db48bfac77baad1Chris Lattner return false; 147048f848716e80d01619b239111db48bfac77baad1Chris Lattner} 147148f848716e80d01619b239111db48bfac77baad1Chris Lattner 14722ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuffbool BitcodeReader::GlobalCleanup() { 14732ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff // Patch the initializers for globals and aliases up. 14742ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff ResolveGlobalAndAliasInits(); 14752ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (!GlobalInits.empty() || !AliasInits.empty()) 14762ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff return Error("Malformed global initializer set"); 14772ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff 14782ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff // Look for intrinsic functions which need to be upgraded at some point 14792ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); 14802ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff FI != FE; ++FI) { 14812ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff Function *NewFn; 14822ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (UpgradeIntrinsicFunction(FI, NewFn)) 14832ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn)); 14842ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff } 14852ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff 14862ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff // Look for global variables which need to be renamed. 14872ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff for (Module::global_iterator 14882ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff GI = TheModule->global_begin(), GE = TheModule->global_end(); 14892ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff GI != GE; ++GI) 14902ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff UpgradeGlobalVariable(GI); 14912ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff // Force deallocation of memory for these vectors to favor the client that 14922ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff // want lazy deserialization. 14932ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); 14942ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); 14952ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff return false; 14962ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff} 14972ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff 14982ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuffbool BitcodeReader::ParseModule(bool Resume) { 14992ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (Resume) 15002ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff Stream.JumpToBit(NextUnreadBit); 15012ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 1502caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Malformed block record"); 1503caee0dccffb77a003681345ab3281bcf8684526cChris Lattner 1504caee0dccffb77a003681345ab3281bcf8684526cChris Lattner SmallVector<uint64_t, 64> Record; 1505caee0dccffb77a003681345ab3281bcf8684526cChris Lattner std::vector<std::string> SectionTable; 15065eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen std::vector<std::string> GCTable; 1507caee0dccffb77a003681345ab3281bcf8684526cChris Lattner 1508caee0dccffb77a003681345ab3281bcf8684526cChris Lattner // Read all the records for this module. 15095a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner while (1) { 15105a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner BitstreamEntry Entry = Stream.advance(); 1511acb6194f93440425776cdd730a2726fd95499505Joe Abbey 15125a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Entry.Kind) { 15135a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Error: 15145a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner Error("malformed module block"); 15155a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return true; 15165a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::EndBlock: 15172ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff return GlobalCleanup(); 1518acb6194f93440425776cdd730a2726fd95499505Joe Abbey 15195a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::SubBlock: 15205a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Entry.ID) { 1521caee0dccffb77a003681345ab3281bcf8684526cChris Lattner default: // Skip unknown content. 1522caee0dccffb77a003681345ab3281bcf8684526cChris Lattner if (Stream.SkipBlock()) 1523caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Malformed block record"); 1524caee0dccffb77a003681345ab3281bcf8684526cChris Lattner break; 15253f7998054a4b92c1823b412f1608259154dd0bbeChris Lattner case bitc::BLOCKINFO_BLOCK_ID: 15263f7998054a4b92c1823b412f1608259154dd0bbeChris Lattner if (Stream.ReadBlockInfoBlock()) 15273f7998054a4b92c1823b412f1608259154dd0bbeChris Lattner return Error("Malformed BlockInfoBlock"); 15283f7998054a4b92c1823b412f1608259154dd0bbeChris Lattner break; 152948c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner case bitc::PARAMATTR_BLOCK_ID: 15300598866c052147c31b808391f58434ce3dbfb838Devang Patel if (ParseAttributeBlock()) 153148c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner return true; 153248c85b84c1b66fb6a1b0d2afddf33da5bd82960dChris Lattner break; 1533c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling case bitc::PARAMATTR_GROUP_BLOCK_ID: 1534c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling if (ParseAttributeGroupBlock()) 1535c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling return true; 1536c3ba0a821b359060d76453023f3852954e6a5ee3Bill Wendling break; 15371afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner case bitc::TYPE_BLOCK_ID_NEW: 1538866971474ced63f725bd3dbf10fdb9e3badb7d9eChris Lattner if (ParseTypeTable()) 1539caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return true; 1540caee0dccffb77a003681345ab3281bcf8684526cChris Lattner break; 15410b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner case bitc::VALUE_SYMTAB_BLOCK_ID: 1542866971474ced63f725bd3dbf10fdb9e3badb7d9eChris Lattner if (ParseValueSymbolTable()) 15430b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner return true; 15442ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff SeenValueSymbolTable = true; 15450b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner break; 1546e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner case bitc::CONSTANTS_BLOCK_ID: 1547866971474ced63f725bd3dbf10fdb9e3badb7d9eChris Lattner if (ParseConstants() || ResolveGlobalAndAliasInits()) 1548e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner return true; 1549e16504eb4ef8f09611cdf6e9a0be9eb886b4ed89Chris Lattner break; 1550e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel case bitc::METADATA_BLOCK_ID: 1551e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel if (ParseMetadata()) 1552e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel return true; 1553e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel break; 155448f848716e80d01619b239111db48bfac77baad1Chris Lattner case bitc::FUNCTION_BLOCK_ID: 155548f848716e80d01619b239111db48bfac77baad1Chris Lattner // If this is the first function body we've seen, reverse the 155648f848716e80d01619b239111db48bfac77baad1Chris Lattner // FunctionsWithBodies list. 15572ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (!SeenFirstFunctionBody) { 155848f848716e80d01619b239111db48bfac77baad1Chris Lattner std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end()); 15592ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (GlobalCleanup()) 15602ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff return true; 15612ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff SeenFirstFunctionBody = true; 156248f848716e80d01619b239111db48bfac77baad1Chris Lattner } 1563acb6194f93440425776cdd730a2726fd95499505Joe Abbey 1564980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner if (RememberAndSkipFunctionBody()) 156548f848716e80d01619b239111db48bfac77baad1Chris Lattner return true; 15662ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff // For streaming bitcode, suspend parsing when we reach the function 15672ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff // bodies. Subsequent materialization calls will resume it when 15682ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff // necessary. For streaming, the function bodies must be at the end of 15692ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff // the bitcode. If the bitcode file is old, the symbol table will be 15702ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff // at the end instead and will not have been seen yet. In this case, 15712ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff // just finish the parse now. 15722ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (LazyStreamer && SeenValueSymbolTable) { 15732ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff NextUnreadBit = Stream.GetCurrentBitNo(); 15742ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff return false; 15752ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff } 157648f848716e80d01619b239111db48bfac77baad1Chris Lattner break; 1577cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier case bitc::USELIST_BLOCK_ID: 1578cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier if (ParseUseLists()) 1579cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier return true; 1580cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier break; 1581caee0dccffb77a003681345ab3281bcf8684526cChris Lattner } 1582caee0dccffb77a003681345ab3281bcf8684526cChris Lattner continue; 1583acb6194f93440425776cdd730a2726fd95499505Joe Abbey 15845a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Record: 15855a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner // The interesting case. 15865a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner break; 1587caee0dccffb77a003681345ab3281bcf8684526cChris Lattner } 1588a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1589a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1590caee0dccffb77a003681345ab3281bcf8684526cChris Lattner // Read a record. 15915a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Stream.readRecord(Entry.ID, Record)) { 1592caee0dccffb77a003681345ab3281bcf8684526cChris Lattner default: break; // Default behavior, ignore unknown content. 1593d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung case bitc::MODULE_CODE_VERSION: { // VERSION: [version#] 1594caee0dccffb77a003681345ab3281bcf8684526cChris Lattner if (Record.size() < 1) 1595caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Malformed MODULE_CODE_VERSION"); 1596d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung // Only version #0 and #1 are supported so far. 1597d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung unsigned module_version = Record[0]; 1598d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung switch (module_version) { 1599d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung default: return Error("Unknown bitstream version!"); 1600d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung case 0: 1601d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung UseRelativeIDs = false; 1602d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung break; 1603d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung case 1: 1604d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung UseRelativeIDs = true; 1605d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung break; 1606d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung } 1607caee0dccffb77a003681345ab3281bcf8684526cChris Lattner break; 1608d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung } 160915e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 1610caee0dccffb77a003681345ab3281bcf8684526cChris Lattner std::string S; 1611caee0dccffb77a003681345ab3281bcf8684526cChris Lattner if (ConvertToString(Record, 0, S)) 1612caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Invalid MODULE_CODE_TRIPLE record"); 1613caee0dccffb77a003681345ab3281bcf8684526cChris Lattner TheModule->setTargetTriple(S); 1614caee0dccffb77a003681345ab3281bcf8684526cChris Lattner break; 1615caee0dccffb77a003681345ab3281bcf8684526cChris Lattner } 161615e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] 1617caee0dccffb77a003681345ab3281bcf8684526cChris Lattner std::string S; 1618caee0dccffb77a003681345ab3281bcf8684526cChris Lattner if (ConvertToString(Record, 0, S)) 1619caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Invalid MODULE_CODE_DATALAYOUT record"); 1620caee0dccffb77a003681345ab3281bcf8684526cChris Lattner TheModule->setDataLayout(S); 1621caee0dccffb77a003681345ab3281bcf8684526cChris Lattner break; 1622caee0dccffb77a003681345ab3281bcf8684526cChris Lattner } 162315e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] 1624caee0dccffb77a003681345ab3281bcf8684526cChris Lattner std::string S; 1625caee0dccffb77a003681345ab3281bcf8684526cChris Lattner if (ConvertToString(Record, 0, S)) 1626caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Invalid MODULE_CODE_ASM record"); 1627caee0dccffb77a003681345ab3281bcf8684526cChris Lattner TheModule->setModuleInlineAsm(S); 1628caee0dccffb77a003681345ab3281bcf8684526cChris Lattner break; 1629caee0dccffb77a003681345ab3281bcf8684526cChris Lattner } 16303defc0bfa600cc253f0cba0fe781aa49435d968aBill Wendling case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N] 16313defc0bfa600cc253f0cba0fe781aa49435d968aBill Wendling // FIXME: Remove in 4.0. 16323defc0bfa600cc253f0cba0fe781aa49435d968aBill Wendling std::string S; 16333defc0bfa600cc253f0cba0fe781aa49435d968aBill Wendling if (ConvertToString(Record, 0, S)) 16343defc0bfa600cc253f0cba0fe781aa49435d968aBill Wendling return Error("Invalid MODULE_CODE_DEPLIB record"); 16353defc0bfa600cc253f0cba0fe781aa49435d968aBill Wendling // Ignore value. 16363defc0bfa600cc253f0cba0fe781aa49435d968aBill Wendling break; 16373defc0bfa600cc253f0cba0fe781aa49435d968aBill Wendling } 163815e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] 1639caee0dccffb77a003681345ab3281bcf8684526cChris Lattner std::string S; 1640caee0dccffb77a003681345ab3281bcf8684526cChris Lattner if (ConvertToString(Record, 0, S)) 1641caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Invalid MODULE_CODE_SECTIONNAME record"); 1642caee0dccffb77a003681345ab3281bcf8684526cChris Lattner SectionTable.push_back(S); 1643caee0dccffb77a003681345ab3281bcf8684526cChris Lattner break; 1644caee0dccffb77a003681345ab3281bcf8684526cChris Lattner } 16455eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N] 164680a75bfae980df96f969f1c05b0c4a80ce975240Gordon Henriksen std::string S; 164780a75bfae980df96f969f1c05b0c4a80ce975240Gordon Henriksen if (ConvertToString(Record, 0, S)) 16485eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen return Error("Invalid MODULE_CODE_GCNAME record"); 16495eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen GCTable.push_back(S); 165080a75bfae980df96f969f1c05b0c4a80ce975240Gordon Henriksen break; 165180a75bfae980df96f969f1c05b0c4a80ce975240Gordon Henriksen } 1652fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb // GLOBALVAR: [pointer type, isconst, initid, 1653bea4626f93c830e31f82cc947df28fdae583cd09Rafael Espindola // linkage, alignment, section, visibility, threadlocal, 1654bea4626f93c830e31f82cc947df28fdae583cd09Rafael Espindola // unnamed_addr] 1655caee0dccffb77a003681345ab3281bcf8684526cChris Lattner case bitc::MODULE_CODE_GLOBALVAR: { 165636d5e7d31be61f631ace0488f0d6cd71b8f31a16Chris Lattner if (Record.size() < 6) 1657caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Invalid MODULE_CODE_GLOBALVAR record"); 1658db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = getTypeByID(Record[0]); 1659f22b74608ede59dabc55fab66f2142f369f9dbfbDuncan Sands if (!Ty) return Error("Invalid MODULE_CODE_GLOBALVAR record"); 16601df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands if (!Ty->isPointerTy()) 1661caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Global not a pointer type!"); 1662fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); 1663caee0dccffb77a003681345ab3281bcf8684526cChris Lattner Ty = cast<PointerType>(Ty)->getElementType(); 1664a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1665caee0dccffb77a003681345ab3281bcf8684526cChris Lattner bool isConstant = Record[1]; 1666caee0dccffb77a003681345ab3281bcf8684526cChris Lattner GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]); 1667caee0dccffb77a003681345ab3281bcf8684526cChris Lattner unsigned Alignment = (1 << Record[4]) >> 1; 1668caee0dccffb77a003681345ab3281bcf8684526cChris Lattner std::string Section; 1669caee0dccffb77a003681345ab3281bcf8684526cChris Lattner if (Record[5]) { 1670caee0dccffb77a003681345ab3281bcf8684526cChris Lattner if (Record[5]-1 >= SectionTable.size()) 1671caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Invalid section ID"); 1672caee0dccffb77a003681345ab3281bcf8684526cChris Lattner Section = SectionTable[Record[5]-1]; 1673caee0dccffb77a003681345ab3281bcf8684526cChris Lattner } 167436d5e7d31be61f631ace0488f0d6cd71b8f31a16Chris Lattner GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; 16755f32c01dead5623d874f442b34762f9d111be4cfChris Lattner if (Record.size() > 6) 16765f32c01dead5623d874f442b34762f9d111be4cfChris Lattner Visibility = GetDecodedVisibility(Record[6]); 1677ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg 1678ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal; 16795f32c01dead5623d874f442b34762f9d111be4cfChris Lattner if (Record.size() > 7) 1680ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg TLM = GetDecodedThreadLocalMode(Record[7]); 1681caee0dccffb77a003681345ab3281bcf8684526cChris Lattner 1682bea4626f93c830e31f82cc947df28fdae583cd09Rafael Espindola bool UnnamedAddr = false; 1683bea4626f93c830e31f82cc947df28fdae583cd09Rafael Espindola if (Record.size() > 8) 1684bea4626f93c830e31f82cc947df28fdae583cd09Rafael Espindola UnnamedAddr = Record[8]; 1685bea4626f93c830e31f82cc947df28fdae583cd09Rafael Espindola 1686a2de37c897556fbd1f94a3ed84ad27accd8f8debMichael Gottesman bool ExternallyInitialized = false; 1687a2de37c897556fbd1f94a3ed84ad27accd8f8debMichael Gottesman if (Record.size() > 9) 1688a2de37c897556fbd1f94a3ed84ad27accd8f8debMichael Gottesman ExternallyInitialized = Record[9]; 1689a2de37c897556fbd1f94a3ed84ad27accd8f8debMichael Gottesman 1690caee0dccffb77a003681345ab3281bcf8684526cChris Lattner GlobalVariable *NewGV = 1691a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar new GlobalVariable(*TheModule, Ty, isConstant, Linkage, 0, "", 0, 1692a2de37c897556fbd1f94a3ed84ad27accd8f8debMichael Gottesman TLM, AddressSpace, ExternallyInitialized); 1693caee0dccffb77a003681345ab3281bcf8684526cChris Lattner NewGV->setAlignment(Alignment); 1694caee0dccffb77a003681345ab3281bcf8684526cChris Lattner if (!Section.empty()) 1695caee0dccffb77a003681345ab3281bcf8684526cChris Lattner NewGV->setSection(Section); 1696caee0dccffb77a003681345ab3281bcf8684526cChris Lattner NewGV->setVisibility(Visibility); 1697bea4626f93c830e31f82cc947df28fdae583cd09Rafael Espindola NewGV->setUnnamedAddr(UnnamedAddr); 1698a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 16990b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner ValueList.push_back(NewGV); 1700a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 17016dbfd7bfbcc7a69c978452560033fa5953db2cbfChris Lattner // Remember which value to use for the global initializer. 17026dbfd7bfbcc7a69c978452560033fa5953db2cbfChris Lattner if (unsigned InitID = Record[2]) 17036dbfd7bfbcc7a69c978452560033fa5953db2cbfChris Lattner GlobalInits.push_back(std::make_pair(NewGV, InitID-1)); 1704caee0dccffb77a003681345ab3281bcf8684526cChris Lattner break; 1705caee0dccffb77a003681345ab3281bcf8684526cChris Lattner } 1706a9bb713130b073276a53a38fe0c37d314a3f1fc1Chris Lattner // FUNCTION: [type, callingconv, isproto, linkage, paramattr, 1707bea4626f93c830e31f82cc947df28fdae583cd09Rafael Espindola // alignment, section, visibility, gc, unnamed_addr] 1708caee0dccffb77a003681345ab3281bcf8684526cChris Lattner case bitc::MODULE_CODE_FUNCTION: { 1709a9bb713130b073276a53a38fe0c37d314a3f1fc1Chris Lattner if (Record.size() < 8) 1710caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Invalid MODULE_CODE_FUNCTION record"); 1711db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = getTypeByID(Record[0]); 1712f22b74608ede59dabc55fab66f2142f369f9dbfbDuncan Sands if (!Ty) return Error("Invalid MODULE_CODE_FUNCTION record"); 17131df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands if (!Ty->isPointerTy()) 1714caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Function not a pointer type!"); 1715db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner FunctionType *FTy = 1716caee0dccffb77a003681345ab3281bcf8684526cChris Lattner dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType()); 1717caee0dccffb77a003681345ab3281bcf8684526cChris Lattner if (!FTy) 1718caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Function not a pointer to function type!"); 1719caee0dccffb77a003681345ab3281bcf8684526cChris Lattner 1720051a950000e21935165db56695e35bade668193bGabor Greif Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, 1721051a950000e21935165db56695e35bade668193bGabor Greif "", TheModule); 1722caee0dccffb77a003681345ab3281bcf8684526cChris Lattner 172365c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel Func->setCallingConv(static_cast<CallingConv::ID>(Record[1])); 172448f848716e80d01619b239111db48bfac77baad1Chris Lattner bool isProto = Record[2]; 1725caee0dccffb77a003681345ab3281bcf8684526cChris Lattner Func->setLinkage(GetDecodedLinkage(Record[3])); 17260598866c052147c31b808391f58434ce3dbfb838Devang Patel Func->setAttributes(getAttributes(Record[4])); 1727a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1728a9bb713130b073276a53a38fe0c37d314a3f1fc1Chris Lattner Func->setAlignment((1 << Record[5]) >> 1); 1729a9bb713130b073276a53a38fe0c37d314a3f1fc1Chris Lattner if (Record[6]) { 1730a9bb713130b073276a53a38fe0c37d314a3f1fc1Chris Lattner if (Record[6]-1 >= SectionTable.size()) 1731caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Invalid section ID"); 1732a9bb713130b073276a53a38fe0c37d314a3f1fc1Chris Lattner Func->setSection(SectionTable[Record[6]-1]); 1733caee0dccffb77a003681345ab3281bcf8684526cChris Lattner } 1734a9bb713130b073276a53a38fe0c37d314a3f1fc1Chris Lattner Func->setVisibility(GetDecodedVisibility(Record[7])); 173580a75bfae980df96f969f1c05b0c4a80ce975240Gordon Henriksen if (Record.size() > 8 && Record[8]) { 17365eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen if (Record[8]-1 > GCTable.size()) 17375eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen return Error("Invalid GC ID"); 17385eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen Func->setGC(GCTable[Record[8]-1].c_str()); 173980a75bfae980df96f969f1c05b0c4a80ce975240Gordon Henriksen } 1740bea4626f93c830e31f82cc947df28fdae583cd09Rafael Espindola bool UnnamedAddr = false; 1741bea4626f93c830e31f82cc947df28fdae583cd09Rafael Espindola if (Record.size() > 9) 1742bea4626f93c830e31f82cc947df28fdae583cd09Rafael Espindola UnnamedAddr = Record[9]; 1743bea4626f93c830e31f82cc947df28fdae583cd09Rafael Espindola Func->setUnnamedAddr(UnnamedAddr); 17440b2482a1ebd07a3b1cec660681add46c927970f2Chris Lattner ValueList.push_back(Func); 1745a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 174648f848716e80d01619b239111db48bfac77baad1Chris Lattner // If this is a function with a body, remember the prototype we are 174748f848716e80d01619b239111db48bfac77baad1Chris Lattner // creating now, so that we can match up the body with them later. 17482ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (!isProto) { 174948f848716e80d01619b239111db48bfac77baad1Chris Lattner FunctionsWithBodies.push_back(Func); 17502ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (LazyStreamer) DeferredFunctionInfo[Func] = 0; 17512ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff } 1752caee0dccffb77a003681345ab3281bcf8684526cChris Lattner break; 1753caee0dccffb77a003681345ab3281bcf8684526cChris Lattner } 175491342d8873a84b2809e5ed120cabb75902034355Anton Korobeynikov // ALIAS: [alias type, aliasee val#, linkage] 1755f8342b98663096186c3a367f7d0fd5ebb7064a52Anton Korobeynikov // ALIAS: [alias type, aliasee val#, linkage, visibility] 1756198f34ac359c48018c6e1f784cf3770ead63b253Chris Lattner case bitc::MODULE_CODE_ALIAS: { 175707d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner if (Record.size() < 3) 175807d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner return Error("Invalid MODULE_ALIAS record"); 1759db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = getTypeByID(Record[0]); 1760f22b74608ede59dabc55fab66f2142f369f9dbfbDuncan Sands if (!Ty) return Error("Invalid MODULE_ALIAS record"); 17611df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands if (!Ty->isPointerTy()) 176207d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner return Error("Function not a pointer type!"); 1763a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 176407d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]), 176507d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner "", 0, TheModule); 176691342d8873a84b2809e5ed120cabb75902034355Anton Korobeynikov // Old bitcode files didn't have visibility field. 176791342d8873a84b2809e5ed120cabb75902034355Anton Korobeynikov if (Record.size() > 3) 176891342d8873a84b2809e5ed120cabb75902034355Anton Korobeynikov NewGA->setVisibility(GetDecodedVisibility(Record[3])); 176907d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner ValueList.push_back(NewGA); 177007d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner AliasInits.push_back(std::make_pair(NewGA, Record[1])); 177107d98b4afbdcbb4eed048400d9116de1ec83e866Chris Lattner break; 1772caee0dccffb77a003681345ab3281bcf8684526cChris Lattner } 1773198f34ac359c48018c6e1f784cf3770ead63b253Chris Lattner /// MODULE_CODE_PURGEVALS: [numvals] 1774198f34ac359c48018c6e1f784cf3770ead63b253Chris Lattner case bitc::MODULE_CODE_PURGEVALS: 1775198f34ac359c48018c6e1f784cf3770ead63b253Chris Lattner // Trim down the value list to the specified size. 1776198f34ac359c48018c6e1f784cf3770ead63b253Chris Lattner if (Record.size() < 1 || Record[0] > ValueList.size()) 1777198f34ac359c48018c6e1f784cf3770ead63b253Chris Lattner return Error("Invalid MODULE_PURGEVALS record"); 1778198f34ac359c48018c6e1f784cf3770ead63b253Chris Lattner ValueList.shrinkTo(Record[0]); 1779198f34ac359c48018c6e1f784cf3770ead63b253Chris Lattner break; 1780198f34ac359c48018c6e1f784cf3770ead63b253Chris Lattner } 1781caee0dccffb77a003681345ab3281bcf8684526cChris Lattner Record.clear(); 1782caee0dccffb77a003681345ab3281bcf8684526cChris Lattner } 1783caee0dccffb77a003681345ab3281bcf8684526cChris Lattner} 1784caee0dccffb77a003681345ab3281bcf8684526cChris Lattner 1785f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskinbool BitcodeReader::ParseBitcodeInto(Module *M) { 1786caee0dccffb77a003681345ab3281bcf8684526cChris Lattner TheModule = 0; 1787a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 17882ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (InitStream()) return true; 1789a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1790caee0dccffb77a003681345ab3281bcf8684526cChris Lattner // Sniff for the signature. 1791caee0dccffb77a003681345ab3281bcf8684526cChris Lattner if (Stream.Read(8) != 'B' || 1792caee0dccffb77a003681345ab3281bcf8684526cChris Lattner Stream.Read(8) != 'C' || 1793caee0dccffb77a003681345ab3281bcf8684526cChris Lattner Stream.Read(4) != 0x0 || 1794caee0dccffb77a003681345ab3281bcf8684526cChris Lattner Stream.Read(4) != 0xC || 1795caee0dccffb77a003681345ab3281bcf8684526cChris Lattner Stream.Read(4) != 0xE || 1796caee0dccffb77a003681345ab3281bcf8684526cChris Lattner Stream.Read(4) != 0xD) 1797caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Invalid bitcode signature"); 1798a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1799caee0dccffb77a003681345ab3281bcf8684526cChris Lattner // We expect a number of well-defined blocks, though we don't necessarily 1800caee0dccffb77a003681345ab3281bcf8684526cChris Lattner // need to understand them all. 18015a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner while (1) { 18025a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner if (Stream.AtEndOfStream()) 18035a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return false; 1804acb6194f93440425776cdd730a2726fd95499505Joe Abbey 18055a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner BitstreamEntry Entry = 18065a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs); 1807acb6194f93440425776cdd730a2726fd95499505Joe Abbey 18085a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Entry.Kind) { 18095a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Error: 18105a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner Error("malformed module file"); 18115a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return true; 18125a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::EndBlock: 18135a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return false; 1814acb6194f93440425776cdd730a2726fd95499505Joe Abbey 18155a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::SubBlock: 18165a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Entry.ID) { 18175a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case bitc::BLOCKINFO_BLOCK_ID: 18185a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner if (Stream.ReadBlockInfoBlock()) 18195a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return Error("Malformed BlockInfoBlock"); 18205a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner break; 18215a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case bitc::MODULE_BLOCK_ID: 18225a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner // Reject multiple MODULE_BLOCK's in a single bitstream. 18235a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner if (TheModule) 18245a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return Error("Multiple MODULE_BLOCKs in same stream"); 18255a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner TheModule = M; 18265a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner if (ParseModule(false)) 18275a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return true; 18285a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner if (LazyStreamer) return false; 18295a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner break; 18305a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner default: 18315a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner if (Stream.SkipBlock()) 18325a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return Error("Malformed block record"); 18335a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner break; 18345a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner } 18355a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner continue; 18365a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Record: 18375a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner // There should be no records in the top-level of blocks. 1838acb6194f93440425776cdd730a2726fd95499505Joe Abbey 18395a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner // The ranlib in Xcode 4 will align archive members by appending newlines 18406ff9aa2aa79d0f1927dc1a73b9d1ca1e08d2978bChad Rosier // to the end of them. If this file size is a multiple of 4 but not 8, we 18416ff9aa2aa79d0f1927dc1a73b9d1ca1e08d2978bChad Rosier // have to read and ignore these final 4 bytes :-( 18425a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner if (Stream.getAbbrevIDWidth() == 2 && Entry.ID == 2 && 1843c9687b32fab6d6ec53ac95dccf61d598be26d5dcRafael Espindola Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a && 18442127c9b93a5fd5f04ffaced84bde0696bd57fce6Bill Wendling Stream.AtEndOfStream()) 1845c9687b32fab6d6ec53ac95dccf61d598be26d5dcRafael Espindola return false; 1846acb6194f93440425776cdd730a2726fd95499505Joe Abbey 1847caee0dccffb77a003681345ab3281bcf8684526cChris Lattner return Error("Invalid record at top-level"); 1848c9687b32fab6d6ec53ac95dccf61d598be26d5dcRafael Espindola } 1849caee0dccffb77a003681345ab3281bcf8684526cChris Lattner } 1850caee0dccffb77a003681345ab3281bcf8684526cChris Lattner} 1851c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner 185234711747a1d2c8713e69333bacef1c880810e371Bill Wendlingbool BitcodeReader::ParseModuleTriple(std::string &Triple) { 185334711747a1d2c8713e69333bacef1c880810e371Bill Wendling if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 185434711747a1d2c8713e69333bacef1c880810e371Bill Wendling return Error("Malformed block record"); 185534711747a1d2c8713e69333bacef1c880810e371Bill Wendling 185634711747a1d2c8713e69333bacef1c880810e371Bill Wendling SmallVector<uint64_t, 64> Record; 185734711747a1d2c8713e69333bacef1c880810e371Bill Wendling 185834711747a1d2c8713e69333bacef1c880810e371Bill Wendling // Read all the records for this module. 18595a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner while (1) { 18605a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 1861acb6194f93440425776cdd730a2726fd95499505Joe Abbey 18625a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Entry.Kind) { 18635a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::SubBlock: // Handled for us already. 18645a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Error: 18655a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return Error("malformed module block"); 18665a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::EndBlock: 186734711747a1d2c8713e69333bacef1c880810e371Bill Wendling return false; 18685a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Record: 18695a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner // The interesting case. 18705a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner break; 187134711747a1d2c8713e69333bacef1c880810e371Bill Wendling } 187234711747a1d2c8713e69333bacef1c880810e371Bill Wendling 187334711747a1d2c8713e69333bacef1c880810e371Bill Wendling // Read a record. 18745a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Stream.readRecord(Entry.ID, Record)) { 187534711747a1d2c8713e69333bacef1c880810e371Bill Wendling default: break; // Default behavior, ignore unknown content. 187634711747a1d2c8713e69333bacef1c880810e371Bill Wendling case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 187734711747a1d2c8713e69333bacef1c880810e371Bill Wendling std::string S; 187834711747a1d2c8713e69333bacef1c880810e371Bill Wendling if (ConvertToString(Record, 0, S)) 187934711747a1d2c8713e69333bacef1c880810e371Bill Wendling return Error("Invalid MODULE_CODE_TRIPLE record"); 188034711747a1d2c8713e69333bacef1c880810e371Bill Wendling Triple = S; 188134711747a1d2c8713e69333bacef1c880810e371Bill Wendling break; 188234711747a1d2c8713e69333bacef1c880810e371Bill Wendling } 188334711747a1d2c8713e69333bacef1c880810e371Bill Wendling } 188434711747a1d2c8713e69333bacef1c880810e371Bill Wendling Record.clear(); 188534711747a1d2c8713e69333bacef1c880810e371Bill Wendling } 188634711747a1d2c8713e69333bacef1c880810e371Bill Wendling} 188734711747a1d2c8713e69333bacef1c880810e371Bill Wendling 188834711747a1d2c8713e69333bacef1c880810e371Bill Wendlingbool BitcodeReader::ParseTriple(std::string &Triple) { 18892ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (InitStream()) return true; 189034711747a1d2c8713e69333bacef1c880810e371Bill Wendling 189134711747a1d2c8713e69333bacef1c880810e371Bill Wendling // Sniff for the signature. 189234711747a1d2c8713e69333bacef1c880810e371Bill Wendling if (Stream.Read(8) != 'B' || 189334711747a1d2c8713e69333bacef1c880810e371Bill Wendling Stream.Read(8) != 'C' || 189434711747a1d2c8713e69333bacef1c880810e371Bill Wendling Stream.Read(4) != 0x0 || 189534711747a1d2c8713e69333bacef1c880810e371Bill Wendling Stream.Read(4) != 0xC || 189634711747a1d2c8713e69333bacef1c880810e371Bill Wendling Stream.Read(4) != 0xE || 189734711747a1d2c8713e69333bacef1c880810e371Bill Wendling Stream.Read(4) != 0xD) 189834711747a1d2c8713e69333bacef1c880810e371Bill Wendling return Error("Invalid bitcode signature"); 189934711747a1d2c8713e69333bacef1c880810e371Bill Wendling 190034711747a1d2c8713e69333bacef1c880810e371Bill Wendling // We expect a number of well-defined blocks, though we don't necessarily 190134711747a1d2c8713e69333bacef1c880810e371Bill Wendling // need to understand them all. 19025a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner while (1) { 19035a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner BitstreamEntry Entry = Stream.advance(); 1904acb6194f93440425776cdd730a2726fd95499505Joe Abbey 19055a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Entry.Kind) { 19065a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Error: 19075a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner Error("malformed module file"); 19085a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return true; 19095a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::EndBlock: 19105a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return false; 1911acb6194f93440425776cdd730a2726fd95499505Joe Abbey 19125a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::SubBlock: 19135a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner if (Entry.ID == bitc::MODULE_BLOCK_ID) 19145a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return ParseModuleTriple(Triple); 1915acb6194f93440425776cdd730a2726fd95499505Joe Abbey 19165a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner // Ignore other sub-blocks. 19175a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner if (Stream.SkipBlock()) { 19185a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner Error("malformed block record in AST file"); 191934711747a1d2c8713e69333bacef1c880810e371Bill Wendling return true; 19205a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner } 19215a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner continue; 1922acb6194f93440425776cdd730a2726fd95499505Joe Abbey 19235a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Record: 19245a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner Stream.skipRecord(Entry.ID); 19255a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner continue; 192634711747a1d2c8713e69333bacef1c880810e371Bill Wendling } 192734711747a1d2c8713e69333bacef1c880810e371Bill Wendling } 192834711747a1d2c8713e69333bacef1c880810e371Bill Wendling} 192934711747a1d2c8713e69333bacef1c880810e371Bill Wendling 1930e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel/// ParseMetadataAttachment - Parse metadata attachments. 1931e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patelbool BitcodeReader::ParseMetadataAttachment() { 1932e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) 1933e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel return Error("Malformed block record"); 1934a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1935e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel SmallVector<uint64_t, 64> Record; 19365a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner while (1) { 19375a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 1938acb6194f93440425776cdd730a2726fd95499505Joe Abbey 19395a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Entry.Kind) { 19405a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::SubBlock: // Handled for us already. 19415a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Error: 19425a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return Error("malformed metadata block"); 19435a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::EndBlock: 19445a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return false; 19455a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Record: 19465a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner // The interesting case. 1947e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel break; 1948e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel } 19495a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner 1950e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel // Read a metadata attachment record. 1951e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel Record.clear(); 19525a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Stream.readRecord(Entry.ID, Record)) { 1953e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel default: // Default behavior: ignore. 1954e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel break; 19559d61dd9a088be975df4beb4632a39ed009bd0ef5Chris Lattner case bitc::METADATA_ATTACHMENT: { 1956e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel unsigned RecordLength = Record.size(); 1957e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel if (Record.empty() || (RecordLength - 1) % 2 == 1) 1958a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar return Error ("Invalid METADATA_ATTACHMENT reader!"); 1959e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel Instruction *Inst = InstructionList[Record[0]]; 1960e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel for (unsigned i = 1; i != RecordLength; i = i+2) { 1961a2148402ce39fb3aad09e98a32078d3853a01ae9Devang Patel unsigned Kind = Record[i]; 196219538d1e9fb4f8198b94f8450c6fc43528d8b868Dan Gohman DenseMap<unsigned, unsigned>::iterator I = 196319538d1e9fb4f8198b94f8450c6fc43528d8b868Dan Gohman MDKindMap.find(Kind); 196419538d1e9fb4f8198b94f8450c6fc43528d8b868Dan Gohman if (I == MDKindMap.end()) 196519538d1e9fb4f8198b94f8450c6fc43528d8b868Dan Gohman return Error("Invalid metadata kind ID"); 1966a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar Value *Node = MDValueList.getValueFwdRef(Record[i+1]); 196719538d1e9fb4f8198b94f8450c6fc43528d8b868Dan Gohman Inst->setMetadata(I->second, cast<MDNode>(Node)); 1968e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel } 1969e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel break; 1970e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel } 1971e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel } 1972e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel } 1973e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel} 197448f848716e80d01619b239111db48bfac77baad1Chris Lattner 1975980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner/// ParseFunctionBody - Lazily parse the specified function body block. 1976980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattnerbool BitcodeReader::ParseFunctionBody(Function *F) { 1977e17b658c792abd4a1552144b8a8808e44970da76Chris Lattner if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) 1978980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner return Error("Malformed block record"); 1979a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 19809a49f1552db7e2ce24a03ec068b17db8a238856dNick Lewycky InstructionList.clear(); 1981980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner unsigned ModuleValueListSize = ValueList.size(); 1982698138384e94bf315b4bc67481400ffab65e5f93Dan Gohman unsigned ModuleMDValueListSize = MDValueList.size(); 1983a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1984980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner // Add all the function arguments to the value table. 1985980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) 1986980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner ValueList.push_back(I); 1987a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1988a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner unsigned NextValueNo = ValueList.size(); 1989231cbcb35b48530aef305c76de1583c0b5dfc7ceChris Lattner BasicBlock *CurBB = 0; 1990231cbcb35b48530aef305c76de1583c0b5dfc7ceChris Lattner unsigned CurBBNo = 0; 1991231cbcb35b48530aef305c76de1583c0b5dfc7ceChris Lattner 1992a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner DebugLoc LastLoc; 1993407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 1994980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner // Read all the records. 1995980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner SmallVector<uint64_t, 64> Record; 1996980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner while (1) { 19975a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner BitstreamEntry Entry = Stream.advance(); 1998acb6194f93440425776cdd730a2726fd95499505Joe Abbey 19995a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Entry.Kind) { 20005a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Error: 20015a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner return Error("Bitcode error in function block"); 20025a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::EndBlock: 20035a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner goto OutOfRecordLoop; 2004acb6194f93440425776cdd730a2726fd95499505Joe Abbey 20055a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::SubBlock: 20065a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner switch (Entry.ID) { 2007980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner default: // Skip unknown content. 2008980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner if (Stream.SkipBlock()) 2009980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner return Error("Malformed block record"); 2010980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner break; 2011980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner case bitc::CONSTANTS_BLOCK_ID: 2012980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner if (ParseConstants()) return true; 2013a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner NextValueNo = ValueList.size(); 2014980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner break; 2015980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner case bitc::VALUE_SYMTAB_BLOCK_ID: 2016980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner if (ParseValueSymbolTable()) return true; 2017980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner break; 2018e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel case bitc::METADATA_ATTACHMENT_ID: 2019a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar if (ParseMetadataAttachment()) return true; 2020a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar break; 2021fab9e99c0191a1f2b5b79aaa9f1f45b995168515Victor Hernandez case bitc::METADATA_BLOCK_ID: 2022fab9e99c0191a1f2b5b79aaa9f1f45b995168515Victor Hernandez if (ParseMetadata()) return true; 2023fab9e99c0191a1f2b5b79aaa9f1f45b995168515Victor Hernandez break; 2024980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner } 2025980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner continue; 2026acb6194f93440425776cdd730a2726fd95499505Joe Abbey 20275a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner case BitstreamEntry::Record: 20285a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner // The interesting case. 20295a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner break; 2030980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner } 2031acb6194f93440425776cdd730a2726fd95499505Joe Abbey 2032980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner // Read a record. 2033980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner Record.clear(); 2034a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner Instruction *I = 0; 20355a4251c767adb7a47ad7a53719398ee1342cc400Chris Lattner unsigned BitCode = Stream.readRecord(Entry.ID, Record); 20361224c386981f7948f298ed9ad444c40609570f2eDan Gohman switch (BitCode) { 2037a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner default: // Default behavior: reject 2038a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner return Error("Unknown instruction"); 2039980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks] 2040a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner if (Record.size() < 1 || Record[0] == 0) 2041a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner return Error("Invalid DECLAREBLOCKS record"); 2042980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner // Create all the basic blocks for the function. 2043f61e6457a5c70eb890fd5b77b82f124ed420e8afChris Lattner FunctionBBs.resize(Record[0]); 2044980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) 20451d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson FunctionBBs[i] = BasicBlock::Create(Context, "", F); 2046a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner CurBB = FunctionBBs[0]; 2047a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner continue; 2048407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 2049a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN 2050a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner // This record indicates that the last instruction is at the same 2051a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner // location as the previous instruction with a location. 2052a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner I = 0; 2053407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 2054a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner // Get the last instruction emitted. 2055a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner if (CurBB && !CurBB->empty()) 2056a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner I = &CurBB->back(); 2057a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner else if (CurBBNo && FunctionBBs[CurBBNo-1] && 2058a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner !FunctionBBs[CurBBNo-1]->empty()) 2059a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner I = &FunctionBBs[CurBBNo-1]->back(); 2060407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 2061a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner if (I == 0) return Error("Invalid DEBUG_LOC_AGAIN record"); 2062a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner I->setDebugLoc(LastLoc); 2063a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner I = 0; 2064a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner continue; 2065407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 20664f6bab98c54a93276b8370d3f61f63bf765f7e1fChris Lattner case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia] 2067a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner I = 0; // Get the last instruction emitted. 2068a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner if (CurBB && !CurBB->empty()) 2069a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner I = &CurBB->back(); 2070a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner else if (CurBBNo && FunctionBBs[CurBBNo-1] && 2071a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner !FunctionBBs[CurBBNo-1]->empty()) 2072a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner I = &FunctionBBs[CurBBNo-1]->back(); 2073a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner if (I == 0 || Record.size() < 4) 2074a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner return Error("Invalid FUNC_CODE_DEBUG_LOC record"); 2075407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 2076a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner unsigned Line = Record[0], Col = Record[1]; 2077a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner unsigned ScopeID = Record[2], IAID = Record[3]; 2078407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 2079a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner MDNode *Scope = 0, *IA = 0; 2080a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner if (ScopeID) Scope = cast<MDNode>(MDValueList.getValueFwdRef(ScopeID-1)); 2081a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner if (IAID) IA = cast<MDNode>(MDValueList.getValueFwdRef(IAID-1)); 2082a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner LastLoc = DebugLoc::get(Line, Col, Scope, IA); 2083a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner I->setDebugLoc(LastLoc); 2084a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner I = 0; 2085a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner continue; 2086a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner } 2087a6245247e9d0c718fb14230ba6610ee939b030faChris Lattner 2088abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode] 2089abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner unsigned OpNum = 0; 2090abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner Value *LHS, *RHS; 2091abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 2092d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) || 20931224c386981f7948f298ed9ad444c40609570f2eDan Gohman OpNum+1 > Record.size()) 2094abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner return Error("Invalid BINOP record"); 2095a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 20961224c386981f7948f298ed9ad444c40609570f2eDan Gohman int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); 2097abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner if (Opc == -1) return Error("Invalid BINOP record"); 20987cbd8a3e92221437048b484d5ef9c0a22d0f8c58Gabor Greif I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); 2099e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(I); 2100f8dbee7cea072eb63ae343759975109553697bcbDan Gohman if (OpNum < Record.size()) { 2101f8dbee7cea072eb63ae343759975109553697bcbDan Gohman if (Opc == Instruction::Add || 2102f8dbee7cea072eb63ae343759975109553697bcbDan Gohman Opc == Instruction::Sub || 2103f067d584a81ae771d301304ea885e55e2de8ee9aChris Lattner Opc == Instruction::Mul || 2104f067d584a81ae771d301304ea885e55e2de8ee9aChris Lattner Opc == Instruction::Shl) { 210526793ed9749cf8999b2219d5d52a7b7a05bed505Dan Gohman if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 2106f8dbee7cea072eb63ae343759975109553697bcbDan Gohman cast<BinaryOperator>(I)->setHasNoSignedWrap(true); 210726793ed9749cf8999b2219d5d52a7b7a05bed505Dan Gohman if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 2108f8dbee7cea072eb63ae343759975109553697bcbDan Gohman cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true); 210935bda8914c0d1c02a6f90f42e7810c83150737e1Chris Lattner } else if (Opc == Instruction::SDiv || 2110f067d584a81ae771d301304ea885e55e2de8ee9aChris Lattner Opc == Instruction::UDiv || 2111f067d584a81ae771d301304ea885e55e2de8ee9aChris Lattner Opc == Instruction::LShr || 2112f067d584a81ae771d301304ea885e55e2de8ee9aChris Lattner Opc == Instruction::AShr) { 211335bda8914c0d1c02a6f90f42e7810c83150737e1Chris Lattner if (Record[OpNum] & (1 << bitc::PEO_EXACT)) 2114f8dbee7cea072eb63ae343759975109553697bcbDan Gohman cast<BinaryOperator>(I)->setIsExact(true); 2115495d10ad56d1113ba33e0589e7c4f96f3c16fa52Michael Ilseman } else if (isa<FPMathOperator>(I)) { 2116495d10ad56d1113ba33e0589e7c4f96f3c16fa52Michael Ilseman FastMathFlags FMF; 21171638b839090a35adcd5a4b4cc0a649352276e703Michael Ilseman if (0 != (Record[OpNum] & FastMathFlags::UnsafeAlgebra)) 21181638b839090a35adcd5a4b4cc0a649352276e703Michael Ilseman FMF.setUnsafeAlgebra(); 21191638b839090a35adcd5a4b4cc0a649352276e703Michael Ilseman if (0 != (Record[OpNum] & FastMathFlags::NoNaNs)) 21201638b839090a35adcd5a4b4cc0a649352276e703Michael Ilseman FMF.setNoNaNs(); 21211638b839090a35adcd5a4b4cc0a649352276e703Michael Ilseman if (0 != (Record[OpNum] & FastMathFlags::NoInfs)) 21221638b839090a35adcd5a4b4cc0a649352276e703Michael Ilseman FMF.setNoInfs(); 21231638b839090a35adcd5a4b4cc0a649352276e703Michael Ilseman if (0 != (Record[OpNum] & FastMathFlags::NoSignedZeros)) 21241638b839090a35adcd5a4b4cc0a649352276e703Michael Ilseman FMF.setNoSignedZeros(); 21251638b839090a35adcd5a4b4cc0a649352276e703Michael Ilseman if (0 != (Record[OpNum] & FastMathFlags::AllowReciprocal)) 21261638b839090a35adcd5a4b4cc0a649352276e703Michael Ilseman FMF.setAllowReciprocal(); 2127495d10ad56d1113ba33e0589e7c4f96f3c16fa52Michael Ilseman if (FMF.any()) 2128495d10ad56d1113ba33e0589e7c4f96f3c16fa52Michael Ilseman I->setFastMathFlags(FMF); 2129f8dbee7cea072eb63ae343759975109553697bcbDan Gohman } 2130495d10ad56d1113ba33e0589e7c4f96f3c16fa52Michael Ilseman 2131f8dbee7cea072eb63ae343759975109553697bcbDan Gohman } 2132a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner break; 2133a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner } 2134abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc] 2135abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner unsigned OpNum = 0; 2136abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner Value *Op; 2137abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2138abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner OpNum+2 != Record.size()) 2139abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner return Error("Invalid CAST record"); 2140a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2141db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ResTy = getTypeByID(Record[OpNum]); 2142abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner int Opc = GetDecodedCastOpcode(Record[OpNum+1]); 2143abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner if (Opc == -1 || ResTy == 0) 2144231cbcb35b48530aef305c76de1583c0b5dfc7ceChris Lattner return Error("Invalid CAST record"); 21457cbd8a3e92221437048b484d5ef9c0a22d0f8c58Gabor Greif I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy); 2146e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(I); 2147231cbcb35b48530aef305c76de1583c0b5dfc7ceChris Lattner break; 2148231cbcb35b48530aef305c76de1583c0b5dfc7ceChris Lattner } 2149dd8004dc73d091ccb3927dbbc3b41639a3738ae3Dan Gohman case bitc::FUNC_CODE_INST_INBOUNDS_GEP: 215015e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands] 21517337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner unsigned OpNum = 0; 21527337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner Value *BasePtr; 21537337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) 215401ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner return Error("Invalid GEP record"); 215501ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner 2156f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner SmallVector<Value*, 16> GEPIdx; 21577337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner while (OpNum != Record.size()) { 21587337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner Value *Op; 21597337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 216001ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner return Error("Invalid GEP record"); 21617337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner GEPIdx.push_back(Op); 216201ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner } 216301ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner 2164a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad I = GetElementPtrInst::Create(BasePtr, GEPIdx); 2165e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(I); 2166dd8004dc73d091ccb3927dbbc3b41639a3738ae3Dan Gohman if (BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP) 2167f8dbee7cea072eb63ae343759975109553697bcbDan Gohman cast<GetElementPtrInst>(I)->setIsInBounds(true); 216801ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner break; 216901ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner } 2170a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 217181a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman case bitc::FUNC_CODE_INST_EXTRACTVAL: { 217281a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman // EXTRACTVAL: [opty, opval, n x indices] 2173e4977cf750eaff28275429191821420c20b0c64fDan Gohman unsigned OpNum = 0; 2174e4977cf750eaff28275429191821420c20b0c64fDan Gohman Value *Agg; 2175e4977cf750eaff28275429191821420c20b0c64fDan Gohman if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2176e4977cf750eaff28275429191821420c20b0c64fDan Gohman return Error("Invalid EXTRACTVAL record"); 2177e4977cf750eaff28275429191821420c20b0c64fDan Gohman 217881a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman SmallVector<unsigned, 4> EXTRACTVALIdx; 217981a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman for (unsigned RecSize = Record.size(); 218081a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman OpNum != RecSize; ++OpNum) { 218181a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman uint64_t Index = Record[OpNum]; 218281a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman if ((unsigned)Index != Index) 218381a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman return Error("Invalid EXTRACTVAL index"); 218481a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman EXTRACTVALIdx.push_back((unsigned)Index); 2185e4977cf750eaff28275429191821420c20b0c64fDan Gohman } 2186e4977cf750eaff28275429191821420c20b0c64fDan Gohman 2187fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad I = ExtractValueInst::Create(Agg, EXTRACTVALIdx); 2188e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(I); 2189e4977cf750eaff28275429191821420c20b0c64fDan Gohman break; 2190e4977cf750eaff28275429191821420c20b0c64fDan Gohman } 2191a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 219281a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman case bitc::FUNC_CODE_INST_INSERTVAL: { 219381a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman // INSERTVAL: [opty, opval, opty, opval, n x indices] 2194e4977cf750eaff28275429191821420c20b0c64fDan Gohman unsigned OpNum = 0; 2195e4977cf750eaff28275429191821420c20b0c64fDan Gohman Value *Agg; 2196e4977cf750eaff28275429191821420c20b0c64fDan Gohman if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2197e4977cf750eaff28275429191821420c20b0c64fDan Gohman return Error("Invalid INSERTVAL record"); 2198e4977cf750eaff28275429191821420c20b0c64fDan Gohman Value *Val; 2199e4977cf750eaff28275429191821420c20b0c64fDan Gohman if (getValueTypePair(Record, OpNum, NextValueNo, Val)) 2200e4977cf750eaff28275429191821420c20b0c64fDan Gohman return Error("Invalid INSERTVAL record"); 2201e4977cf750eaff28275429191821420c20b0c64fDan Gohman 220281a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman SmallVector<unsigned, 4> INSERTVALIdx; 220381a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman for (unsigned RecSize = Record.size(); 220481a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman OpNum != RecSize; ++OpNum) { 220581a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman uint64_t Index = Record[OpNum]; 220681a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman if ((unsigned)Index != Index) 220781a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman return Error("Invalid INSERTVAL index"); 220881a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman INSERTVALIdx.push_back((unsigned)Index); 2209e4977cf750eaff28275429191821420c20b0c64fDan Gohman } 2210e4977cf750eaff28275429191821420c20b0c64fDan Gohman 2211fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad I = InsertValueInst::Create(Agg, Val, INSERTVALIdx); 2212e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(I); 2213e4977cf750eaff28275429191821420c20b0c64fDan Gohman break; 2214e4977cf750eaff28275429191821420c20b0c64fDan Gohman } 2215a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2216abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval] 2217fb2bbbe78674a34e5ec2ec6f8c566ac5cbb26154Dan Gohman // obsolete form of select 2218fb2bbbe78674a34e5ec2ec6f8c566ac5cbb26154Dan Gohman // handles select i1 ... in old bitcode 2219abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner unsigned OpNum = 0; 2220abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner Value *TrueVal, *FalseVal, *Cond; 2221abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 2222d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) || 2223d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung popValue(Record, OpNum, NextValueNo, Type::getInt1Ty(Context), Cond)) 222401ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner return Error("Invalid SELECT record"); 2225a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2226fb2bbbe78674a34e5ec2ec6f8c566ac5cbb26154Dan Gohman I = SelectInst::Create(Cond, TrueVal, FalseVal); 2227e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(I); 2228fb2bbbe78674a34e5ec2ec6f8c566ac5cbb26154Dan Gohman break; 2229fb2bbbe78674a34e5ec2ec6f8c566ac5cbb26154Dan Gohman } 2230a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2231fb2bbbe78674a34e5ec2ec6f8c566ac5cbb26154Dan Gohman case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred] 2232fb2bbbe78674a34e5ec2ec6f8c566ac5cbb26154Dan Gohman // new form of select 2233fb2bbbe78674a34e5ec2ec6f8c566ac5cbb26154Dan Gohman // handles select i1 or select [N x i1] 2234fb2bbbe78674a34e5ec2ec6f8c566ac5cbb26154Dan Gohman unsigned OpNum = 0; 2235fb2bbbe78674a34e5ec2ec6f8c566ac5cbb26154Dan Gohman Value *TrueVal, *FalseVal, *Cond; 2236fb2bbbe78674a34e5ec2ec6f8c566ac5cbb26154Dan Gohman if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 2237d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) || 2238fb2bbbe78674a34e5ec2ec6f8c566ac5cbb26154Dan Gohman getValueTypePair(Record, OpNum, NextValueNo, Cond)) 2239fb2bbbe78674a34e5ec2ec6f8c566ac5cbb26154Dan Gohman return Error("Invalid SELECT record"); 2240f72fb679eff7de84e3e18b75d63a18cb3510bcddDan Gohman 2241f72fb679eff7de84e3e18b75d63a18cb3510bcddDan Gohman // select condition can be either i1 or [N x i1] 2242db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType* vector_type = 2243db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner dyn_cast<VectorType>(Cond->getType())) { 2244f72fb679eff7de84e3e18b75d63a18cb3510bcddDan Gohman // expect <n x i1> 2245a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar if (vector_type->getElementType() != Type::getInt1Ty(Context)) 2246f72fb679eff7de84e3e18b75d63a18cb3510bcddDan Gohman return Error("Invalid SELECT condition type"); 2247f72fb679eff7de84e3e18b75d63a18cb3510bcddDan Gohman } else { 2248f72fb679eff7de84e3e18b75d63a18cb3510bcddDan Gohman // expect i1 2249a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar if (Cond->getType() != Type::getInt1Ty(Context)) 2250f72fb679eff7de84e3e18b75d63a18cb3510bcddDan Gohman return Error("Invalid SELECT condition type"); 2251a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar } 2252a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2253051a950000e21935165db56695e35bade668193bGabor Greif I = SelectInst::Create(Cond, TrueVal, FalseVal); 2254e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(I); 225501ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner break; 225601ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner } 2257a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 225801ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval] 2259abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner unsigned OpNum = 0; 2260abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner Value *Vec, *Idx; 2261abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 2262d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung popValue(Record, OpNum, NextValueNo, Type::getInt32Ty(Context), Idx)) 226301ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner return Error("Invalid EXTRACTELT record"); 2264a3500da5592aee83675d6714d4f1e9d5ad96d1f2Eric Christopher I = ExtractElementInst::Create(Vec, Idx); 2265e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(I); 226601ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner break; 226701ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner } 2268a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 226901ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval] 2270abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner unsigned OpNum = 0; 2271abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner Value *Vec, *Elt, *Idx; 2272abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 2273d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung popValue(Record, OpNum, NextValueNo, 2274abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner cast<VectorType>(Vec->getType())->getElementType(), Elt) || 2275d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung popValue(Record, OpNum, NextValueNo, Type::getInt32Ty(Context), Idx)) 227601ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner return Error("Invalid INSERTELT record"); 2277051a950000e21935165db56695e35bade668193bGabor Greif I = InsertElementInst::Create(Vec, Elt, Idx); 2278e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(I); 227901ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner break; 228001ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner } 2281a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2282abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval] 2283abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner unsigned OpNum = 0; 2284abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner Value *Vec1, *Vec2, *Mask; 2285abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) || 2286d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec2)) 2287abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner return Error("Invalid SHUFFLEVEC record"); 2288abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner 2289aeb06d246254e4829a49164a11eacced9a43d9d4Mon P Wang if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) 229001ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner return Error("Invalid SHUFFLEVEC record"); 229101ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner I = new ShuffleVectorInst(Vec1, Vec2, Mask); 2292e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(I); 229301ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner break; 229401ff65fb3989fd8b302b55c4743b778f6927cb73Chris Lattner } 2295aeb06d246254e4829a49164a11eacced9a43d9d4Mon P Wang 22967f6aa2b162e5daaf7b9ccf05d749597d3d7cf460Nick Lewycky case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred] 22977f6aa2b162e5daaf7b9ccf05d749597d3d7cf460Nick Lewycky // Old form of ICmp/FCmp returning bool 22987f6aa2b162e5daaf7b9ccf05d749597d3d7cf460Nick Lewycky // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were 22997f6aa2b162e5daaf7b9ccf05d749597d3d7cf460Nick Lewycky // both legal on vectors but had different behaviour. 2300fb2bbbe78674a34e5ec2ec6f8c566ac5cbb26154Dan Gohman case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred] 23017f6aa2b162e5daaf7b9ccf05d749597d3d7cf460Nick Lewycky // FCmp/ICmp returning bool or vector of bool 23027f6aa2b162e5daaf7b9ccf05d749597d3d7cf460Nick Lewycky 2303f72fb679eff7de84e3e18b75d63a18cb3510bcddDan Gohman unsigned OpNum = 0; 2304f72fb679eff7de84e3e18b75d63a18cb3510bcddDan Gohman Value *LHS, *RHS; 2305f72fb679eff7de84e3e18b75d63a18cb3510bcddDan Gohman if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 2306d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) || 2307f72fb679eff7de84e3e18b75d63a18cb3510bcddDan Gohman OpNum+1 != Record.size()) 23087f6aa2b162e5daaf7b9ccf05d749597d3d7cf460Nick Lewycky return Error("Invalid CMP record"); 2309a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2310b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands if (LHS->getType()->isFPOrFPVectorTy()) 23111c8a23c440b1665ba422778cdc74a0c59ecaf39eDan Gohman I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); 23127f6aa2b162e5daaf7b9ccf05d749597d3d7cf460Nick Lewycky else 23131c8a23c440b1665ba422778cdc74a0c59ecaf39eDan Gohman I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS); 2314e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(I); 2315f72fb679eff7de84e3e18b75d63a18cb3510bcddDan Gohman break; 2316f72fb679eff7de84e3e18b75d63a18cb3510bcddDan Gohman } 23177f6aa2b162e5daaf7b9ccf05d749597d3d7cf460Nick Lewycky 2318231cbcb35b48530aef305c76de1583c0b5dfc7ceChris Lattner case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>] 2319d9d99ff8e8fe2897a3d45609763aeb8088b63afaDevang Patel { 2320d9d99ff8e8fe2897a3d45609763aeb8088b63afaDevang Patel unsigned Size = Record.size(); 2321d9d99ff8e8fe2897a3d45609763aeb8088b63afaDevang Patel if (Size == 0) { 23221d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson I = ReturnInst::Create(Context); 2323a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar InstructionList.push_back(I); 2324d9d99ff8e8fe2897a3d45609763aeb8088b63afaDevang Patel break; 2325fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman } 2326fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman 2327fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman unsigned OpNum = 0; 232896a74c57d9e8fe0595ba8308eec1276cf8bcf6b0Chris Lattner Value *Op = NULL; 232996a74c57d9e8fe0595ba8308eec1276cf8bcf6b0Chris Lattner if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 233096a74c57d9e8fe0595ba8308eec1276cf8bcf6b0Chris Lattner return Error("Invalid RET record"); 233196a74c57d9e8fe0595ba8308eec1276cf8bcf6b0Chris Lattner if (OpNum != Record.size()) 233296a74c57d9e8fe0595ba8308eec1276cf8bcf6b0Chris Lattner return Error("Invalid RET record"); 2333fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman 233496a74c57d9e8fe0595ba8308eec1276cf8bcf6b0Chris Lattner I = ReturnInst::Create(Context, Op); 2335a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar InstructionList.push_back(I); 2336fc74abfba5128544a750fce22fdf13eb0403e3ceDan Gohman break; 2337231cbcb35b48530aef305c76de1583c0b5dfc7ceChris Lattner } 2338f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] 2339f61e6457a5c70eb890fd5b77b82f124ed420e8afChris Lattner if (Record.size() != 1 && Record.size() != 3) 2340f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner return Error("Invalid BR record"); 2341f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner BasicBlock *TrueDest = getBasicBlock(Record[0]); 2342f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner if (TrueDest == 0) 2343f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner return Error("Invalid BR record"); 2344f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner 2345e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel if (Record.size() == 1) { 2346051a950000e21935165db56695e35bade668193bGabor Greif I = BranchInst::Create(TrueDest); 2347a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar InstructionList.push_back(I); 2348e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel } 2349f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner else { 2350f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner BasicBlock *FalseDest = getBasicBlock(Record[1]); 2351d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung Value *Cond = getValue(Record, 2, NextValueNo, 2352d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung Type::getInt1Ty(Context)); 2353f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner if (FalseDest == 0 || Cond == 0) 2354f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner return Error("Invalid BR record"); 2355051a950000e21935165db56695e35bade668193bGabor Greif I = BranchInst::Create(TrueDest, FalseDest, Cond); 2356a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar InstructionList.push_back(I); 2357f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner } 2358f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner break; 2359f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner } 2360f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...] 2361407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman // Check magic 23621cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy if ((Record[0] >> 16) == SWITCH_INST_MAGIC) { 23631cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy // New SwitchInst format with case ranges. 2364407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 23651cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy Type *OpTy = getTypeByID(Record[1]); 23661cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy unsigned ValueBitWidth = cast<IntegerType>(OpTy)->getBitWidth(); 23671cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy 2368d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung Value *Cond = getValue(Record, 2, NextValueNo, OpTy); 23691cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy BasicBlock *Default = getBasicBlock(Record[3]); 23701cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy if (OpTy == 0 || Cond == 0 || Default == 0) 23711cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy return Error("Invalid SWITCH record"); 23721cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy 23731cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy unsigned NumCases = Record[4]; 2374407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 23751cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); 23761cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy InstructionList.push_back(SI); 2377407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 23781cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy unsigned CurIdx = 5; 23791cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy for (unsigned i = 0; i != NumCases; ++i) { 23800aa32d5d0ff6cd65b6cff957858a79e2d2a614bdStepan Dyatkovskiy IntegersSubsetToBB CaseBuilder; 23811cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy unsigned NumItems = Record[CurIdx++]; 23821cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy for (unsigned ci = 0; ci != NumItems; ++ci) { 23831cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy bool isSingleNumber = Record[CurIdx++]; 2384407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 23851cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy APInt Low; 23861cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy unsigned ActiveWords = 1; 23871cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy if (ValueBitWidth > 64) 23881cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy ActiveWords = Record[CurIdx++]; 2389f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer Low = ReadWideAPInt(makeArrayRef(&Record[CurIdx], ActiveWords), 2390f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer ValueBitWidth); 23911cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy CurIdx += ActiveWords; 2392484fc93eff0295b1aa52b9a64d22346580e4b0e2Stepan Dyatkovskiy 23931cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy if (!isSingleNumber) { 23941cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy ActiveWords = 1; 23951cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy if (ValueBitWidth > 64) 23961cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy ActiveWords = Record[CurIdx++]; 23971cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy APInt High = 2398f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer ReadWideAPInt(makeArrayRef(&Record[CurIdx], ActiveWords), 2399f52aea8bc25acfdd406f741d2711ebbf54606c81Benjamin Kramer ValueBitWidth); 2400407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 2401484fc93eff0295b1aa52b9a64d22346580e4b0e2Stepan Dyatkovskiy CaseBuilder.add(IntItem::fromType(OpTy, Low), 2402484fc93eff0295b1aa52b9a64d22346580e4b0e2Stepan Dyatkovskiy IntItem::fromType(OpTy, High)); 24031cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy CurIdx += ActiveWords; 24041cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy } else 2405484fc93eff0295b1aa52b9a64d22346580e4b0e2Stepan Dyatkovskiy CaseBuilder.add(IntItem::fromType(OpTy, Low)); 24061cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy } 24071cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy BasicBlock *DestBB = getBasicBlock(Record[CurIdx++]); 2408407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman IntegersSubset Case = CaseBuilder.getCase(); 24091cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy SI->addCase(Case, DestBB); 24101cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy } 2411734dde8e051d34ac34cc58eb31cf2e6fa3ac3f37Stepan Dyatkovskiy uint16_t Hash = SI->hash(); 24121cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy if (Hash != (Record[0] & 0xFFFF)) 24131cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy return Error("Invalid SWITCH record"); 24141cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy I = SI; 24151cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy break; 24161cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy } 2417407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 24181cce5bf8ef9ee3dc157ae5d8778f84a7a0d1d8b9Stepan Dyatkovskiy // Old SwitchInst format without case ranges. 2419407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 2420f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner if (Record.size() < 3 || (Record.size() & 1) == 0) 2421f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner return Error("Invalid SWITCH record"); 2422db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *OpTy = getTypeByID(Record[0]); 2423d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung Value *Cond = getValue(Record, 1, NextValueNo, OpTy); 2424f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner BasicBlock *Default = getBasicBlock(Record[2]); 2425f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner if (OpTy == 0 || Cond == 0 || Default == 0) 2426f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner return Error("Invalid SWITCH record"); 2427f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner unsigned NumCases = (Record.size()-3)/2; 2428051a950000e21935165db56695e35bade668193bGabor Greif SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); 2429e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(SI); 2430f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner for (unsigned i = 0, e = NumCases; i != e; ++i) { 2431a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar ConstantInt *CaseVal = 2432f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy)); 2433f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); 2434f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner if (CaseVal == 0 || DestBB == 0) { 2435f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner delete SI; 2436f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner return Error("Invalid SWITCH record!"); 2437f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner } 2438f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner SI->addCase(CaseVal, DestBB); 2439f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner } 2440f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner I = SI; 2441f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner break; 2442f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner } 2443ab21db79ef1d2530880ad11f21f0b87ffca02dd4Chris Lattner case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] 2444f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner if (Record.size() < 2) 2445ab21db79ef1d2530880ad11f21f0b87ffca02dd4Chris Lattner return Error("Invalid INDIRECTBR record"); 2446db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *OpTy = getTypeByID(Record[0]); 2447d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung Value *Address = getValue(Record, 1, NextValueNo, OpTy); 2448f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner if (OpTy == 0 || Address == 0) 2449ab21db79ef1d2530880ad11f21f0b87ffca02dd4Chris Lattner return Error("Invalid INDIRECTBR record"); 2450f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner unsigned NumDests = Record.size()-2; 2451ab21db79ef1d2530880ad11f21f0b87ffca02dd4Chris Lattner IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); 2452f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner InstructionList.push_back(IBI); 2453f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner for (unsigned i = 0, e = NumDests; i != e; ++i) { 2454f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) { 2455f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner IBI->addDestination(DestBB); 2456f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner } else { 2457f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner delete IBI; 2458ab21db79ef1d2530880ad11f21f0b87ffca02dd4Chris Lattner return Error("Invalid INDIRECTBR record!"); 2459f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner } 2460f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner } 2461f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner I = IBI; 2462f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner break; 2463f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner } 2464407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 2465dc024674ff96820d6020757b48d47f46d4c07db2Duncan Sands case bitc::FUNC_CODE_INST_INVOKE: { 2466dc024674ff96820d6020757b48d47f46d4c07db2Duncan Sands // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] 2467a9bb713130b073276a53a38fe0c37d314a3f1fc1Chris Lattner if (Record.size() < 4) return Error("Invalid INVOKE record"); 246899faa3b4ec6d03ac7808fe4ff3fbf3d04e375502Bill Wendling AttributeSet PAL = getAttributes(Record[0]); 2469a9bb713130b073276a53a38fe0c37d314a3f1fc1Chris Lattner unsigned CCInfo = Record[1]; 2470a9bb713130b073276a53a38fe0c37d314a3f1fc1Chris Lattner BasicBlock *NormalBB = getBasicBlock(Record[2]); 2471a9bb713130b073276a53a38fe0c37d314a3f1fc1Chris Lattner BasicBlock *UnwindBB = getBasicBlock(Record[3]); 2472a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2473a9bb713130b073276a53a38fe0c37d314a3f1fc1Chris Lattner unsigned OpNum = 4; 24747337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner Value *Callee; 24757337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 2476f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner return Error("Invalid INVOKE record"); 2477a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2478db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); 2479db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner FunctionType *FTy = !CalleeTy ? 0 : 2480f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner dyn_cast<FunctionType>(CalleeTy->getElementType()); 2481f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner 2482f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner // Check that the right number of fixed parameters are here. 24837337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner if (FTy == 0 || NormalBB == 0 || UnwindBB == 0 || 24847337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner Record.size() < OpNum+FTy->getNumParams()) 2485f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner return Error("Invalid INVOKE record"); 2486a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2487f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner SmallVector<Value*, 16> Ops; 24887337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 2489d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung Ops.push_back(getValue(Record, OpNum, NextValueNo, 2490d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung FTy->getParamType(i))); 24917337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner if (Ops.back() == 0) return Error("Invalid INVOKE record"); 2492f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner } 2493a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 24947337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner if (!FTy->isVarArg()) { 24957337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner if (Record.size() != OpNum) 2496f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner return Error("Invalid INVOKE record"); 24977337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner } else { 24987337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner // Read type/value pairs for varargs params. 24997337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner while (OpNum != Record.size()) { 25007337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner Value *Op; 25017337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2502f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner return Error("Invalid INVOKE record"); 25037337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner Ops.push_back(Op); 2504f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner } 2505f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner } 2506a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2507a3efbb15ddd5aa9006564cd79086723640084878Jay Foad I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops); 2508e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(I); 250965c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel cast<InvokeInst>(I)->setCallingConv( 251065c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel static_cast<CallingConv::ID>(CCInfo)); 25110598866c052147c31b808391f58434ce3dbfb838Devang Patel cast<InvokeInst>(I)->setAttributes(PAL); 2512f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner break; 2513f4c8e5243376af58e52c4a0930d838509bbbea2fChris Lattner } 2514dccc03b2423fe65efb5963ae816b99c24fc53374Bill Wendling case bitc::FUNC_CODE_INST_RESUME: { // RESUME: [opval] 2515dccc03b2423fe65efb5963ae816b99c24fc53374Bill Wendling unsigned Idx = 0; 2516dccc03b2423fe65efb5963ae816b99c24fc53374Bill Wendling Value *Val = 0; 2517dccc03b2423fe65efb5963ae816b99c24fc53374Bill Wendling if (getValueTypePair(Record, Idx, NextValueNo, Val)) 2518dccc03b2423fe65efb5963ae816b99c24fc53374Bill Wendling return Error("Invalid RESUME record"); 2519dccc03b2423fe65efb5963ae816b99c24fc53374Bill Wendling I = ResumeInst::Create(Val); 252035726bfcaa852fcbcbda03613b7f9a59763003bcBill Wendling InstructionList.push_back(I); 2521dccc03b2423fe65efb5963ae816b99c24fc53374Bill Wendling break; 2522dccc03b2423fe65efb5963ae816b99c24fc53374Bill Wendling } 2523231cbcb35b48530aef305c76de1583c0b5dfc7ceChris Lattner case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE 25241d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson I = new UnreachableInst(Context); 2525e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(I); 2526231cbcb35b48530aef305c76de1583c0b5dfc7ceChris Lattner break; 2527abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...] 252815e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner if (Record.size() < 1 || ((Record.size()-1)&1)) 25292a98ccabb4efe9882cdddd4b659e4935fc646040Chris Lattner return Error("Invalid PHI record"); 2530db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = getTypeByID(Record[0]); 25312a98ccabb4efe9882cdddd4b659e4935fc646040Chris Lattner if (!Ty) return Error("Invalid PHI record"); 2532a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 25333ecfc861b4365f341c5c969b40e1afccde676e6fJay Foad PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2); 2534e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(PN); 2535a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 253615e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) { 2537d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung Value *V; 2538d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung // With the new function encoding, it is possible that operands have 2539d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung // negative IDs (for forward references). Use a signed VBR 2540d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung // representation to keep the encoding small. 2541d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung if (UseRelativeIDs) 2542d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung V = getValueSigned(Record, 1+i, NextValueNo, Ty); 2543d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung else 2544d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung V = getValue(Record, 1+i, NextValueNo, Ty); 254515e6d170e8d4b99937d34aef2c02078247f4cdf7Chris Lattner BasicBlock *BB = getBasicBlock(Record[2+i]); 25462a98ccabb4efe9882cdddd4b659e4935fc646040Chris Lattner if (!V || !BB) return Error("Invalid PHI record"); 25472a98ccabb4efe9882cdddd4b659e4935fc646040Chris Lattner PN->addIncoming(V, BB); 25482a98ccabb4efe9882cdddd4b659e4935fc646040Chris Lattner } 25492a98ccabb4efe9882cdddd4b659e4935fc646040Chris Lattner I = PN; 25502a98ccabb4efe9882cdddd4b659e4935fc646040Chris Lattner break; 25512a98ccabb4efe9882cdddd4b659e4935fc646040Chris Lattner } 2552a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2553e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling case bitc::FUNC_CODE_INST_LANDINGPAD: { 2554e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling // LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?] 2555e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling unsigned Idx = 0; 2556e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling if (Record.size() < 4) 2557e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling return Error("Invalid LANDINGPAD record"); 2558e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling Type *Ty = getTypeByID(Record[Idx++]); 2559e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling if (!Ty) return Error("Invalid LANDINGPAD record"); 2560e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling Value *PersFn = 0; 2561e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling if (getValueTypePair(Record, Idx, NextValueNo, PersFn)) 2562e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling return Error("Invalid LANDINGPAD record"); 2563e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling 2564e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling bool IsCleanup = !!Record[Idx++]; 2565e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling unsigned NumClauses = Record[Idx++]; 2566e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling LandingPadInst *LP = LandingPadInst::Create(Ty, PersFn, NumClauses); 2567e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling LP->setCleanup(IsCleanup); 2568e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling for (unsigned J = 0; J != NumClauses; ++J) { 2569e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling LandingPadInst::ClauseType CT = 2570e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling LandingPadInst::ClauseType(Record[Idx++]); (void)CT; 2571e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling Value *Val; 2572e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling 2573e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling if (getValueTypePair(Record, Idx, NextValueNo, Val)) { 2574e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling delete LP; 2575e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling return Error("Invalid LANDINGPAD record"); 2576e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling } 2577e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling 2578e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling assert((CT != LandingPadInst::Catch || 2579e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling !isa<ArrayType>(Val->getType())) && 2580e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling "Catch clause has a invalid type!"); 2581e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling assert((CT != LandingPadInst::Filter || 2582e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling isa<ArrayType>(Val->getType())) && 2583e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling "Filter clause has invalid type!"); 2584e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling LP->addClause(Val); 2585e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling } 2586e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling 2587e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling I = LP; 258835726bfcaa852fcbcbda03613b7f9a59763003bcBill Wendling InstructionList.push_back(I); 2589e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling break; 2590e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling } 2591e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling 2592a37dd3e6a5b0d2081bcd83a85183c33d3aba7cdaDan Gohman case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align] 259396a74c57d9e8fe0595ba8308eec1276cf8bcf6b0Chris Lattner if (Record.size() != 4) 25942a98ccabb4efe9882cdddd4b659e4935fc646040Chris Lattner return Error("Invalid ALLOCA record"); 2595db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType *Ty = 259696a74c57d9e8fe0595ba8308eec1276cf8bcf6b0Chris Lattner dyn_cast_or_null<PointerType>(getTypeByID(Record[0])); 2597db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *OpTy = getTypeByID(Record[1]); 259896a74c57d9e8fe0595ba8308eec1276cf8bcf6b0Chris Lattner Value *Size = getFnValueByID(Record[2], OpTy); 259996a74c57d9e8fe0595ba8308eec1276cf8bcf6b0Chris Lattner unsigned Align = Record[3]; 26002a98ccabb4efe9882cdddd4b659e4935fc646040Chris Lattner if (!Ty || !Size) return Error("Invalid ALLOCA record"); 260150dead06ffc107edb7e84857baaeeb09039c631cOwen Anderson I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); 2602e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(I); 26032a98ccabb4efe9882cdddd4b659e4935fc646040Chris Lattner break; 26042a98ccabb4efe9882cdddd4b659e4935fc646040Chris Lattner } 26050579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol] 26067337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner unsigned OpNum = 0; 26077337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner Value *Op; 26087337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 26097337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner OpNum+2 != Record.size()) 2610abfbf85004b2114ee33e05fc9efe3a7bd044e402Chris Lattner return Error("Invalid LOAD record"); 2611a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 26127337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2613e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(I); 26140579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner break; 26150579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner } 261621006d40ac9ec7715bca2095451075a83773dc52Eli Friedman case bitc::FUNC_CODE_INST_LOADATOMIC: { 261721006d40ac9ec7715bca2095451075a83773dc52Eli Friedman // LOADATOMIC: [opty, op, align, vol, ordering, synchscope] 261821006d40ac9ec7715bca2095451075a83773dc52Eli Friedman unsigned OpNum = 0; 261921006d40ac9ec7715bca2095451075a83773dc52Eli Friedman Value *Op; 262021006d40ac9ec7715bca2095451075a83773dc52Eli Friedman if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 262121006d40ac9ec7715bca2095451075a83773dc52Eli Friedman OpNum+4 != Record.size()) 262221006d40ac9ec7715bca2095451075a83773dc52Eli Friedman return Error("Invalid LOADATOMIC record"); 2623407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 262421006d40ac9ec7715bca2095451075a83773dc52Eli Friedman 262521006d40ac9ec7715bca2095451075a83773dc52Eli Friedman AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); 262621006d40ac9ec7715bca2095451075a83773dc52Eli Friedman if (Ordering == NotAtomic || Ordering == Release || 262721006d40ac9ec7715bca2095451075a83773dc52Eli Friedman Ordering == AcquireRelease) 262821006d40ac9ec7715bca2095451075a83773dc52Eli Friedman return Error("Invalid LOADATOMIC record"); 262921006d40ac9ec7715bca2095451075a83773dc52Eli Friedman if (Ordering != NotAtomic && Record[OpNum] == 0) 263021006d40ac9ec7715bca2095451075a83773dc52Eli Friedman return Error("Invalid LOADATOMIC record"); 263121006d40ac9ec7715bca2095451075a83773dc52Eli Friedman SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); 263221006d40ac9ec7715bca2095451075a83773dc52Eli Friedman 263321006d40ac9ec7715bca2095451075a83773dc52Eli Friedman I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1, 263421006d40ac9ec7715bca2095451075a83773dc52Eli Friedman Ordering, SynchScope); 263521006d40ac9ec7715bca2095451075a83773dc52Eli Friedman InstructionList.push_back(I); 263621006d40ac9ec7715bca2095451075a83773dc52Eli Friedman break; 263721006d40ac9ec7715bca2095451075a83773dc52Eli Friedman } 26384f6bab98c54a93276b8370d3f61f63bf765f7e1fChris Lattner case bitc::FUNC_CODE_INST_STORE: { // STORE2:[ptrty, ptr, val, align, vol] 2639fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb unsigned OpNum = 0; 2640fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb Value *Val, *Ptr; 2641fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 2642d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung popValue(Record, OpNum, NextValueNo, 2643fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb cast<PointerType>(Ptr->getType())->getElementType(), Val) || 2644fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb OpNum+2 != Record.size()) 2645fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb return Error("Invalid STORE record"); 2646a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2647fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2648e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(I); 2649fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb break; 2650fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb } 265121006d40ac9ec7715bca2095451075a83773dc52Eli Friedman case bitc::FUNC_CODE_INST_STOREATOMIC: { 265221006d40ac9ec7715bca2095451075a83773dc52Eli Friedman // STOREATOMIC: [ptrty, ptr, val, align, vol, ordering, synchscope] 265321006d40ac9ec7715bca2095451075a83773dc52Eli Friedman unsigned OpNum = 0; 265421006d40ac9ec7715bca2095451075a83773dc52Eli Friedman Value *Val, *Ptr; 265521006d40ac9ec7715bca2095451075a83773dc52Eli Friedman if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 2656d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung popValue(Record, OpNum, NextValueNo, 265721006d40ac9ec7715bca2095451075a83773dc52Eli Friedman cast<PointerType>(Ptr->getType())->getElementType(), Val) || 265821006d40ac9ec7715bca2095451075a83773dc52Eli Friedman OpNum+4 != Record.size()) 265921006d40ac9ec7715bca2095451075a83773dc52Eli Friedman return Error("Invalid STOREATOMIC record"); 266021006d40ac9ec7715bca2095451075a83773dc52Eli Friedman 266121006d40ac9ec7715bca2095451075a83773dc52Eli Friedman AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); 2662c3d3598425b5af392691b740dbe407b10605d839Eli Friedman if (Ordering == NotAtomic || Ordering == Acquire || 266321006d40ac9ec7715bca2095451075a83773dc52Eli Friedman Ordering == AcquireRelease) 266421006d40ac9ec7715bca2095451075a83773dc52Eli Friedman return Error("Invalid STOREATOMIC record"); 266521006d40ac9ec7715bca2095451075a83773dc52Eli Friedman SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); 266621006d40ac9ec7715bca2095451075a83773dc52Eli Friedman if (Ordering != NotAtomic && Record[OpNum] == 0) 266721006d40ac9ec7715bca2095451075a83773dc52Eli Friedman return Error("Invalid STOREATOMIC record"); 266821006d40ac9ec7715bca2095451075a83773dc52Eli Friedman 266921006d40ac9ec7715bca2095451075a83773dc52Eli Friedman I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1, 267021006d40ac9ec7715bca2095451075a83773dc52Eli Friedman Ordering, SynchScope); 267121006d40ac9ec7715bca2095451075a83773dc52Eli Friedman InstructionList.push_back(I); 267221006d40ac9ec7715bca2095451075a83773dc52Eli Friedman break; 267321006d40ac9ec7715bca2095451075a83773dc52Eli Friedman } 2674ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman case bitc::FUNC_CODE_INST_CMPXCHG: { 2675ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman // CMPXCHG:[ptrty, ptr, cmp, new, vol, ordering, synchscope] 2676ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman unsigned OpNum = 0; 2677ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman Value *Ptr, *Cmp, *New; 2678ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 2679d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung popValue(Record, OpNum, NextValueNo, 2680ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman cast<PointerType>(Ptr->getType())->getElementType(), Cmp) || 2681d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung popValue(Record, OpNum, NextValueNo, 2682ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman cast<PointerType>(Ptr->getType())->getElementType(), New) || 2683ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman OpNum+3 != Record.size()) 2684ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman return Error("Invalid CMPXCHG record"); 2685ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+1]); 268621006d40ac9ec7715bca2095451075a83773dc52Eli Friedman if (Ordering == NotAtomic || Ordering == Unordered) 2687ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman return Error("Invalid CMPXCHG record"); 2688ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+2]); 2689ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman I = new AtomicCmpXchgInst(Ptr, Cmp, New, Ordering, SynchScope); 2690ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]); 2691ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman InstructionList.push_back(I); 2692ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman break; 2693ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman } 2694ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman case bitc::FUNC_CODE_INST_ATOMICRMW: { 2695ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman // ATOMICRMW:[ptrty, ptr, val, op, vol, ordering, synchscope] 2696ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman unsigned OpNum = 0; 2697ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman Value *Ptr, *Val; 2698ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 2699d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung popValue(Record, OpNum, NextValueNo, 2700ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman cast<PointerType>(Ptr->getType())->getElementType(), Val) || 2701ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman OpNum+4 != Record.size()) 2702ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman return Error("Invalid ATOMICRMW record"); 2703ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman AtomicRMWInst::BinOp Operation = GetDecodedRMWOperation(Record[OpNum]); 2704ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman if (Operation < AtomicRMWInst::FIRST_BINOP || 2705ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman Operation > AtomicRMWInst::LAST_BINOP) 2706ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman return Error("Invalid ATOMICRMW record"); 2707ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); 270821006d40ac9ec7715bca2095451075a83773dc52Eli Friedman if (Ordering == NotAtomic || Ordering == Unordered) 2709ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman return Error("Invalid ATOMICRMW record"); 2710ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); 2711ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SynchScope); 2712ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]); 2713ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman InstructionList.push_back(I); 2714ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman break; 2715ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman } 271647f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, synchscope] 271747f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman if (2 != Record.size()) 271847f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman return Error("Invalid FENCE record"); 271947f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman AtomicOrdering Ordering = GetDecodedOrdering(Record[0]); 272047f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman if (Ordering == NotAtomic || Ordering == Unordered || 272147f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman Ordering == Monotonic) 272247f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman return Error("Invalid FENCE record"); 272347f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman SynchronizationScope SynchScope = GetDecodedSynchScope(Record[1]); 272447f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman I = new FenceInst(Context, Ordering, SynchScope); 272547f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman InstructionList.push_back(I); 272647f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman break; 272747f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman } 27284f6bab98c54a93276b8370d3f61f63bf765f7e1fChris Lattner case bitc::FUNC_CODE_INST_CALL: { 2729dc024674ff96820d6020757b48d47f46d4c07db2Duncan Sands // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] 2730dc024674ff96820d6020757b48d47f46d4c07db2Duncan Sands if (Record.size() < 3) 27310579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner return Error("Invalid CALL record"); 2732a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 273399faa3b4ec6d03ac7808fe4ff3fbf3d04e375502Bill Wendling AttributeSet PAL = getAttributes(Record[0]); 2734a9bb713130b073276a53a38fe0c37d314a3f1fc1Chris Lattner unsigned CCInfo = Record[1]; 2735a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2736a9bb713130b073276a53a38fe0c37d314a3f1fc1Chris Lattner unsigned OpNum = 2; 27377337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner Value *Callee; 27387337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 27397337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner return Error("Invalid CALL record"); 2740a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2741db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); 2742db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner FunctionType *FTy = 0; 27430579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType()); 27447337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner if (!FTy || Record.size() < FTy->getNumParams()+OpNum) 27450579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner return Error("Invalid CALL record"); 2746a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 27470579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner SmallVector<Value*, 16> Args; 27480579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner // Read the fixed params. 27497337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 27501afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (FTy->getParamType(i)->isLabelTy()) 2751eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen Args.push_back(getBasicBlock(Record[OpNum])); 27529b10dfb7d6ffb0e4466f908cd7d18212a45cfdacDan Gohman else 2753d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung Args.push_back(getValue(Record, OpNum, NextValueNo, 2754d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung FTy->getParamType(i))); 27550579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner if (Args.back() == 0) return Error("Invalid CALL record"); 27560579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner } 2757a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 27580579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner // Read type/value pairs for varargs params. 27590579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner if (!FTy->isVarArg()) { 27607337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner if (OpNum != Record.size()) 27610579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner return Error("Invalid CALL record"); 27620579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner } else { 27637337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner while (OpNum != Record.size()) { 27647337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner Value *Op; 27657337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 27667337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner return Error("Invalid CALL record"); 27677337ab9e929a4a787f90d37ee0ed8f4cc27170abChris Lattner Args.push_back(Op); 27680579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner } 27690579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner } 2770a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2771a3efbb15ddd5aa9006564cd79086723640084878Jay Foad I = CallInst::Create(Callee, Args); 2772e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(I); 277365c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel cast<CallInst>(I)->setCallingConv( 277465c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel static_cast<CallingConv::ID>(CCInfo>>1)); 277576520191abf157dfa2bcb473406193ab362480b6Chris Lattner cast<CallInst>(I)->setTailCall(CCInfo & 1); 27760598866c052147c31b808391f58434ce3dbfb838Devang Patel cast<CallInst>(I)->setAttributes(PAL); 27770579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner break; 27780579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner } 27790579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] 27800579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner if (Record.size() < 3) 27810579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner return Error("Invalid VAARG record"); 2782db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *OpTy = getTypeByID(Record[0]); 2783d9a3bad4487dee0b9ed1a0f5555dffe605826158Jan Wen Voung Value *Op = getValue(Record, 1, NextValueNo, OpTy); 2784db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ResTy = getTypeByID(Record[2]); 27850579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner if (!OpTy || !Op || !ResTy) 27860579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner return Error("Invalid VAARG record"); 27870579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner I = new VAArgInst(Op, ResTy); 2788e8e0213cc3daa2d0457c22e4c12e6973f21fc942Devang Patel InstructionList.push_back(I); 27890579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner break; 27900579f7f17f08649e65ca8673b8983c0f4985ae36Chris Lattner } 2791a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner } 2792a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner 2793a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner // Add instruction to end of current BB. If there is no current BB, reject 2794a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner // this file. 2795a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner if (CurBB == 0) { 2796a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner delete I; 2797a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner return Error("Invalid instruction with no BB"); 2798a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner } 2799a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner CurBB->getInstList().push_back(I); 2800a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2801a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner // If this was a terminator instruction, move to the next block. 2802a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner if (isa<TerminatorInst>(I)) { 2803a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner ++CurBBNo; 2804a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0; 2805980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner } 2806a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2807a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner // Non-void values get registered in the value table for future use. 2808f012705c7e4ca8cf90b6b734ce1d5355daca5ba5Benjamin Kramer if (I && !I->getType()->isVoidTy()) 2809a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner ValueList.AssignValue(I, NextValueNo++); 2810980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner } 2811a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 28125a4251c767adb7a47ad7a53719398ee1342cc400Chris LattnerOutOfRecordLoop: 2813acb6194f93440425776cdd730a2726fd95499505Joe Abbey 2814a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner // Check the function list for unresolved values. 2815a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner if (Argument *A = dyn_cast<Argument>(ValueList.back())) { 2816a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner if (A->getParent() == 0) { 2817a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner // We found at least one unresolved value. Nuke them all to avoid leaks. 2818a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){ 281956e2a5774423047cd9b1a76e1e7b233567780ca6Dan Gohman if ((A = dyn_cast<Argument>(ValueList[i])) && A->getParent() == 0) { 28209e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson A->replaceAllUsesWith(UndefValue::get(A->getType())); 2821a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner delete A; 2822a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner } 2823a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner } 282435a0470e0229c9a15a4c0d3af8d6c6564d81bd7dChris Lattner return Error("Never resolved value found in function!"); 2825a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner } 2826a7c49aac984fafa5dfdfcc2762d4d51b26788e38Chris Lattner } 2827a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2828064ff3e4356584b793b4738f02b9fa6b1d863d76Dan Gohman // FIXME: Check for unresolved forward-declared metadata references 2829064ff3e4356584b793b4738f02b9fa6b1d863d76Dan Gohman // and clean up leaks. 2830064ff3e4356584b793b4738f02b9fa6b1d863d76Dan Gohman 283150b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner // See if anything took the address of blocks in this function. If so, 283250b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner // resolve them now. 283350b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner DenseMap<Function*, std::vector<BlockAddrRefTy> >::iterator BAFRI = 283450b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner BlockAddrFwdRefs.find(F); 283550b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner if (BAFRI != BlockAddrFwdRefs.end()) { 283650b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner std::vector<BlockAddrRefTy> &RefList = BAFRI->second; 283750b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner for (unsigned i = 0, e = RefList.size(); i != e; ++i) { 283850b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner unsigned BlockIdx = RefList[i].first; 2839cdfc940912d56a63b6f12eaa7f3faf79cf74c693Chris Lattner if (BlockIdx >= FunctionBBs.size()) 284050b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner return Error("Invalid blockaddress block #"); 2841407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 284250b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner GlobalVariable *FwdRef = RefList[i].second; 2843cdfc940912d56a63b6f12eaa7f3faf79cf74c693Chris Lattner FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx])); 284450b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner FwdRef->eraseFromParent(); 284550b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner } 2846407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 284750b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner BlockAddrFwdRefs.erase(BAFRI); 284850b136dae90eb37f9fc9517a8638020db4f04f9cChris Lattner } 2849407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 2850980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner // Trim the value list down to the size it was before we parsed this function. 2851980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner ValueList.shrinkTo(ModuleValueListSize); 2852698138384e94bf315b4bc67481400ffab65e5f93Dan Gohman MDValueList.shrinkTo(ModuleMDValueListSize); 2853980e5aad4cfaa32e13b297f4201eb1088ca96cc4Chris Lattner std::vector<BasicBlock*>().swap(FunctionBBs); 285448f848716e80d01619b239111db48bfac77baad1Chris Lattner return false; 285548f848716e80d01619b239111db48bfac77baad1Chris Lattner} 285648f848716e80d01619b239111db48bfac77baad1Chris Lattner 28572ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff/// FindFunctionInStream - Find the function body in the bitcode stream 28582ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuffbool BitcodeReader::FindFunctionInStream(Function *F, 28592ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff DenseMap<Function*, uint64_t>::iterator DeferredFunctionInfoIterator) { 28602ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff while (DeferredFunctionInfoIterator->second == 0) { 28612ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (Stream.AtEndOfStream()) 28622ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff return Error("Could not find Function in stream"); 28632ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff // ParseModule will parse the next body in the stream and set its 28642ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff // position in the DeferredFunctionInfo map. 28652ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (ParseModule(true)) return true; 28662ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff } 28672ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff return false; 28682ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff} 28692ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff 2870b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner//===----------------------------------------------------------------------===// 2871f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin// GVMaterializer implementation 2872b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner//===----------------------------------------------------------------------===// 2873b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner 2874b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner 2875f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskinbool BitcodeReader::isMaterializable(const GlobalValue *GV) const { 2876f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin if (const Function *F = dyn_cast<Function>(GV)) { 2877f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin return F->isDeclaration() && 2878f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin DeferredFunctionInfo.count(const_cast<Function*>(F)); 2879f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin } 2880f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin return false; 2881f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin} 2882f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin 2883f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskinbool BitcodeReader::Materialize(GlobalValue *GV, std::string *ErrInfo) { 2884f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin Function *F = dyn_cast<Function>(GV); 2885f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin // If it's not a function or is already material, ignore the request. 2886f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin if (!F || !F->isMaterializable()) return false; 2887a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2888f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F); 2889b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!"); 28902ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff // If its position is recorded as 0, its body is somewhere in the stream 28912ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff // but we haven't seen it yet. 28922ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (DFII->second == 0) 28932ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (LazyStreamer && FindFunctionInStream(F, DFII)) return true; 2894a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2895f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin // Move the bit stream to the saved position of the deferred function body. 2896f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin Stream.JumpToBit(DFII->second); 2897a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2898b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner if (ParseFunctionBody(F)) { 2899b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner if (ErrInfo) *ErrInfo = ErrorString; 2900b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner return true; 2901b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner } 29026994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth 29036994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth // Upgrade any old intrinsic calls in the function. 29046994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(), 29056994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth E = UpgradedIntrinsics.end(); I != E; ++I) { 29066994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth if (I->first != I->second) { 29076994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth for (Value::use_iterator UI = I->first->use_begin(), 29086994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth UE = I->first->use_end(); UI != UE; ) { 29096994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 29106994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth UpgradeIntrinsicCall(CI, I->second); 29116994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth } 29126994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth } 29136994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth } 2914a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2915b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner return false; 2916b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner} 2917b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner 2918f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskinbool BitcodeReader::isDematerializable(const GlobalValue *GV) const { 2919f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin const Function *F = dyn_cast<Function>(GV); 2920f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin if (!F || F->isDeclaration()) 2921f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin return false; 2922f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin return DeferredFunctionInfo.count(const_cast<Function*>(F)); 2923f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin} 2924f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin 2925f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskinvoid BitcodeReader::Dematerialize(GlobalValue *GV) { 2926f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin Function *F = dyn_cast<Function>(GV); 2927f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin // If this function isn't dematerializable, this is a noop. 2928f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin if (!F || !isDematerializable(F)) 2929b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner return; 2930a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2931b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner assert(DeferredFunctionInfo.count(F) && "No info to read function later?"); 2932a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2933b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner // Just forget the function body, we can remat it later. 2934b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner F->deleteBody(); 2935b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner} 2936b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner 2937b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner 2938f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskinbool BitcodeReader::MaterializeModule(Module *M, std::string *ErrInfo) { 2939f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin assert(M == TheModule && 2940f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin "Can only Materialize the Module this BitcodeReader is attached to."); 2941714fa95d01ce1a646b52bc529f3dbcf6a06fa29bChris Lattner // Iterate over the module, deserializing any functions that are still on 2942714fa95d01ce1a646b52bc529f3dbcf6a06fa29bChris Lattner // disk. 2943714fa95d01ce1a646b52bc529f3dbcf6a06fa29bChris Lattner for (Module::iterator F = TheModule->begin(), E = TheModule->end(); 2944714fa95d01ce1a646b52bc529f3dbcf6a06fa29bChris Lattner F != E; ++F) 2945f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin if (F->isMaterializable() && 2946f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin Materialize(F, ErrInfo)) 2947f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin return true; 29486994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth 29490ffe6984297ece417e591003674d4466a201eb2aDerek Schuff // At this point, if there are any function bodies, the current bit is 29500ffe6984297ece417e591003674d4466a201eb2aDerek Schuff // pointing to the END_BLOCK record after them. Now make sure the rest 29510ffe6984297ece417e591003674d4466a201eb2aDerek Schuff // of the bits in the module have been read. 29520ffe6984297ece417e591003674d4466a201eb2aDerek Schuff if (NextUnreadBit) 29530ffe6984297ece417e591003674d4466a201eb2aDerek Schuff ParseModule(true); 29540ffe6984297ece417e591003674d4466a201eb2aDerek Schuff 2955a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar // Upgrade any intrinsic calls that slipped through (should not happen!) and 2956a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar // delete the old functions to clean up. We can't do this unless the entire 2957a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar // module is materialized because there could always be another function body 29586994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth // with calls to the old function. 29596994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth for (std::vector<std::pair<Function*, Function*> >::iterator I = 29606994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) { 29616994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth if (I->first != I->second) { 29626994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth for (Value::use_iterator UI = I->first->use_begin(), 29636994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth UE = I->first->use_end(); UI != UE; ) { 29646994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 29656994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth UpgradeIntrinsicCall(CI, I->second); 29666994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth } 29677d9eb5884c34d0b6d9912d1f972327eedc62d60aChris Lattner if (!I->first->use_empty()) 29687d9eb5884c34d0b6d9912d1f972327eedc62d60aChris Lattner I->first->replaceAllUsesWith(I->second); 29696994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth I->first->eraseFromParent(); 29706994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth } 29716994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth } 29726994040a952e5fb27605eb3cf29ed86c4e59cf62Chandler Carruth std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics); 2973e4b275610a7a05b7ee4c0378a906a6330e4c4ab0Devang Patel 2974f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin return false; 2975b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner} 2976b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner 29772ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuffbool BitcodeReader::InitStream() { 29782ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (LazyStreamer) return InitLazyStream(); 29792ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff return InitStreamFromBuffer(); 29802ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff} 29812ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff 29822ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuffbool BitcodeReader::InitStreamFromBuffer() { 29835177b3a8c48adec2acf284fcb8e00775a705a7e2Roman Divacky const unsigned char *BufPtr = (const unsigned char*)Buffer->getBufferStart(); 29842ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); 29852ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff 29862ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (Buffer->getBufferSize() & 3) { 29872ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (!isRawBitcode(BufPtr, BufEnd) && !isBitcodeWrapper(BufPtr, BufEnd)) 29882ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff return Error("Invalid bitcode signature"); 29892ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff else 29902ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff return Error("Bitcode stream should be a multiple of 4 bytes in length"); 29912ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff } 29922ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff 29932ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff // If we have a wrapper header, parse it and ignore the non-bc file contents. 29942ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff // The magic number is 0x0B17C0DE stored in little endian. 29952ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (isBitcodeWrapper(BufPtr, BufEnd)) 29962ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true)) 29972ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff return Error("Invalid bitcode wrapper header"); 29982ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff 29992ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff StreamFile.reset(new BitstreamReader(BufPtr, BufEnd)); 30002ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff Stream.init(*StreamFile); 30012ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff 30022ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff return false; 30032ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff} 30042ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff 30052ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuffbool BitcodeReader::InitLazyStream() { 30062ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff // Check and strip off the bitcode wrapper; BitstreamReader expects never to 30072ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff // see it. 30082ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff StreamingMemoryObject *Bytes = new StreamingMemoryObject(LazyStreamer); 30092ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff StreamFile.reset(new BitstreamReader(Bytes)); 30102ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff Stream.init(*StreamFile); 30112ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff 30122ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff unsigned char buf[16]; 30132ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (Bytes->readBytes(0, 16, buf, NULL) == -1) 30142ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff return Error("Bitcode stream must be at least 16 bytes in length"); 30152ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff 30162ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (!isBitcode(buf, buf + 16)) 30172ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff return Error("Invalid bitcode signature"); 30182ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff 30192ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (isBitcodeWrapper(buf, buf + 4)) { 30202ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff const unsigned char *bitcodeStart = buf; 30212ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff const unsigned char *bitcodeEnd = buf + 16; 30222ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false); 30232ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff Bytes->dropLeadingBytes(bitcodeStart - buf); 30242ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff Bytes->setKnownObjectSize(bitcodeEnd - bitcodeStart); 30252ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff } 30262ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff return false; 30272ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff} 302848f848716e80d01619b239111db48bfac77baad1Chris Lattner 3029c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner//===----------------------------------------------------------------------===// 3030c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner// External interface 3031c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner//===----------------------------------------------------------------------===// 3032c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner 3033f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin/// getLazyBitcodeModule - lazy function-at-a-time loading from a file. 3034c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner/// 3035f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey YasskinModule *llvm::getLazyBitcodeModule(MemoryBuffer *Buffer, 3036f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin LLVMContext& Context, 3037f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin std::string *ErrMsg) { 3038f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin Module *M = new Module(Buffer->getBufferIdentifier(), Context); 30398b477ed579794ba6d76915d56b3f448a7dd20120Owen Anderson BitcodeReader *R = new BitcodeReader(Buffer, Context); 3040f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin M->setMaterializer(R); 3041f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin if (R->ParseBitcodeInto(M)) { 3042c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner if (ErrMsg) 3043c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner *ErrMsg = R->getErrorString(); 3044a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3045f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin delete M; // Also deletes R. 3046c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner return 0; 3047c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner } 3048f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin // Have the BitcodeReader dtor delete 'Buffer'. 3049f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin R->setBufferOwned(true); 305047f79bb58e42f1a08a7f388b8b1596ded7d49bbbRafael Espindola 305147f79bb58e42f1a08a7f388b8b1596ded7d49bbbRafael Espindola R->materializeForwardReferencedFunctions(); 305247f79bb58e42f1a08a7f388b8b1596ded7d49bbbRafael Espindola 3053f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin return M; 3054c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner} 3055c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner 30562ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff 30572ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek SchuffModule *llvm::getStreamedBitcodeModule(const std::string &name, 30582ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff DataStreamer *streamer, 30592ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff LLVMContext &Context, 30602ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff std::string *ErrMsg) { 30612ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff Module *M = new Module(name, Context); 30622ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff BitcodeReader *R = new BitcodeReader(streamer, Context); 30632ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff M->setMaterializer(R); 30642ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (R->ParseBitcodeInto(M)) { 30652ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff if (ErrMsg) 30662ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff *ErrMsg = R->getErrorString(); 30672ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff delete M; // Also deletes R. 30682ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff return 0; 30692ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff } 30702ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff R->setBufferOwned(false); // no buffer to delete 30712ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff return M; 30722ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff} 30732ea93875b2f2900b9d244dfd7649c9ed02a34cd7Derek Schuff 3074c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner/// ParseBitcodeFile - Read the specified bitcode file, returning the module. 3075c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner/// If an error occurs, return null and fill in *ErrMsg if non-null. 3076a279bc3da55691784064cb47200a1c584408b8abDaniel DunbarModule *llvm::ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext& Context, 30778b477ed579794ba6d76915d56b3f448a7dd20120Owen Anderson std::string *ErrMsg){ 3078f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin Module *M = getLazyBitcodeModule(Buffer, Context, ErrMsg); 3079f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin if (!M) return 0; 3080b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner 3081b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner // Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether 3082b348bb81253a1105d23ab1a1771f8d2a6546aa1bChris Lattner // there was an error. 3083f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin static_cast<BitcodeReader*>(M->getMaterializer())->setBufferOwned(false); 3084a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3085f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin // Read in the entire module, and destroy the BitcodeReader. 3086f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin if (M->MaterializeAllPermanently(ErrMsg)) { 3087f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin delete M; 308834711747a1d2c8713e69333bacef1c880810e371Bill Wendling return 0; 3089f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin } 309034711747a1d2c8713e69333bacef1c880810e371Bill Wendling 3091cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier // TODO: Restore the use-lists to the in-memory state when the bitcode was 3092cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier // written. We must defer until the Module has been fully materialized. 3093cbbb09687f563fad96fd815a3a89920f436373e4Chad Rosier 3094c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner return M; 3095c453f76e2b4d7fd1e042b5b6d4c20556779186dfChris Lattner} 309634711747a1d2c8713e69333bacef1c880810e371Bill Wendling 309734711747a1d2c8713e69333bacef1c880810e371Bill Wendlingstd::string llvm::getBitcodeTargetTriple(MemoryBuffer *Buffer, 309834711747a1d2c8713e69333bacef1c880810e371Bill Wendling LLVMContext& Context, 309934711747a1d2c8713e69333bacef1c880810e371Bill Wendling std::string *ErrMsg) { 310034711747a1d2c8713e69333bacef1c880810e371Bill Wendling BitcodeReader *R = new BitcodeReader(Buffer, Context); 310134711747a1d2c8713e69333bacef1c880810e371Bill Wendling // Don't let the BitcodeReader dtor delete 'Buffer'. 310234711747a1d2c8713e69333bacef1c880810e371Bill Wendling R->setBufferOwned(false); 310334711747a1d2c8713e69333bacef1c880810e371Bill Wendling 310434711747a1d2c8713e69333bacef1c880810e371Bill Wendling std::string Triple(""); 310534711747a1d2c8713e69333bacef1c880810e371Bill Wendling if (R->ParseTriple(Triple)) 310634711747a1d2c8713e69333bacef1c880810e371Bill Wendling if (ErrMsg) 310734711747a1d2c8713e69333bacef1c880810e371Bill Wendling *ErrMsg = R->getErrorString(); 310834711747a1d2c8713e69333bacef1c880810e371Bill Wendling 310934711747a1d2c8713e69333bacef1c880810e371Bill Wendling delete R; 311034711747a1d2c8713e69333bacef1c880810e371Bill Wendling return Triple; 311134711747a1d2c8713e69333bacef1c880810e371Bill Wendling} 3112