BitcodeReader.cpp revision c2074caf075818abb6d3689ad924ca09f4a5ba1f
1932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===- BitcodeReader.cpp - Internal BitcodeReader implementation ----------===// 2932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// 3932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// The LLVM Compiler Infrastructure 4932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// 5932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// This file is distributed under the University of Illinois Open Source 6932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// License. See LICENSE.TXT for details. 7932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// 8932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 9932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// 10932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// This header defines the BitcodeReader class. 11932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// 12932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 13932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 14c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao#include "llvm/Bitcode/ReaderWriter.h" 15b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "BitcodeReader.h" 16d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines#include "BitReader_2_7.h" 17932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/ADT/SmallString.h" 18932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/ADT/SmallVector.h" 19c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray#include "llvm/IR/AutoUpgrade.h" 20b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/Constants.h" 21b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/DerivedTypes.h" 22b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/InlineAsm.h" 23b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/IntrinsicInst.h" 24b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/Module.h" 25b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/OperandTraits.h" 26b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/Operator.h" 27932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/Support/MathExtras.h" 28932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/Support/MemoryBuffer.h" 29c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 30932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesusing namespace llvm; 31932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesusing namespace llvm_2_7; 32932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 33932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define METADATA_NODE_2_7 2 34932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define METADATA_FN_NODE_2_7 3 35932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define METADATA_NAMED_NODE_2_7 5 36932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define METADATA_ATTACHMENT_2_7 7 37c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao#define FUNC_CODE_INST_UNWIND_2_7 14 38932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define FUNC_CODE_INST_MALLOC_2_7 17 39932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define FUNC_CODE_INST_FREE_2_7 18 40932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define FUNC_CODE_INST_STORE_2_7 21 41932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define FUNC_CODE_INST_CALL_2_7 22 42932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define FUNC_CODE_INST_GETRESULT_2_7 25 43932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define FUNC_CODE_DEBUG_LOC_2_7 32 44932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 45be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien#define TYPE_BLOCK_ID_OLD_3_0 10 46be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien#define TYPE_SYMTAB_BLOCK_ID_OLD_3_0 13 47be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien#define TYPE_CODE_STRUCT_OLD_3_0 10 48be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien 49be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chiennamespace { 50c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray 51c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray void StripDebugInfoOfFunction(Module* M, const char* name) { 52c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray if (Function* FuncStart = M->getFunction(name)) { 53c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray while (!FuncStart->use_empty()) { 54c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray cast<CallInst>(*FuncStart->use_begin())->eraseFromParent(); 55c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray } 56c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray FuncStart->eraseFromParent(); 57c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray } 58c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray } 59c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray 60be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien /// This function strips all debug info intrinsics, except for llvm.dbg.declare. 61be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien /// If an llvm.dbg.declare intrinsic is invalid, then this function simply 62be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien /// strips that use. 63be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien void CheckDebugInfoIntrinsics(Module *M) { 64c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray StripDebugInfoOfFunction(M, "llvm.dbg.func.start"); 65c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray StripDebugInfoOfFunction(M, "llvm.dbg.stoppoint"); 66c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray StripDebugInfoOfFunction(M, "llvm.dbg.region.start"); 67c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray StripDebugInfoOfFunction(M, "llvm.dbg.region.end"); 68b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 69be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (Function *Declare = M->getFunction("llvm.dbg.declare")) { 70be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (!Declare->use_empty()) { 71c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray DbgDeclareInst *DDI = cast<DbgDeclareInst>(*Declare->use_begin()); 72be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (!isa<MDNode>(DDI->getArgOperand(0)) || 73be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien !isa<MDNode>(DDI->getArgOperand(1))) { 74be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien while (!Declare->use_empty()) { 75c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray CallInst *CI = cast<CallInst>(*Declare->use_begin()); 76be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien CI->eraseFromParent(); 77be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien } 78be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien Declare->eraseFromParent(); 79be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien } 80be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien } 81be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien } 82be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien } 83be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien} // end anonymous namespace 84be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien 85932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReader::FreeState() { 86932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BufferOwned) 87932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete Buffer; 88932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Buffer = 0; 89932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Type*>().swap(TypeList); 90932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.clear(); 91932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.clear(); 92932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 93b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines std::vector<AttributeSet>().swap(MAttributes); 94932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<BasicBlock*>().swap(FunctionBBs); 95932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Function*>().swap(FunctionsWithBodies); 96932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DeferredFunctionInfo.clear(); 97932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDKindMap.clear(); 98932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 99932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 100932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 101932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// Helper functions to implement forward reference resolution, etc. 102932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 103932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 104932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ConvertToString - Convert a string from a record into an std::string, return 105932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// true on failure. 106932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinestemplate<typename StrTy> 107932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic bool ConvertToString(SmallVector<uint64_t, 64> &Record, unsigned Idx, 108932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StrTy &Result) { 109932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx > Record.size()) 110932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 111932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 112932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = Idx, e = Record.size(); i != e; ++i) 113932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Result += (char)Record[i]; 114932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 115932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 116932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 117932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) { 118932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Val) { 119932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Map unknown/new linkages to external 120932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 0: return GlobalValue::ExternalLinkage; 121932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 1: return GlobalValue::WeakAnyLinkage; 122932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 2: return GlobalValue::AppendingLinkage; 123932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 3: return GlobalValue::InternalLinkage; 124932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 4: return GlobalValue::LinkOnceAnyLinkage; 125c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray case 5: return GlobalValue::ExternalLinkage; // Was DLLImportLinkage; 126c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray case 6: return GlobalValue::ExternalLinkage; // Was DLLExportLinkage; 127932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 7: return GlobalValue::ExternalWeakLinkage; 128932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 8: return GlobalValue::CommonLinkage; 129932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 9: return GlobalValue::PrivateLinkage; 130932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 10: return GlobalValue::WeakODRLinkage; 131932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 11: return GlobalValue::LinkOnceODRLinkage; 132932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 12: return GlobalValue::AvailableExternallyLinkage; 133c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray case 13: return GlobalValue::PrivateLinkage; // Was LinkerPrivateLinkage; 134c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray case 14: return GlobalValue::ExternalWeakLinkage; // Was LinkerPrivateWeakLinkage; 135d724d097437f40a5689464429f948ec41e4a2415Stephen Hines //ANDROID: convert LinkOnceODRAutoHideLinkage -> LinkOnceODRLinkage 136d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case 15: return GlobalValue::LinkOnceODRLinkage; 137932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 138932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 139932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 140932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) { 141932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Val) { 142932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Map unknown visibilities to default. 143932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 0: return GlobalValue::DefaultVisibility; 144932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 1: return GlobalValue::HiddenVisibility; 145932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 2: return GlobalValue::ProtectedVisibility; 146932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 147932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 148932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1498b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liaostatic GlobalVariable::ThreadLocalMode GetDecodedThreadLocalMode(unsigned Val) { 1508b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao switch (Val) { 1518b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 0: return GlobalVariable::NotThreadLocal; 1528b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao default: // Map unknown non-zero value to general dynamic. 1538b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 1: return GlobalVariable::GeneralDynamicTLSModel; 1548b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 2: return GlobalVariable::LocalDynamicTLSModel; 1558b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 3: return GlobalVariable::InitialExecTLSModel; 1568b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 4: return GlobalVariable::LocalExecTLSModel; 1578b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao } 1588b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao} 1598b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao 160932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic int GetDecodedCastOpcode(unsigned Val) { 161932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Val) { 162932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: return -1; 163932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_TRUNC : return Instruction::Trunc; 164932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_ZEXT : return Instruction::ZExt; 165932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_SEXT : return Instruction::SExt; 166932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPTOUI : return Instruction::FPToUI; 167932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPTOSI : return Instruction::FPToSI; 168932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_UITOFP : return Instruction::UIToFP; 169932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_SITOFP : return Instruction::SIToFP; 170932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPTRUNC : return Instruction::FPTrunc; 171932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPEXT : return Instruction::FPExt; 172932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_PTRTOINT: return Instruction::PtrToInt; 173932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_INTTOPTR: return Instruction::IntToPtr; 174932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_BITCAST : return Instruction::BitCast; 175932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 176932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 177932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic int GetDecodedBinaryOpcode(unsigned Val, Type *Ty) { 178932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Val) { 179932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: return -1; 180932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_ADD: 181932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FAdd : Instruction::Add; 182932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SUB: 183932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FSub : Instruction::Sub; 184932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_MUL: 185932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FMul : Instruction::Mul; 186932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_UDIV: return Instruction::UDiv; 187932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SDIV: 188932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FDiv : Instruction::SDiv; 189932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_UREM: return Instruction::URem; 190932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SREM: 191932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FRem : Instruction::SRem; 192932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SHL: return Instruction::Shl; 193932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_LSHR: return Instruction::LShr; 194932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_ASHR: return Instruction::AShr; 195932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_AND: return Instruction::And; 196932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_OR: return Instruction::Or; 197932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_XOR: return Instruction::Xor; 198932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 199932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 200932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 201932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesnamespace llvm { 202932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesnamespace { 203932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// @brief A class for maintaining the slot number definition 204932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// as a placeholder for the actual definition for forward constants defs. 205932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines class ConstantPlaceHolder : public ConstantExpr { 206932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines void operator=(const ConstantPlaceHolder &); // DO NOT IMPLEMENT 207932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines public: 208932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // allocate space for exactly one operand 209932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines void *operator new(size_t s) { 210932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return User::operator new(s, 1); 211932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 212932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines explicit ConstantPlaceHolder(Type *Ty, LLVMContext& Context) 213932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) { 214932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Op<0>() = UndefValue::get(Type::getInt32Ty(Context)); 215932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 216932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 217932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// @brief Methods to support type inquiry through isa, cast, and dyn_cast. 218932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines //static inline bool classof(const ConstantPlaceHolder *) { return true; } 219932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static bool classof(const Value *V) { 220932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return isa<ConstantExpr>(V) && 221932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1; 222932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 223932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 224932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 225932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// Provide fast operand accessors 226932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines //DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 227932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines }; 228932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 229932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 230932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// FIXME: can we inherit this from ConstantExpr? 231932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinestemplate <> 232932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstruct OperandTraits<ConstantPlaceHolder> : 233932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines public FixedNumOperandTraits<ConstantPlaceHolder, 1> { 234932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines}; 235932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 236932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 237932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 238932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) { 239932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx == size()) { 240932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines push_back(V); 241932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 242932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 243932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 244932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 245932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx+1); 246932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 247932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines WeakVH &OldV = ValuePtrs[Idx]; 248932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OldV == 0) { 249932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV = V; 250932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 251932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 252932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 253932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Handle constants and non-constants (e.g. instrs) differently for 254932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // efficiency. 255932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Constant *PHC = dyn_cast<Constant>(&*OldV)) { 256932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveConstants.push_back(std::make_pair(PHC, Idx)); 257932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV = V; 258932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 259932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If there was a forward reference to this value, replace it. 260932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *PrevVal = OldV; 261932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV->replaceAllUsesWith(V); 262932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete PrevVal; 263932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 264932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 265932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 266932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 267932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesConstant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, 268932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty) { 269932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 270932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx + 1); 271932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 272932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Value *V = ValuePtrs[Idx]) { 273932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(Ty == V->getType() && "Type mismatch in constant table!"); 274932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return cast<Constant>(V); 275932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 276932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 277932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create and return a placeholder, which will later be RAUW'd. 278932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *C = new ConstantPlaceHolder(Ty, Context); 279932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValuePtrs[Idx] = C; 280932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return C; 281932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 282932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 283932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesValue *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty) { 284932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 285932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx + 1); 286932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 287932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Value *V = ValuePtrs[Idx]) { 288932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!"); 289932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V; 290932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 291932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 292932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No type specified, must be invalid reference. 293932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Ty == 0) return 0; 294932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 295932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create and return a placeholder, which will later be RAUW'd. 296932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = new Argument(Ty); 297932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValuePtrs[Idx] = V; 298932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V; 299932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 300932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 301932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ResolveConstantForwardRefs - Once all constants are read, this method bulk 302932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// resolves any forward references. The idea behind this is that we sometimes 303932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// get constants (such as large arrays) which reference *many* forward ref 304932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// constants. Replacing each of these causes a lot of thrashing when 305932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// building/reuniquing the constant. Instead of doing this, we look at all the 306932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// uses and rewrite all the place holders at once for any constant that uses 307932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// a placeholder. 308932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReaderValueList::ResolveConstantForwardRefs() { 309932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Sort the values by-pointer so that they are efficient to look up with a 310932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // binary search. 311932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::sort(ResolveConstants.begin(), ResolveConstants.end()); 312932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 313932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Constant*, 64> NewOps; 314932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 315932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!ResolveConstants.empty()) { 316932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *RealVal = operator[](ResolveConstants.back().second); 317932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Placeholder = ResolveConstants.back().first; 318932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveConstants.pop_back(); 319932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 320932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Loop over all users of the placeholder, updating them to reference the 321932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // new value. If they reference more than one placeholder, update them all 322932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // at once. 323932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!Placeholder->use_empty()) { 324932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value::use_iterator UI = Placeholder->use_begin(); 325c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray Use &use = *UI; 326c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray User *U = use.getUser(); 327932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 328932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If the using object isn't uniqued, just update the operands. This 329932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // handles instructions and initializers for global variables. 330932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!isa<Constant>(U) || isa<GlobalValue>(U)) { 331c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray use.set(RealVal); 332932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 333932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 334932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 335932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Otherwise, we have a constant that uses the placeholder. Replace that 336932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // constant with a new constant that has *all* placeholder uses updated. 337932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *UserC = cast<Constant>(U); 338932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (User::op_iterator I = UserC->op_begin(), E = UserC->op_end(); 339932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I != E; ++I) { 340932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *NewOp; 341932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!isa<ConstantPlaceHolder>(*I)) { 342932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Not a placeholder reference. 343932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOp = *I; 344932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (*I == Placeholder) { 345932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Common case is that it just references this one placeholder. 346932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOp = RealVal; 347932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 348932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Otherwise, look up the placeholder in ResolveConstants. 349932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveConstantsTy::iterator It = 350932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::lower_bound(ResolveConstants.begin(), ResolveConstants.end(), 351932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::pair<Constant*, unsigned>(cast<Constant>(*I), 352932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 0)); 353932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(It != ResolveConstants.end() && It->first == *I); 354932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOp = operator[](It->second); 355932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 356932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 357932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOps.push_back(cast<Constant>(NewOp)); 358932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 359932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 360932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Make the new constant. 361932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *NewC; 362932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) { 363932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = ConstantArray::get(UserCA->getType(), NewOps); 364932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) { 365932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = ConstantStruct::get(UserCS->getType(), NewOps); 366932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (isa<ConstantVector>(UserC)) { 367932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = ConstantVector::get(NewOps); 368932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 369932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr."); 370932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = cast<ConstantExpr>(UserC)->getWithOperands(NewOps); 371932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 372932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 373932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UserC->replaceAllUsesWith(NewC); 374932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UserC->destroyConstant(); 375932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOps.clear(); 376932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 377932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 378932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Update all ValueHandles, they should be the only users at this point. 379932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Placeholder->replaceAllUsesWith(RealVal); 380932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete Placeholder; 381932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 382932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 383932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 384932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReaderMDValueList::AssignValue(Value *V, unsigned Idx) { 385932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx == size()) { 386932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines push_back(V); 387932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 388932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 389932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 390932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 391932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx+1); 392932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 393932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines WeakVH &OldV = MDValuePtrs[Idx]; 394932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OldV == 0) { 395932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV = V; 396932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 397932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 398932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 399932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If there was a forward reference to this value, replace it. 400932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDNode *PrevVal = cast<MDNode>(OldV); 401932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV->replaceAllUsesWith(V); 402932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDNode::deleteTemporary(PrevVal); 403932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Deleting PrevVal sets Idx value in MDValuePtrs to null. Set new 404932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // value for Idx. 405932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValuePtrs[Idx] = V; 406932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 407932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 408932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesValue *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { 409932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 410932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx + 1); 411932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 412932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Value *V = MDValuePtrs[Idx]) { 413932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(V->getType()->isMetadataTy() && "Type mismatch in value table!"); 414932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V; 415932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 416932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 417932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create and return a placeholder, which will later be RAUW'd. 418932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = MDNode::getTemporary(Context, ArrayRef<Value*>()); 419932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValuePtrs[Idx] = V; 420932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V; 421932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 422932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 423932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesType *BitcodeReader::getTypeByID(unsigned ID) { 424932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // The type table size is always specified correctly. 425932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ID >= TypeList.size()) 426932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return 0; 427b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 428932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *Ty = TypeList[ID]) 429932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty; 430932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 431932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we have a forward reference, the only possible case is when it is to a 432932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // named struct. Just create a placeholder for now. 433b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines return TypeList[ID] = StructType::create(Context); 434932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 435932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 436932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// FIXME: Remove in LLVM 3.1, only used by ParseOldTypeTable. 437932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesType *BitcodeReader::getTypeByIDOrNull(unsigned ID) { 438932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ID >= TypeList.size()) 439932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList.resize(ID+1); 440b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 441932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return TypeList[ID]; 442932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 443932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 444932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 445932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 446932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// Functions for parsing blocks from the bitcode file 447932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 448932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 449d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 450d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// \brief This fills an AttrBuilder object with the LLVM attributes that have 451d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// been decoded from the given integer. This function must stay in sync with 452d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// 'encodeLLVMAttributesForBitcode'. 453d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesstatic void decodeLLVMAttributesForBitcode(AttrBuilder &B, 454d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines uint64_t EncodedAttrs) { 455d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // FIXME: Remove in 4.0. 456d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 457d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The alignment is stored as a 16-bit raw value from bits 31--16. We shift 458d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // the bits above 31 down by 11 bits. 459d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16; 460d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines assert((!Alignment || isPowerOf2_32(Alignment)) && 461d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines "Alignment must be a power of two."); 462d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 463d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Alignment) 464d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines B.addAlignmentAttr(Alignment); 465d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines B.addRawValue(((EncodedAttrs & (0xfffffULL << 32)) >> 11) | 466d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines (EncodedAttrs & 0xffff)); 467d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 468d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 469d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseAttributeBlock() { 470932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) 471d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 472932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 473932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!MAttributes.empty()) 474d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidMultipleBlocks); 475932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 476932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 477932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 478d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SmallVector<AttributeSet, 8> Attrs; 479932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 480932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records. 481932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 482d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 483932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 484d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 485d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 486d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 487d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 488d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 489d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 490d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 491d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 492d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 493932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 494932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 495932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 496932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 497d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 498932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: ignore. 499932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 500d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::PARAMATTR_CODE_ENTRY_OLD: { // ENTRY: [paramidx0, attr0, ...] 501932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() & 1) 502d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 503932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 504b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 505d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines AttrBuilder B; 506d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines decodeLLVMAttributesForBitcode(B, Record[i+1]); 507d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.push_back(AttributeSet::get(Context, Record[i], B)); 508932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 509932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 510d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines MAttributes.push_back(AttributeSet::get(Context, Attrs)); 511d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.clear(); 512d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 513d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 514d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [attrgrp0, attrgrp1, ...] 515d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (unsigned i = 0, e = Record.size(); i != e; ++i) 516d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.push_back(MAttributeGroups[Record[i]]); 517932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 518b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines MAttributes.push_back(AttributeSet::get(Context, Attrs)); 519932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Attrs.clear(); 520932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 521932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 522932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 523932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 524932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 525932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 526d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 527d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseTypeTable() { 528932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW)) 529d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 530b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 531932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return ParseTypeTableBody(); 532932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 533932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 534d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseTypeTableBody() { 535932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!TypeList.empty()) 536d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidMultipleBlocks); 537932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 538932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 539932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumRecords = 0; 540932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 541932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<64> TypeName; 542b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 543932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this type table. 544932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 545d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 546d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 547d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 548d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 549d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 550d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 551d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 552932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords != TypeList.size()) 553d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 554d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 555d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 556d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 557d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 558932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 559932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 560932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 561932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 562932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ResultTy = 0; 563d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 564d724d097437f40a5689464429f948ec41e4a2415Stephen Hines default: 565d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 566932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 567932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // TYPE_CODE_NUMENTRY contains a count of the number of types in the 568932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // type list. This allows us to reserve space. 569932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 570d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 571932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList.resize(Record[0]); 572932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 573932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VOID: // VOID 574932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getVoidTy(Context); 575932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 576d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::TYPE_CODE_HALF: // HALF 577d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ResultTy = Type::getHalfTy(Context); 578d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 579932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FLOAT: // FLOAT 580932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFloatTy(Context); 581932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 582932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_DOUBLE: // DOUBLE 583932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getDoubleTy(Context); 584932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 585932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_FP80: // X86_FP80 586932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_FP80Ty(Context); 587932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 588932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FP128: // FP128 589932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFP128Ty(Context); 590932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 591932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 592932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getPPC_FP128Ty(Context); 593932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 594932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_LABEL: // LABEL 595932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getLabelTy(Context); 596932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 597932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_METADATA: // METADATA 598932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getMetadataTy(Context); 599932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 600932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_MMX: // X86_MMX 601932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_MMXTy(Context); 602932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 603932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 604932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 605d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 606932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 607932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = IntegerType::get(Context, Record[0]); 608932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 609932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 610932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // [pointee type, address space] 611932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 612d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 613932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AddressSpace = 0; 614932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() == 2) 615932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AddressSpace = Record[1]; 616932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = getTypeByID(Record[0]); 617d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (ResultTy == 0) 618d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 619932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = PointerType::get(ResultTy, AddressSpace); 620932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 621932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 6223e88bf7dfe2af63827099a7d5be0173cf4c74f4dStephen Hines case bitc::TYPE_CODE_FUNCTION_OLD: { 623b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // FIXME: attrid is dead, remove it in LLVM 4.0 624932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FUNCTION: [vararg, attrid, retty, paramty x N] 625932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 626d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 627b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Type*, 8> ArgTys; 628932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 3, e = Record.size(); i != e; ++i) { 629932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *T = getTypeByID(Record[i])) 630932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArgTys.push_back(T); 631932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 632932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 633932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 634b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 635932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = getTypeByID(Record[2]); 636932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ResultTy == 0 || ArgTys.size() < Record.size()-3) 637d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 638932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 639932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 640932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 641932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 642932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N] 643932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 644d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 645b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Type*, 8> EltTys; 646932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1, e = Record.size(); i != e; ++i) { 647932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *T = getTypeByID(Record[i])) 648932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EltTys.push_back(T); 649932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 650932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 651932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 652932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (EltTys.size() != Record.size()-1) 653d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 654932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = StructType::get(Context, EltTys, Record[0]); 655932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 656932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 657932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N] 658932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, TypeName)) 659d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 660932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 661932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 662932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N] 663932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 664d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 665b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 666932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords >= TypeList.size()) 667d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 668b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 669932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check to see if this was forward referenced, if so fill in the temp. 670932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 671932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Res) { 672932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Res->setName(TypeName); 673932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NumRecords] = 0; 674932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else // Otherwise, create a new struct. 675bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien Res = StructType::create(Context, TypeName); 676932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeName.clear(); 677b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 678932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Type*, 8> EltTys; 679932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1, e = Record.size(); i != e; ++i) { 680932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *T = getTypeByID(Record[i])) 681932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EltTys.push_back(T); 682932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 683932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 684932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 685932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (EltTys.size() != Record.size()-1) 686d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 687932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Res->setBody(EltTys, Record[0]); 688932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Res; 689932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 690932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 691932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: [] 692932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != 1) 693d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 694932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 695932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords >= TypeList.size()) 696d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 697b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 698932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check to see if this was forward referenced, if so fill in the temp. 699932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 700932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Res) { 701932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Res->setName(TypeName); 702932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NumRecords] = 0; 703932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else // Otherwise, create a new struct with no body. 704bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien Res = StructType::create(Context, TypeName); 705932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeName.clear(); 706932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Res; 707932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 708b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines } 709932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 710932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 711d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 712932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByID(Record[1]))) 713932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = ArrayType::get(ResultTy, Record[0]); 714932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 715d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 716932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 717932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 718932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 719d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 720932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByID(Record[1]))) 721932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = VectorType::get(ResultTy, Record[0]); 722932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 723d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 724932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 725932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 726932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 727932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords >= TypeList.size()) 728d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 729932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(ResultTy && "Didn't read a type?"); 730932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(TypeList[NumRecords] == 0 && "Already read type?"); 731932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NumRecords++] = ResultTy; 732932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 733932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 734932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 735932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// FIXME: Remove in LLVM 3.1 736d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseOldTypeTable() { 737be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (Stream.EnterSubBlock(TYPE_BLOCK_ID_OLD_3_0)) 738d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 739932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 740932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!TypeList.empty()) 741d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 742b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 743b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 744932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // While horrible, we have no good ordering of types in the bc file. Just 745932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // iteratively parse types out of the bc file in multiple passes until we get 746932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // them all. Do this by saving a cursor for the start of the type block. 747932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BitstreamCursor StartOfTypeBlockCursor(Stream); 748b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 749932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumTypesRead = 0; 750b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 751932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 752932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesRestartScan: 753932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextTypeID = 0; 754932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool ReadAnyTypes = false; 755b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 756932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this type table. 757932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 758932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 759932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 760932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID != TypeList.size()) 761d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 762b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 763932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we haven't read all of the types yet, iterate again. 764932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumTypesRead != TypeList.size()) { 765932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we didn't successfully read any types in this pass, then we must 766932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // have an unhandled forward reference. 767932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!ReadAnyTypes) 768d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 769b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 770932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream = StartOfTypeBlockCursor; 771932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines goto RestartScan; 772932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 773b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 774932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 775d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 776d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 777932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 778b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 779932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 780932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 781932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 782932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 783d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 784932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 785932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 786b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 787932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 788932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 789932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 790932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 791b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 792932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 793932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 794932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ResultTy = 0; 795d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 796d724d097437f40a5689464429f948ec41e4a2415Stephen Hines default: return Error(InvalidTYPETable); 797932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 798932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // TYPE_CODE_NUMENTRY contains a count of the number of types in the 799932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // type list. This allows us to reserve space. 800932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 801d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 802932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList.resize(Record[0]); 803932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 804932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VOID: // VOID 805932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getVoidTy(Context); 806932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 807932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FLOAT: // FLOAT 808932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFloatTy(Context); 809932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 810932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_DOUBLE: // DOUBLE 811932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getDoubleTy(Context); 812932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 813932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_FP80: // X86_FP80 814932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_FP80Ty(Context); 815932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 816932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FP128: // FP128 817932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFP128Ty(Context); 818932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 819932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 820932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getPPC_FP128Ty(Context); 821932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 822932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_LABEL: // LABEL 823932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getLabelTy(Context); 824932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 825932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_METADATA: // METADATA 826932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getMetadataTy(Context); 827932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 828932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_MMX: // X86_MMX 829932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_MMXTy(Context); 830932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 831932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 832932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 833d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 834932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = IntegerType::get(Context, Record[0]); 835932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 836932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_OPAQUE: // OPAQUE 837932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID < TypeList.size() && TypeList[NextTypeID] == 0) 838bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien ResultTy = StructType::create(Context, ""); 839932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 840be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien case TYPE_CODE_STRUCT_OLD_3_0: {// STRUCT_OLD 841932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID >= TypeList.size()) break; 842932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we already read it, don't reprocess. 843932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TypeList[NextTypeID] && 844932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines !cast<StructType>(TypeList[NextTypeID])->isOpaque()) 845932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 846932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 847932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Set a type. 848932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TypeList[NextTypeID] == 0) 849bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien TypeList[NextTypeID] = StructType::create(Context, ""); 850932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 851932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Type*> EltTys; 852932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1, e = Record.size(); i != e; ++i) { 853932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *Elt = getTypeByIDOrNull(Record[i])) 854932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EltTys.push_back(Elt); 855932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 856932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 857932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 858932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 859932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (EltTys.size() != Record.size()-1) 860932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; // Not all elements are ready. 861b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 862932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<StructType>(TypeList[NextTypeID])->setBody(EltTys, Record[0]); 863932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = TypeList[NextTypeID]; 864932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NextTypeID] = 0; 865932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 866932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 867932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 868932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // [pointee type, address space] 869932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 870d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 871932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AddressSpace = 0; 872932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() == 2) 873932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AddressSpace = Record[1]; 874932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[0]))) 875932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = PointerType::get(ResultTy, AddressSpace); 876932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 877932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 8783e88bf7dfe2af63827099a7d5be0173cf4c74f4dStephen Hines case bitc::TYPE_CODE_FUNCTION_OLD: { 879932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME: attrid is dead, remove it in LLVM 3.0 880932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FUNCTION: [vararg, attrid, retty, paramty x N] 881932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 882d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 883932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Type*> ArgTys; 884932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 3, e = Record.size(); i != e; ++i) { 885932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *Elt = getTypeByIDOrNull(Record[i])) 886932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArgTys.push_back(Elt); 887932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 888932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 889932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 890932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ArgTys.size()+3 != Record.size()) 891932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; // Something was null. 892932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[2]))) 893932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 894932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 895932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 896932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 897932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 898d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 899932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[1]))) 900932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = ArrayType::get(ResultTy, Record[0]); 901932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 902932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 903932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 904d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 905932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[1]))) 906932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = VectorType::get(ResultTy, Record[0]); 907932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 908932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 909b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 910932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID >= TypeList.size()) 911d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 912b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 913932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ResultTy && TypeList[NextTypeID] == 0) { 914932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++NumTypesRead; 915932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ReadAnyTypes = true; 916b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 917932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NextTypeID] = ResultTy; 918932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 919b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 920932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++NextTypeID; 921932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 922932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 923932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 924932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 925d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseOldTypeSymbolTable() { 926be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (Stream.EnterSubBlock(TYPE_SYMTAB_BLOCK_ID_OLD_3_0)) 927d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 928932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 929932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 930932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 931932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this type table. 932932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string TypeName; 933932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 934932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 935932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 936932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 937d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 938d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 939932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 940932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 941932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 942932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 943932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 944932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 945d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 946932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 947932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 948932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 949932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 950932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 951932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 952932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 953932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 954932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 955932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 956d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 957932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: unknown type. 958932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 959932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TST_CODE_ENTRY: // TST_ENTRY: [typeid, namechar x N] 960932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 1, TypeName)) 961d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 962932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned TypeID = Record[0]; 963932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TypeID >= TypeList.size()) 964d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 965932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 966932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Only apply the type name to a struct type with no name. 967932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (StructType *STy = dyn_cast<StructType>(TypeList[TypeID])) 968bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien if (!STy->isLiteral() && !STy->hasName()) 969932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines STy->setName(TypeName); 970932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeName.clear(); 971932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 972932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 973932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 974932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 975932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 976d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseValueSymbolTable() { 977932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) 978d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 979932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 980932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 981932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 982932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this value table. 983932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<128> ValueName; 984932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 985932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 986932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 987932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 988d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 989d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 990932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 991932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 992932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 993932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 994932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 995d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 996932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 997932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 998932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 999932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 1000932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 1001932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1002932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1003932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1004932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1005932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1006d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 1007932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: unknown type. 1008932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1009932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N] 1010932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 1, ValueName)) 1011d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1012932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ValueID = Record[0]; 1013932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ValueID >= ValueList.size()) 1014d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1015932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = ValueList[ValueID]; 1016932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1017932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V->setName(StringRef(ValueName.data(), ValueName.size())); 1018932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueName.clear(); 1019932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1020932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1021932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VST_CODE_BBENTRY: { 1022932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 1, ValueName)) 1023d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1024932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *BB = getBasicBlock(Record[0]); 1025932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BB == 0) 1026d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1027932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1028932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BB->setName(StringRef(ValueName.data(), ValueName.size())); 1029932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueName.clear(); 1030932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1031932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1032932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1033932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1034932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1035932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1036d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseMetadata() { 1037932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextMDValueNo = MDValueList.size(); 1038932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1039932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) 1040d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1041932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1042932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1043932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1044932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records. 1045932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 1046932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 1047932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 1048932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 1049d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1050d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1051932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1052932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1053932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 1054932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 1055932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 1056932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1057d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1058932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1059932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1060932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1061932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 1062932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 1063932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1064932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1065932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1066932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool IsFunctionLocal = false; 1067932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1068932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1069d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Code = Stream.readRecord(Code, Record); 1070932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Code) { 1071932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: ignore. 1072932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1073932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_NAME: { 1074932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read named of the named metadata. 1075932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NameLength = Record.size(); 1076932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<8> Name; 1077932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Name.resize(NameLength); 1078932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != NameLength; ++i) 1079932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Name[i] = Record[i]; 1080932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1081932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Code = Stream.ReadCode(); 1082932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1083932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // METADATA_NAME is always followed by METADATA_NAMED_NODE. 1084d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned NextBitCode = Stream.readRecord(Code, Record); 1085932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextBitCode == METADATA_NAMED_NODE_2_7) { 1086932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 1087932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (NextBitCode != bitc::METADATA_NAMED_NODE) { 1088932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(!"Invalid Named Metadata record."); (void)NextBitCode; 1089932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1090932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1091932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read named metadata elements. 1092932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1093932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NamedMDNode *NMD = TheModule->getOrInsertNamedMetadata(Name); 1094932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) { 1095932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDNode *MD = dyn_cast<MDNode>(MDValueList.getValueFwdRef(Record[i])); 1096932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (MD == 0) 1097d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1098932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NMD->addOperand(MD); 1099932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1100932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1101932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (LLVM2_7MetadataDetected) { 1102932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.AssignValue(0, NextMDValueNo++); 1103932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1104932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1105932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1106932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case METADATA_FN_NODE_2_7: 1107932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_FN_NODE: 1108932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IsFunctionLocal = true; 1109932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // fall-through 1110932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case METADATA_NODE_2_7: 1111932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_NODE: { 1112932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == METADATA_FN_NODE_2_7 || 1113932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Code == METADATA_NODE_2_7) { 1114932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 1115932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1116932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1117932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() % 2 == 1) 1118d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1119932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1120932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1121932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 8> Elts; 1122932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; i += 2) { 1123932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[i]); 1124d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 1125d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1126932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Ty->isMetadataTy()) 1127932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); 1128932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (!Ty->isVoidTy()) 1129932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty)); 1130932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1131932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(NULL); 1132932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1133932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = MDNode::getWhenValsUnresolved(Context, Elts, IsFunctionLocal); 1134932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IsFunctionLocal = false; 1135932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.AssignValue(V, NextMDValueNo++); 1136932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1137932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1138932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_STRING: { 1139932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned MDStringLength = Record.size(); 1140932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<8> String; 1141932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines String.resize(MDStringLength); 1142932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != MDStringLength; ++i) 1143932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines String[i] = Record[i]; 1144932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = MDString::get(Context, 1145932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StringRef(String.data(), String.size())); 1146932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.AssignValue(V, NextMDValueNo++); 1147932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1148932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1149932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_KIND: { 1150932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned RecordLength = Record.size(); 1151932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty() || RecordLength < 2) 1152d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1153932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<8> Name; 1154932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Name.resize(RecordLength-1); 1155932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Kind = Record[0]; 1156932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1; i != RecordLength; ++i) 1157932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Name[i-1] = Record[i]; 1158b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1159932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NewKind = TheModule->getMDKindID(Name.str()); 1160932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) 1161d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(ConflictingMETADATA_KINDRecords); 1162932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1163932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1164932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1165932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1166932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1167932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1168d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// decodeSignRotatedValue - Decode a signed value stored with the sign bit in 1169932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// the LSB for dense VBR encoding. 1170d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesuint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) { 1171932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((V & 1) == 0) 1172932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V >> 1; 1173932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (V != 1) 1174932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return -(V >> 1); 1175932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // There is no such thing as -0 with integers. "-0" really means MININT. 1176932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return 1ULL << 63; 1177932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1178932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1179932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ResolveGlobalAndAliasInits - Resolve all of the initializers for global 1180932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// values and aliases that we can. 1181d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ResolveGlobalAndAliasInits() { 1182932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist; 1183932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist; 1184932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1185932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInitWorklist.swap(GlobalInits); 1186932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInitWorklist.swap(AliasInits); 1187932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1188932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!GlobalInitWorklist.empty()) { 1189932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ValID = GlobalInitWorklist.back().second; 1190932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ValID >= ValueList.size()) { 1191932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Not ready to resolve this yet, it requires something later in the file. 1192932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInits.push_back(GlobalInitWorklist.back()); 1193932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1194932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 1195932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInitWorklist.back().first->setInitializer(C); 1196932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1197d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(ExpectedConstant); 1198932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1199932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInitWorklist.pop_back(); 1200932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1201932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1202932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!AliasInitWorklist.empty()) { 1203932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ValID = AliasInitWorklist.back().second; 1204932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ValID >= ValueList.size()) { 1205932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInits.push_back(AliasInitWorklist.back()); 1206932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1207932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 1208932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInitWorklist.back().first->setAliasee(C); 1209932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1210d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(ExpectedConstant); 1211932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1212932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInitWorklist.pop_back(); 1213932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1214d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1215932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1216932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1217d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesstatic APInt ReadWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) { 1218d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SmallVector<uint64_t, 8> Words(Vals.size()); 1219d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::transform(Vals.begin(), Vals.end(), Words.begin(), 1220d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitcodeReader::decodeSignRotatedValue); 1221d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1222d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return APInt(TypeBits, Words); 1223d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 1224d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1225d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseConstants() { 1226932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) 1227d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1228932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1229932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1230932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1231932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this value table. 1232932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *CurTy = Type::getInt32Ty(Context); 1233932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextCstNo = ValueList.size(); 1234932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 1235d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 1236d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1237d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 1238d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 1239d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 1240d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1241d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 1242d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (NextCstNo != ValueList.size()) 1243d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidConstantReference); 1244d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1245d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Once all the constants have been read, go through and resolve forward 1246d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // references. 1247d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ValueList.ResolveConstantForwardRefs(); 1248d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1249d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 1250d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 1251932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1252932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1253932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1254932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1255932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1256932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = 0; 1257d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned BitCode = Stream.readRecord(Entry.ID, Record); 1258932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (BitCode) { 1259932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: unknown constant 1260932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_UNDEF: // UNDEF 1261932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); 1262932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1263932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] 1264932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1265d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1266932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[0] >= TypeList.size()) 1267d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1268932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurTy = TypeList[Record[0]]; 1269932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; // Skip the ValueList manipulation. 1270932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_NULL: // NULL 1271932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = Constant::getNullValue(CurTy); 1272932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1273932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_INTEGER: // INTEGER: [intval] 1274932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!CurTy->isIntegerTy() || Record.empty()) 1275d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1276d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0])); 1277932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1278932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval] 1279932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!CurTy->isIntegerTy() || Record.empty()) 1280d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1281932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1282d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt VInt = ReadWideAPInt(Record, 1283d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines cast<IntegerType>(CurTy)->getBitWidth()); 1284d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantInt::get(Context, VInt); 1285d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1286932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1287932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1288932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] 1289932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1290d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1291d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (CurTy->isHalfTy()) 1292d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf, 1293d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(16, (uint16_t)Record[0]))); 1294d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else if (CurTy->isFloatTy()) 1295d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEsingle, 1296d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(32, (uint32_t)Record[0]))); 1297932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurTy->isDoubleTy()) 1298d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEdouble, 1299d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(64, Record[0]))); 1300932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurTy->isX86_FP80Ty()) { 1301932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Bits are not stored the same way as a normal i80 APInt, compensate. 1302932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t Rearrange[2]; 1303932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16); 1304932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Rearrange[1] = Record[0] >> 48; 1305d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::x87DoubleExtended, 1306d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(80, Rearrange))); 1307932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (CurTy->isFP128Ty()) 1308d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEquad, 1309d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(128, Record))); 1310932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurTy->isPPC_FP128Ty()) 1311d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::PPCDoubleDouble, 1312d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(128, Record))); 1313932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1314932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); 1315932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1316932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1317932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1318932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] 1319932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1320d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1321932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1322932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1323b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Constant*, 16> Elts; 1324932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1325932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (StructType *STy = dyn_cast<StructType>(CurTy)) { 1326932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1327932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i], 1328932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines STy->getElementType(i))); 1329932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantStruct::get(STy, Elts); 1330932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) { 1331932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = ATy->getElementType(); 1332932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1333932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 1334932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantArray::get(ATy, Elts); 1335932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) { 1336932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = VTy->getElementType(); 1337932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1338932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 1339932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantVector::get(Elts); 1340932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1341932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); 1342932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1343932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1344932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1345932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_STRING: { // STRING: [values] 1346932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1347d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1348932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1349932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArrayType *ATy = cast<ArrayType>(CurTy); 1350932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = ATy->getElementType(); 1351932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1352932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1353932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Constant*> Elts; 1354932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1355932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ConstantInt::get(EltTy, Record[i])); 1356932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantArray::get(ATy, Elts); 1357932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1358932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1359932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CSTRING: { // CSTRING: [values] 1360932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1361d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1362932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1363932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArrayType *ATy = cast<ArrayType>(CurTy); 1364932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = ATy->getElementType(); 1365932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1366932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1367932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Constant*> Elts; 1368932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1369932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ConstantInt::get(EltTy, Record[i])); 1370932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(Constant::getNullValue(EltTy)); 1371932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantArray::get(ATy, Elts); 1372932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1373932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1374932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] 1375d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1376d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1377932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedBinaryOpcode(Record[0], CurTy); 1378932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc < 0) { 1379932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); // Unknown binop. 1380932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1381932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy); 1382932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy); 1383932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Flags = 0; 1384932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() >= 4) { 1385932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc == Instruction::Add || 1386932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Sub || 1387932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Mul || 1388932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Shl) { 1389932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 1390932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Flags |= OverflowingBinaryOperator::NoSignedWrap; 1391932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 1392932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Flags |= OverflowingBinaryOperator::NoUnsignedWrap; 1393932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (Opc == Instruction::SDiv || 1394932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::UDiv || 1395932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::LShr || 1396932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::AShr) { 1397932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[3] & (1 << bitc::PEO_EXACT)) 1398932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Flags |= SDivOperator::IsExact; 1399932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1400932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1401932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::get(Opc, LHS, RHS, Flags); 1402932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1403932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1404932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1405932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] 1406d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1407d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1408932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedCastOpcode(Record[0]); 1409932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc < 0) { 1410932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); // Unknown cast. 1411932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1412932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[1]); 1413d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!OpTy) 1414d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1415932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); 1416932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getCast(Opc, Op, CurTy); 1417932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1418932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1419932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1420932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_INBOUNDS_GEP: 1421932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands] 1422d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() & 1) 1423d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1424932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Constant*, 16> Elts; 1425932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 1426932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ElTy = getTypeByID(Record[i]); 1427d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!ElTy) 1428d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1429932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); 1430932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1431932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BitCode == bitc::CST_CODE_CE_INBOUNDS_GEP) 1432bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien V = ConstantExpr::getInBoundsGetElementPtr(Elts[0], 1433bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien llvm::ArrayRef<llvm::Constant*>(&Elts[1], Elts.size() - 1)); 1434932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1435bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien V = ConstantExpr::getGetElementPtr(Elts[0], 1436bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien llvm::ArrayRef<llvm::Constant*>(&Elts[1], Elts.size() - 1)); 1437932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1438932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1439932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_SELECT: // CE_SELECT: [opval#, opval#, opval#] 1440d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1441d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1442932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0], 1443932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type::getInt1Ty(Context)), 1444932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.getConstantFwdRef(Record[1],CurTy), 1445932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.getConstantFwdRef(Record[2],CurTy)); 1446932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1447932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval] 1448d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1449d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1450932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = 1451932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1452d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (OpTy == 0) 1453d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1454932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1455932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 1456932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getExtractElement(Op0, Op1); 1457932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1458932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1459932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval] 1460932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1461932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || OpTy == 0) 1462d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1463932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 1464932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[1], 1465932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpTy->getElementType()); 1466932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 1467932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getInsertElement(Op0, Op1, Op2); 1468932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1469932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1470932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] 1471932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1472932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || OpTy == 0) 1473d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1474932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 1475932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); 1476932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 1477932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpTy->getNumElements()); 1478932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy); 1479932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 1480932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1481932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1482932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval] 1483932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *RTy = dyn_cast<VectorType>(CurTy); 1484932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = 1485932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1486932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 4 || RTy == 0 || OpTy == 0) 1487d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1488932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1489932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 1490932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 1491932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines RTy->getNumElements()); 1492932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy); 1493932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 1494932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1495932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1496932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] 1497d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 4) 1498d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1499932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 1500d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (OpTy == 0) 1501d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1502932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1503932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 1504932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1505932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy->isFPOrFPVectorTy()) 1506932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getFCmp(Record[3], Op0, Op1); 1507932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1508932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getICmp(Record[3], Op0, Op1); 1509932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1510932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1511932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_INLINEASM: { 1512d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 2) 1513d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1514932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string AsmStr, ConstrStr; 1515932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool HasSideEffects = Record[0] & 1; 1516932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool IsAlignStack = Record[0] >> 1; 1517932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AsmStrSize = Record[1]; 1518932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (2+AsmStrSize >= Record.size()) 1519d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1520932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ConstStrSize = Record[2+AsmStrSize]; 1521932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (3+AsmStrSize+ConstStrSize > Record.size()) 1522d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1523932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1524932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != AsmStrSize; ++i) 1525932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AsmStr += (char)Record[2+i]; 1526932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != ConstStrSize; ++i) 1527932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ConstrStr += (char)Record[3+AsmStrSize+i]; 1528932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *PTy = cast<PointerType>(CurTy); 1529932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), 1530932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AsmStr, ConstrStr, HasSideEffects, IsAlignStack); 1531932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1532932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1533932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_BLOCKADDRESS:{ 1534d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1535d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1536932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *FnTy = getTypeByID(Record[0]); 1537d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (FnTy == 0) 1538d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1539932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *Fn = 1540932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy)); 1541d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Fn == 0) 1542d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1543b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1544932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalVariable *FwdRef = new GlobalVariable(*Fn->getParent(), 1545932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type::getInt8Ty(Context), 1546932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines false, GlobalValue::InternalLinkage, 1547932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 0, ""); 1548932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BlockAddrFwdRefs[Fn].push_back(std::make_pair(Record[2], FwdRef)); 1549932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = FwdRef; 1550932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1551b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines } 1552932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1553932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1554932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.AssignValue(V, NextCstNo); 1555932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++NextCstNo; 1556932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1557932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1558932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextCstNo != ValueList.size()) 1559d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidConstantReference); 1560932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1561932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 1562d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(ExpectedConstant); 1563932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1564932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Once all the constants have been read, go through and resolve forward 1565932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // references. 1566932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.ResolveConstantForwardRefs(); 1567d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1568932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1569932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1570932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// RememberAndSkipFunctionBody - When we see the block for a function body, 1571932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// remember where it is and then skip it. This lets us lazily deserialize the 1572932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// functions. 1573d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::RememberAndSkipFunctionBody() { 1574932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Get the function we are talking about. 1575932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FunctionsWithBodies.empty()) 1576d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InsufficientFunctionProtos); 1577932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1578932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *Fn = FunctionsWithBodies.back(); 1579932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionsWithBodies.pop_back(); 1580932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1581932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Save the current stream state. 1582932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t CurBit = Stream.GetCurrentBitNo(); 1583932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DeferredFunctionInfo[Fn] = CurBit; 1584932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1585932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Skip over the function block for now. 1586932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1587d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1588d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1589932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1590932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1591d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::GlobalCleanup() { 1592d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Patch the initializers for globals and aliases up. 1593d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ResolveGlobalAndAliasInits(); 1594d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!GlobalInits.empty() || !AliasInits.empty()) 1595d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedGlobalInitializerSet); 1596d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1597d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Look for intrinsic functions which need to be upgraded at some point 1598d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); 1599d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines FI != FE; ++FI) { 1600d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Function *NewFn; 1601d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (UpgradeIntrinsicFunction(FI, NewFn)) 1602d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn)); 1603d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 1604d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1605d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Look for global variables which need to be renamed. 1606d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (Module::global_iterator 1607d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines GI = TheModule->global_begin(), GE = TheModule->global_end(); 1608d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines GI != GE; ++GI) 1609d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines UpgradeGlobalVariable(GI); 1610d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Force deallocation of memory for these vectors to favor the client that 1611d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // want lazy deserialization. 1612d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); 1613d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); 1614d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1615d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 1616d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1617d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseModule(bool Resume) { 1618d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Resume) 1619d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.JumpToBit(NextUnreadBit); 1620d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 1621d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1622932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1623932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1624932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::string> SectionTable; 1625932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::string> GCTable; 1626932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1627932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this module. 1628932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!Stream.AtEndOfStream()) { 1629932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 1630932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 1631932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 1632d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1633932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1634932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Patch the initializers for globals and aliases up. 1635932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveGlobalAndAliasInits(); 1636932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!GlobalInits.empty() || !AliasInits.empty()) 1637d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedGlobalInitializerSet); 1638932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FunctionsWithBodies.empty()) 1639d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InsufficientFunctionProtos); 1640932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1641932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Look for intrinsic functions which need to be upgraded at some point 1642932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); 1643932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FI != FE; ++FI) { 1644932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function* NewFn; 1645932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (UpgradeIntrinsicFunction(FI, NewFn)) 1646932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn)); 1647932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1648932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1649932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Look for global variables which need to be renamed. 1650932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Module::global_iterator 1651932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GI = TheModule->global_begin(), GE = TheModule->global_end(); 1652932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GI != GE; ++GI) 1653932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradeGlobalVariable(GI); 1654932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1655932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Force deallocation of memory for these vectors to favor the client that 1656932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // want lazy deserialization. 1657932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); 1658932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); 1659932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Function*>().swap(FunctionsWithBodies); 1660d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1661932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1662932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1663932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 1664932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadSubBlockID()) { 1665932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Skip unknown content. 1666932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1667d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1668932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1669932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BLOCKINFO_BLOCK_ID: 1670932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockInfoBlock()) 1671d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1672932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1673932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::PARAMATTR_BLOCK_ID: 1674d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseAttributeBlock()) 1675d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1676932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1677932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_BLOCK_ID_NEW: 1678d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseTypeTable()) 1679d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1680932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1681be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien case TYPE_BLOCK_ID_OLD_3_0: 1682d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseOldTypeTable()) 1683d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1684932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1685be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien case TYPE_SYMTAB_BLOCK_ID_OLD_3_0: 1686d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseOldTypeSymbolTable()) 1687d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1688932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1689932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VALUE_SYMTAB_BLOCK_ID: 1690d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseValueSymbolTable()) 1691d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1692d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SeenValueSymbolTable = true; 1693932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1694932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CONSTANTS_BLOCK_ID: 1695d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseConstants()) 1696d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1697d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ResolveGlobalAndAliasInits()) 1698d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1699932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1700932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_BLOCK_ID: 1701d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseMetadata()) 1702d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1703932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1704932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNCTION_BLOCK_ID: 1705932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this is the first function body we've seen, reverse the 1706932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FunctionsWithBodies list. 1707d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!SeenFirstFunctionBody) { 1708932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end()); 1709d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = GlobalCleanup()) 1710d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1711d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SeenFirstFunctionBody = true; 1712932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1713932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1714d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = RememberAndSkipFunctionBody()) 1715d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1716d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // For streaming bitcode, suspend parsing when we reach the function 1717d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // bodies. Subsequent materialization calls will resume it when 1718d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // necessary. For streaming, the function bodies must be at the end of 1719d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // the bitcode. If the bitcode file is old, the symbol table will be 1720d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // at the end instead and will not have been seen yet. In this case, 1721d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // just finish the parse now. 1722d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (LazyStreamer && SeenValueSymbolTable) { 1723d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines NextUnreadBit = Stream.GetCurrentBitNo(); 1724d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1725d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 1726d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 1727932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1728932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1729932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1730932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1731932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1732932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 1733932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 1734932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1735932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1736932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1737932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1738d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 1739932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: break; // Default behavior, ignore unknown content. 1740b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines case bitc::MODULE_CODE_VERSION: { // VERSION: [version#] 1741932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 1742d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1743932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Only version #0 is supported so far. 1744932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[0] != 0) 1745d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 1746932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1747b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines } 1748932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 1749932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1750932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1751d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1752932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule->setTargetTriple(S); 1753932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1754932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1755932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] 1756932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1757932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1758d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1759932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule->setDataLayout(S); 1760932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1761932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1762932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] 1763932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1764932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1765d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1766932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule->setModuleInlineAsm(S); 1767932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1768932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1769932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N] 1770932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1771932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1772d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1773b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // ANDROID: Ignore value, since we never used it anyways. 1774b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // TheModule->addLibrary(S); 1775932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1776932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1777932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] 1778932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1779932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1780d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1781932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SectionTable.push_back(S); 1782932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1783932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1784932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N] 1785932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1786932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1787d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1788932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GCTable.push_back(S); 1789932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1790932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1791932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // GLOBALVAR: [pointer type, isconst, initid, 1792932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // linkage, alignment, section, visibility, threadlocal, 1793932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // unnamed_addr] 1794932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_GLOBALVAR: { 1795932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 6) 1796d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1797932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 1798d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 1799d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1800932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty->isPointerTy()) 1801d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 1802932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); 1803932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Ty = cast<PointerType>(Ty)->getElementType(); 1804932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1805932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool isConstant = Record[1]; 1806932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]); 1807932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Alignment = (1 << Record[4]) >> 1; 1808932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string Section; 1809932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[5]) { 1810932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[5]-1 >= SectionTable.size()) 1811d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 1812932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Section = SectionTable[Record[5]-1]; 1813932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1814932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; 1815932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 6) 1816932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Visibility = GetDecodedVisibility(Record[6]); 18178b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao 18188b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal; 1819932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 7) 18208b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao TLM = GetDecodedThreadLocalMode(Record[7]); 1821932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1822932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool UnnamedAddr = false; 1823932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 8) 1824932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UnnamedAddr = Record[8]; 1825932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1826932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalVariable *NewGV = 1827932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines new GlobalVariable(*TheModule, Ty, isConstant, Linkage, 0, "", 0, 18288b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao TLM, AddressSpace); 1829932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setAlignment(Alignment); 1830932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Section.empty()) 1831932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setSection(Section); 1832932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setVisibility(Visibility); 1833932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setUnnamedAddr(UnnamedAddr); 1834932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1835932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(NewGV); 1836932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1837932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Remember which value to use for the global initializer. 1838932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (unsigned InitID = Record[2]) 1839932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInits.push_back(std::make_pair(NewGV, InitID-1)); 1840932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1841932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1842932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FUNCTION: [type, callingconv, isproto, linkage, paramattr, 1843932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // alignment, section, visibility, gc, unnamed_addr] 1844932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_FUNCTION: { 1845932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 8) 1846d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1847932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 1848d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 1849d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1850932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty->isPointerTy()) 1851d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 1852932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionType *FTy = 1853932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType()); 1854932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy) 1855d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 1856932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1857932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, 1858932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines "", TheModule); 1859932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1860932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setCallingConv(static_cast<CallingConv::ID>(Record[1])); 1861932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool isProto = Record[2]; 1862932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setLinkage(GetDecodedLinkage(Record[3])); 1863932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setAttributes(getAttributes(Record[4])); 1864932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1865932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setAlignment((1 << Record[5]) >> 1); 1866932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[6]) { 1867932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[6]-1 >= SectionTable.size()) 1868d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 1869932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setSection(SectionTable[Record[6]-1]); 1870932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1871932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setVisibility(GetDecodedVisibility(Record[7])); 1872932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 8 && Record[8]) { 1873932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[8]-1 > GCTable.size()) 1874d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 1875932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setGC(GCTable[Record[8]-1].c_str()); 1876932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1877932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool UnnamedAddr = false; 1878932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 9) 1879932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UnnamedAddr = Record[9]; 1880932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setUnnamedAddr(UnnamedAddr); 1881932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(Func); 1882932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1883932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this is a function with a body, remember the prototype we are 1884932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // creating now, so that we can match up the body with them later. 1885d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isProto) { 1886932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionsWithBodies.push_back(Func); 1887d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (LazyStreamer) DeferredFunctionInfo[Func] = 0; 1888d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 1889932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1890932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1891932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // ALIAS: [alias type, aliasee val#, linkage] 1892932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // ALIAS: [alias type, aliasee val#, linkage, visibility] 1893932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_ALIAS: { 1894932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 1895d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1896932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 1897d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 1898d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1899932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty->isPointerTy()) 1900d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 1901932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1902932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]), 1903932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines "", 0, TheModule); 1904932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Old bitcode files didn't have visibility field. 1905932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 3) 1906932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGA->setVisibility(GetDecodedVisibility(Record[3])); 1907932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(NewGA); 1908932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInits.push_back(std::make_pair(NewGA, Record[1])); 1909932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1910932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1911932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// MODULE_CODE_PURGEVALS: [numvals] 1912932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_PURGEVALS: 1913932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Trim down the value list to the specified size. 1914932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1 || Record[0] > ValueList.size()) 1915d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1916932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.shrinkTo(Record[0]); 1917932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1918932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1919932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1920932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1921932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1922d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(BitcodeStreamInvalidSize); 1923932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1924932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1925d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseBitcodeInto(Module *M) { 1926932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule = 0; 1927932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1928d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = InitStream()) 1929d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1930932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1931932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Sniff for the signature. 1932932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.Read(8) != 'B' || 1933932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(8) != 'C' || 1934932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0x0 || 1935932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xC || 1936932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xE || 1937932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xD) 1938d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 1939932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1940932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We expect a number of well-defined blocks, though we don't necessarily 1941932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // need to understand them all. 1942d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 1943d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.AtEndOfStream()) 1944d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1945d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1946d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = 1947d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs); 1948932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1949d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 1950d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 1951d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1952d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 1953d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1954932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1955d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: 1956d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.ID) { 1957d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::BLOCKINFO_BLOCK_ID: 1958d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.ReadBlockInfoBlock()) 1959d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1960d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 1961d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::MODULE_BLOCK_ID: 1962d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Reject multiple MODULE_BLOCK's in a single bitstream. 1963d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (TheModule) 1964d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidMultipleBlocks); 1965d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines TheModule = M; 1966d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseModule(false)) 1967d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1968d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (LazyStreamer) 1969d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1970d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 1971d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines default: 1972d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.SkipBlock()) 1973d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1974d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 1975d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 1976d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 1977d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 1978d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // There should be no records in the top-level of blocks. 1979d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1980d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The ranlib in Xcode 4 will align archive members by appending newlines 1981d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // to the end of them. If this file size is a multiple of 4 but not 8, we 1982d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // have to read and ignore these final 4 bytes :-( 1983d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.getAbbrevIDWidth() == 2 && Entry.ID == 2 && 1984932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a && 1985b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines Stream.AtEndOfStream()) 1986d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1987932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1988d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1989932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1990932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1991932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1992932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1993d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseModuleTriple(std::string &Triple) { 1994932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 1995d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1996932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1997932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1998932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1999932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this module. 2000d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2001d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 2002932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2003d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2004d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 2005d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2006d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2007d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2008d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2009d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2010d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 2011d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 2012932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2013932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2014932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 2015d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 2016932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: break; // Default behavior, ignore unknown content. 2017932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_VERSION: // VERSION: [version#] 2018932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 2019d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2020932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Only version #0 is supported so far. 2021932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[0] != 0) 2022d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2023932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2024932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 2025932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 2026932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 2027d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2028932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Triple = S; 2029932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2030932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2031932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2032932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 2033932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2034932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2035d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(BitcodeStreamInvalidSize); 2036932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2037932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2038d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseTriple(std::string &Triple) { 2039d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = InitStream()) 2040d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2041932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2042932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Sniff for the signature. 2043932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.Read(8) != 'B' || 2044932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(8) != 'C' || 2045932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0x0 || 2046932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xC || 2047932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xE || 2048932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xD) 2049d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 2050932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2051932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We expect a number of well-defined blocks, though we don't necessarily 2052932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // need to understand them all. 2053d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2054d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advance(); 2055932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2056d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2057d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2058d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2059d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2060d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2061932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2062d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: 2063d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Entry.ID == bitc::MODULE_BLOCK_ID) 2064d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return ParseModuleTriple(Triple); 2065932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2066d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Ignore other sub-blocks. 2067d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Stream.SkipBlock()) 2068d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2069d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 2070d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2071d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2072d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.skipRecord(Entry.ID); 2073d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 2074932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2075932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2076932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2077932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2078932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ParseMetadataAttachment - Parse metadata attachments. 2079d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseMetadataAttachment() { 2080932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) 2081d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2082932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2083932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 2084d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2085d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 2086d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2087d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2088d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 2089d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2090d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2091d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2092d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2093d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2094d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 2095932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2096932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2097d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2098932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a metadata attachment record. 2099932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 2100d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 2101932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: ignore. 2102932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2103932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case METADATA_ATTACHMENT_2_7: 2104932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 2105932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_ATTACHMENT: { 2106932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned RecordLength = Record.size(); 2107932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty() || (RecordLength - 1) % 2 == 1) 2108d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2109932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Instruction *Inst = InstructionList[Record[0]]; 2110932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1; i != RecordLength; i = i+2) { 2111932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Kind = Record[i]; 2112932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DenseMap<unsigned, unsigned>::iterator I = 2113932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDKindMap.find(Kind); 2114932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I == MDKindMap.end()) 2115d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 2116932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Node = MDValueList.getValueFwdRef(Record[i+1]); 2117932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Inst->setMetadata(I->second, cast<MDNode>(Node)); 2118932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2119932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2120932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2121932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2122932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2123932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2124932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2125932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ParseFunctionBody - Lazily parse the specified function body block. 2126d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseFunctionBody(Function *F) { 2127932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) 2128d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2129932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2130932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.clear(); 2131932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ModuleValueListSize = ValueList.size(); 2132932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ModuleMDValueListSize = MDValueList.size(); 2133932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2134932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Add all the function arguments to the value table. 2135932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) 2136932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(I); 2137932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2138932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextValueNo = ValueList.size(); 2139932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *CurBB = 0; 2140932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned CurBBNo = 0; 2141932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2142932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DebugLoc LastLoc; 2143b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2144932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records. 2145932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 2146932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 2147932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 2148932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 2149932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 2150d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2151932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2152932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2153932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2154932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 2155932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadSubBlockID()) { 2156932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Skip unknown content. 2157932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 2158d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2159932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2160932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CONSTANTS_BLOCK_ID: 2161d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseConstants()) 2162d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2163932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NextValueNo = ValueList.size(); 2164932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2165932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VALUE_SYMTAB_BLOCK_ID: 2166d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseValueSymbolTable()) 2167d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2168932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2169932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_ATTACHMENT_ID: 2170d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseMetadataAttachment()) 2171d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2172932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2173932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_BLOCK_ID: 2174d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseMetadata()) 2175d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2176932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2177932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2178932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2179932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2180932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2181932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 2182932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 2183932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2184932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2185932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2186932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 2187932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 2188932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Instruction *I = 0; 2189d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned BitCode = Stream.readRecord(Code, Record); 2190932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (BitCode) { 2191932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: reject 2192d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 2193932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks] 2194932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1 || Record[0] == 0) 2195d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2196932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create all the basic blocks for the function. 2197932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionBBs.resize(Record[0]); 2198932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) 2199932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionBBs[i] = BasicBlock::Create(Context, "", F); 2200932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurBB = FunctionBBs[0]; 2201932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2202b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2203932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN 2204932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // This record indicates that the last instruction is at the same 2205932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // location as the previous instruction with a location. 2206932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; 2207b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2208932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Get the last instruction emitted. 2209932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CurBB && !CurBB->empty()) 2210932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &CurBB->back(); 2211932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurBBNo && FunctionBBs[CurBBNo-1] && 2212932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines !FunctionBBs[CurBBNo-1]->empty()) 2213932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &FunctionBBs[CurBBNo-1]->back(); 2214b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2215d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (I == 0) 2216d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2217932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->setDebugLoc(LastLoc); 2218932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; 2219932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2220b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2221932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_DEBUG_LOC_2_7: 2222932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 2223932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia] 2224932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; // Get the last instruction emitted. 2225932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CurBB && !CurBB->empty()) 2226932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &CurBB->back(); 2227932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurBBNo && FunctionBBs[CurBBNo-1] && 2228932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines !FunctionBBs[CurBBNo-1]->empty()) 2229932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &FunctionBBs[CurBBNo-1]->back(); 2230932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I == 0 || Record.size() < 4) 2231d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2232b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2233932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Line = Record[0], Col = Record[1]; 2234932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ScopeID = Record[2], IAID = Record[3]; 2235b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2236932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDNode *Scope = 0, *IA = 0; 2237932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ScopeID) Scope = cast<MDNode>(MDValueList.getValueFwdRef(ScopeID-1)); 2238932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (IAID) IA = cast<MDNode>(MDValueList.getValueFwdRef(IAID-1)); 2239932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LastLoc = DebugLoc::get(Line, Col, Scope, IA); 2240932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->setDebugLoc(LastLoc); 2241932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; 2242932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2243932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2244932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2245932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode] 2246932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2247932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *LHS, *RHS; 2248932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 2249932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, LHS->getType(), RHS) || 2250932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+1 > Record.size()) 2251d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2252932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2253932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); 2254d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Opc == -1) 2255d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2256932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); 2257932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2258932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpNum < Record.size()) { 2259932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc == Instruction::Add || 2260932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Sub || 2261932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Mul || 2262932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Shl) { 2263932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 2264932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<BinaryOperator>(I)->setHasNoSignedWrap(true); 2265932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 2266932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true); 2267932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (Opc == Instruction::SDiv || 2268932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::UDiv || 2269932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::LShr || 2270932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::AShr) { 2271932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[OpNum] & (1 << bitc::PEO_EXACT)) 2272932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<BinaryOperator>(I)->setIsExact(true); 2273932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2274932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2275932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2276932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2277932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc] 2278932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2279932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2280932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2281932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) 2282d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2283932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2284932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ResTy = getTypeByID(Record[OpNum]); 2285932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedCastOpcode(Record[OpNum+1]); 2286932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc == -1 || ResTy == 0) 2287d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2288932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy); 2289932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2290932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2291932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2292932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INBOUNDS_GEP: 2293932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands] 2294932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2295932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *BasePtr; 2296932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) 2297d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2298932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2299932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 16> GEPIdx; 2300932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (OpNum != Record.size()) { 2301932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2302932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2303d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2304932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GEPIdx.push_back(Op); 2305932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2306932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2307bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien I = GetElementPtrInst::Create(BasePtr, GEPIdx); 2308932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2309932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP) 2310932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<GetElementPtrInst>(I)->setIsInBounds(true); 2311932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2312932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2313932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2314932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_EXTRACTVAL: { 2315932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // EXTRACTVAL: [opty, opval, n x indices] 2316932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2317932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Agg; 2318932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2319d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2320932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2321932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<unsigned, 4> EXTRACTVALIdx; 2322932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned RecSize = Record.size(); 2323932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum != RecSize; ++OpNum) { 2324932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t Index = Record[OpNum]; 2325932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((unsigned)Index != Index) 2326d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 2327932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EXTRACTVALIdx.push_back((unsigned)Index); 2328932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2329932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2330932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ExtractValueInst::Create(Agg, EXTRACTVALIdx); 2331932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2332932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2333932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2334932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2335932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INSERTVAL: { 2336932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // INSERTVAL: [opty, opval, opty, opval, n x indices] 2337932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2338932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Agg; 2339932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2340d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2341932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Val; 2342932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Val)) 2343d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2344932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2345932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<unsigned, 4> INSERTVALIdx; 2346932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned RecSize = Record.size(); 2347932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum != RecSize; ++OpNum) { 2348932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t Index = Record[OpNum]; 2349932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((unsigned)Index != Index) 2350d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 2351932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines INSERTVALIdx.push_back((unsigned)Index); 2352932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2353932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2354932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = InsertValueInst::Create(Agg, Val, INSERTVALIdx); 2355932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2356932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2357932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2358932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2359932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval] 2360932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // obsolete form of select 2361932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // handles select i1 ... in old bitcode 2362932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2363932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *TrueVal, *FalseVal, *Cond; 2364932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 2365932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 2366932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Type::getInt1Ty(Context), Cond)) 2367d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2368932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2369932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = SelectInst::Create(Cond, TrueVal, FalseVal); 2370932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2371932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2372932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2373932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2374932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred] 2375932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // new form of select 2376932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // handles select i1 or select [N x i1] 2377932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2378932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *TrueVal, *FalseVal, *Cond; 2379932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 2380932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 2381932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValueTypePair(Record, OpNum, NextValueNo, Cond)) 2382d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2383932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2384932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // select condition can be either i1 or [N x i1] 2385932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (VectorType* vector_type = 2386932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast<VectorType>(Cond->getType())) { 2387932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // expect <n x i1> 2388932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (vector_type->getElementType() != Type::getInt1Ty(Context)) 2389d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 2390932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2391932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // expect i1 2392932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Cond->getType() != Type::getInt1Ty(Context)) 2393d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 2394932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2395932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2396932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = SelectInst::Create(Cond, TrueVal, FalseVal); 2397932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2398932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2399932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2400932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2401932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval] 2402932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2403932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Vec, *Idx; 2404932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 2405932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 2406d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2407932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ExtractElementInst::Create(Vec, Idx); 2408932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2409932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2410932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2411932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2412932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval] 2413932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2414932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Vec, *Elt, *Idx; 2415932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 2416932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, 2417932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<VectorType>(Vec->getType())->getElementType(), Elt) || 2418932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 2419d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2420932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = InsertElementInst::Create(Vec, Elt, Idx); 2421932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2422932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2423932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2424932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2425932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval] 2426932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2427932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Vec1, *Vec2, *Mask; 2428932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) || 2429932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Vec1->getType(), Vec2)) 2430d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2431932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2432932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) 2433d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2434932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new ShuffleVectorInst(Vec1, Vec2, Mask); 2435932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2436932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2437932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2438932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2439932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred] 2440932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Old form of ICmp/FCmp returning bool 2441932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were 2442932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // both legal on vectors but had different behaviour. 2443932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred] 2444932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FCmp/ICmp returning bool or vector of bool 2445932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2446932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2447932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *LHS, *RHS; 2448932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 2449932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, LHS->getType(), RHS) || 2450932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+1 != Record.size()) 2451d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2452932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2453932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (LHS->getType()->isFPOrFPVectorTy()) 2454932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); 2455932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 2456932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS); 2457932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2458932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2459932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2460932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2461932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_GETRESULT_2_7: { 2462932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != 2) { 2463d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2464932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2465932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2466932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2467932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValueTypePair(Record, OpNum, NextValueNo, Op); 2468932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Index = Record[1]; 2469932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ExtractValueInst::Create(Op, Index); 2470932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2471932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2472932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2473932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2474932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>] 2475932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines { 2476932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 2477932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Size == 0) { 2478932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ReturnInst::Create(Context); 2479932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2480932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2481932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2482932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2483932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2484932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op = NULL; 2485932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2486d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2487932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpNum != Record.size()) 2488d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2489932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2490932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ReturnInst::Create(Context, Op); 2491932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2492932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2493932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2494932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] 2495932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != 1 && Record.size() != 3) 2496d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2497932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *TrueDest = getBasicBlock(Record[0]); 2498932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TrueDest == 0) 2499d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2500932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2501932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() == 1) { 2502932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = BranchInst::Create(TrueDest); 2503932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2504932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2505932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else { 2506932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *FalseDest = getBasicBlock(Record[1]); 2507932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Cond = getFnValueByID(Record[2], Type::getInt1Ty(Context)); 2508932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FalseDest == 0 || Cond == 0) 2509d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2510932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = BranchInst::Create(TrueDest, FalseDest, Cond); 2511932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2512932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2513932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2514932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2515932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...] 2516932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || (Record.size() & 1) == 0) 2517d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2518932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 2519932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Cond = getFnValueByID(Record[1], OpTy); 2520932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *Default = getBasicBlock(Record[2]); 2521932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy == 0 || Cond == 0 || Default == 0) 2522d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2523932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumCases = (Record.size()-3)/2; 2524932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); 2525932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(SI); 2526932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = NumCases; i != e; ++i) { 2527932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ConstantInt *CaseVal = 2528932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy)); 2529932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); 2530932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CaseVal == 0 || DestBB == 0) { 2531932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete SI; 2532d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2533932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2534932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SI->addCase(CaseVal, DestBB); 2535932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2536932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = SI; 2537932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2538932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2539932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] 2540932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 2541d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2542932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 2543932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Address = getFnValueByID(Record[1], OpTy); 2544932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy == 0 || Address == 0) 2545d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2546932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumDests = Record.size()-2; 2547932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); 2548932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(IBI); 2549932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = NumDests; i != e; ++i) { 2550932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) { 2551932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IBI->addDestination(DestBB); 2552932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2553932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete IBI; 2554d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2555932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2556932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2557932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = IBI; 2558932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2559932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2560b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2561932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INVOKE: { 2562932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] 2563d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 4) 2564d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2565b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines AttributeSet PAL = getAttributes(Record[0]); 2566932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned CCInfo = Record[1]; 2567932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *NormalBB = getBasicBlock(Record[2]); 2568932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *UnwindBB = getBasicBlock(Record[3]); 2569932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2570932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 4; 2571932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Callee; 2572932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 2573d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2574932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2575932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); 2576932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionType *FTy = !CalleeTy ? 0 : 2577932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast<FunctionType>(CalleeTy->getElementType()); 2578932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2579932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check that the right number of fixed parameters are here. 2580932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FTy == 0 || NormalBB == 0 || UnwindBB == 0 || 2581932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.size() < OpNum+FTy->getNumParams()) 2582d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2583932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2584932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 16> Ops; 2585932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 2586932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Ops.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 2587d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Ops.back() == 0) 2588d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2589932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2590932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2591932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy->isVarArg()) { 2592932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != OpNum) 2593d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2594932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2595932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read type/value pairs for varargs params. 2596932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (OpNum != Record.size()) { 2597932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2598932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2599d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2600932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Ops.push_back(Op); 2601932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2602932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2603932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2604932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops); 2605932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2606932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<InvokeInst>(I)->setCallingConv( 2607932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static_cast<CallingConv::ID>(CCInfo)); 2608932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<InvokeInst>(I)->setAttributes(PAL); 2609932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2610932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2611c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao case FUNC_CODE_INST_UNWIND_2_7: { // UNWIND_OLD 2612c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao // 'unwind' instruction has been removed in LLVM 3.1 2613c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao // Replace 'unwind' with 'landingpad' and 'resume'. 2614c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Type *ExnTy = StructType::get(Type::getInt8PtrTy(Context), 2615c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Type::getInt32Ty(Context), NULL); 2616c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Constant *PersFn = 2617c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao F->getParent()-> 2618c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao getOrInsertFunction("__gcc_personality_v0", 2619c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao FunctionType::get(Type::getInt32Ty(Context), true)); 2620c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 2621c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao LandingPadInst *LP = LandingPadInst::Create(ExnTy, PersFn, 1); 2622c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao LP->setCleanup(true); 2623c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 2624c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao CurBB->getInstList().push_back(LP); 2625c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao I = ResumeInst::Create(LP); 2626932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2627932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2628c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao } 2629932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE 2630932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new UnreachableInst(Context); 2631932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2632932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2633932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...] 2634932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1 || ((Record.size()-1)&1)) 2635d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2636932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 2637d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 2638d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2639932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2640932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2); 2641932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(PN); 2642932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2643932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) { 2644932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = getFnValueByID(Record[1+i], Ty); 2645932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *BB = getBasicBlock(Record[2+i]); 2646d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!V || !BB) 2647d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2648932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PN->addIncoming(V, BB); 2649932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2650932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = PN; 2651932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2652932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2653932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2654932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_MALLOC_2_7: { // MALLOC: [instty, op, align] 2655932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Autoupgrade malloc instruction to malloc call. 2656932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME: Remove in LLVM 3.0. 2657932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) { 2658d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2659932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2660932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *Ty = 2661932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<PointerType>(getTypeByID(Record[0])); 2662932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Size = getFnValueByID(Record[1], Type::getInt32Ty(Context)); 2663d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty || !Size) 2664d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2665d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!CurBB) 2666d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidInstructionWithNoBB); 2667932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Int32Ty = IntegerType::getInt32Ty(CurBB->getContext()); 2668932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *AllocSize = ConstantExpr::getSizeOf(Ty->getElementType()); 2669932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, Int32Ty); 2670932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CallInst::CreateMalloc(CurBB, Int32Ty, Ty->getElementType(), 2671932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AllocSize, Size, NULL); 2672932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2673932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2674932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2675932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_FREE_2_7: { // FREE: [op, opty] 2676932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2677932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2678932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2679932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum != Record.size()) { 2680d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2681932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2682d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!CurBB) 2683d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidInstructionWithNoBB); 2684932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CallInst::CreateFree(Op, CurBB); 2685932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2686932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2687932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2688932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2689932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align] 2690932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // For backward compatibility, tolerate a lack of an opty, and use i32. 2691932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Remove this in LLVM 3.0. 2692932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || Record.size() > 4) { 2693d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2694932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2695932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2696932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *Ty = 2697932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<PointerType>(getTypeByID(Record[OpNum++])); 2698932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = Record.size() == 4 ? getTypeByID(Record[OpNum++]) : 2699932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type::getInt32Ty(Context); 2700932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Size = getFnValueByID(Record[OpNum++], OpTy); 2701932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Align = Record[OpNum++]; 2702d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty || !Size) 2703d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2704932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); 2705932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2706932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2707932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2708932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol] 2709932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2710932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2711932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2712932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) 2713d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2714932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2715932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2716932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2717932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2718932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2719932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_STORE: { // STORE2:[ptrty, ptr, val, align, vol] 2720932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2721932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Val, *Ptr; 2722932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 2723932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, 2724932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<PointerType>(Ptr->getType())->getElementType(), Val) || 2725932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) 2726d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2727932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2728932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2729932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2730932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2731932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2732932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_STORE_2_7: { 2733932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2734932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Val, *Ptr; 2735932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Val) || 2736932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, 2737932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType::getUnqual(Val->getType()), Ptr)|| 2738932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) { 2739d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2740932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2741932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2742932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2743932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2744932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2745932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_CALL_2_7: 2746932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 2747932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CALL: { 2748932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] 2749932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 2750d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2751932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2752b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines AttributeSet PAL = getAttributes(Record[0]); 2753932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned CCInfo = Record[1]; 2754932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2755932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 2; 2756932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Callee; 2757932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 2758d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2759932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2760932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); 2761932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionType *FTy = 0; 2762932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType()); 2763932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy || Record.size() < FTy->getNumParams()+OpNum) 2764d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2765932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2766932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 16> Args; 2767932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read the fixed params. 2768932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 2769932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FTy->getParamType(i)->isLabelTy()) 2770932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Args.push_back(getBasicBlock(Record[OpNum])); 2771932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 2772932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Args.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 2773d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Args.back() == 0) 2774d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2775932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2776932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2777932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read type/value pairs for varargs params. 2778932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy->isVarArg()) { 2779932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpNum != Record.size()) 2780d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2781932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2782932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (OpNum != Record.size()) { 2783932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2784932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2785d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2786932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Args.push_back(Op); 2787932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2788932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2789932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2790932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CallInst::Create(Callee, Args); 2791932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2792932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<CallInst>(I)->setCallingConv( 2793932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static_cast<CallingConv::ID>(CCInfo>>1)); 2794932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<CallInst>(I)->setTailCall(CCInfo & 1); 2795932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<CallInst>(I)->setAttributes(PAL); 2796932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2797932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2798932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] 2799932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 2800d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2801932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 2802932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op = getFnValueByID(Record[1], OpTy); 2803932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ResTy = getTypeByID(Record[2]); 2804932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!OpTy || !Op || !ResTy) 2805d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2806932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new VAArgInst(Op, ResTy); 2807932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2808932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2809932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2810932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2811932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2812932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Add instruction to end of current BB. If there is no current BB, reject 2813932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // this file. 2814932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CurBB == 0) { 2815932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete I; 2816d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidInstructionWithNoBB); 2817932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2818932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurBB->getInstList().push_back(I); 2819932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2820932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this was a terminator instruction, move to the next block. 2821932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (isa<TerminatorInst>(I)) { 2822932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++CurBBNo; 2823932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0; 2824932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2825932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2826932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Non-void values get registered in the value table for future use. 2827932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I && !I->getType()->isVoidTy()) 2828932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.AssignValue(I, NextValueNo++); 2829932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2830932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2831932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check the function list for unresolved values. 2832932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Argument *A = dyn_cast<Argument>(ValueList.back())) { 2833932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (A->getParent() == 0) { 2834932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We found at least one unresolved value. Nuke them all to avoid leaks. 2835932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){ 2836932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((A = dyn_cast<Argument>(ValueList[i])) && A->getParent() == 0) { 2837932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines A->replaceAllUsesWith(UndefValue::get(A->getType())); 2838932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete A; 2839932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2840932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2841d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(NeverResolvedValueFoundInFunction); 2842932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2843932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2844932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2845932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME: Check for unresolved forward-declared metadata references 2846932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // and clean up leaks. 2847932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2848932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // See if anything took the address of blocks in this function. If so, 2849932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // resolve them now. 2850932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DenseMap<Function*, std::vector<BlockAddrRefTy> >::iterator BAFRI = 2851932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BlockAddrFwdRefs.find(F); 2852932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BAFRI != BlockAddrFwdRefs.end()) { 2853932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<BlockAddrRefTy> &RefList = BAFRI->second; 2854932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = RefList.size(); i != e; ++i) { 2855932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned BlockIdx = RefList[i].first; 2856932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BlockIdx >= FunctionBBs.size()) 2857d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 2858b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2859932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalVariable *FwdRef = RefList[i].second; 2860932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx])); 2861932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FwdRef->eraseFromParent(); 2862932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2863b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2864932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BlockAddrFwdRefs.erase(BAFRI); 2865932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2866932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2867932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NewMDValueListSize = MDValueList.size(); 2868932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Trim the value list down to the size it was before we parsed this function. 2869932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.shrinkTo(ModuleValueListSize); 2870932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.shrinkTo(ModuleMDValueListSize); 2871932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2872932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (LLVM2_7MetadataDetected) { 2873932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.resize(NewMDValueListSize); 2874932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2875932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2876932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<BasicBlock*>().swap(FunctionBBs); 2877d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2878932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2879932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2880932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 2881932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// GVMaterializer implementation 2882932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 2883932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2884932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2885932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::isMaterializable(const GlobalValue *GV) const { 2886932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (const Function *F = dyn_cast<Function>(GV)) { 2887932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return F->isDeclaration() && 2888932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DeferredFunctionInfo.count(const_cast<Function*>(F)); 2889932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2890932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 2891932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2892932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2893d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::Materialize(GlobalValue *GV) { 2894932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *F = dyn_cast<Function>(GV); 2895932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If it's not a function or is already material, ignore the request. 2896d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!F || !F->isMaterializable()) 2897d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2898932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2899932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F); 2900932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!"); 2901932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2902932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Move the bit stream to the saved position of the deferred function body. 2903932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.JumpToBit(DFII->second); 2904932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2905d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseFunctionBody(F)) 2906d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2907932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2908932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Upgrade any old intrinsic calls in the function. 2909932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(), 2910932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines E = UpgradedIntrinsics.end(); I != E; ++I) { 2911932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I->first != I->second) { 2912932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Value::use_iterator UI = I->first->use_begin(), 2913932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UE = I->first->use_end(); UI != UE; ) { 2914932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 2915932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradeIntrinsicCall(CI, I->second); 2916932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2917932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2918932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2919932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2920d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2921932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2922932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2923932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::isDematerializable(const GlobalValue *GV) const { 2924932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines const Function *F = dyn_cast<Function>(GV); 2925932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!F || F->isDeclaration()) 2926932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 2927932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return DeferredFunctionInfo.count(const_cast<Function*>(F)); 2928932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2929932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2930932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReader::Dematerialize(GlobalValue *GV) { 2931932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *F = dyn_cast<Function>(GV); 2932932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this function isn't dematerializable, this is a noop. 2933932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!F || !isDematerializable(F)) 2934932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 2935932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2936932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(DeferredFunctionInfo.count(F) && "No info to read function later?"); 2937932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2938932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Just forget the function body, we can remat it later. 2939932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines F->deleteBody(); 2940932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2941932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2942932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2943d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::MaterializeModule(Module *M) { 2944932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(M == TheModule && 2945932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines "Can only Materialize the Module this BitcodeReader is attached to."); 2946932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Iterate over the module, deserializing any functions that are still on 2947932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // disk. 2948932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Module::iterator F = TheModule->begin(), E = TheModule->end(); 2949d724d097437f40a5689464429f948ec41e4a2415Stephen Hines F != E; ++F) { 2950d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (F->isMaterializable()) { 2951d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = Materialize(F)) 2952d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2953d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 2954d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 2955932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2956932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Upgrade any intrinsic calls that slipped through (should not happen!) and 2957932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // delete the old functions to clean up. We can't do this unless the entire 2958932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // module is materialized because there could always be another function body 2959932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // with calls to the old function. 2960932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (std::vector<std::pair<Function*, Function*> >::iterator I = 2961932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) { 2962932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I->first != I->second) { 2963932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Value::use_iterator UI = I->first->use_begin(), 2964932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UE = I->first->use_end(); UI != UE; ) { 2965932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 2966932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradeIntrinsicCall(CI, I->second); 2967932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2968932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!I->first->use_empty()) 2969932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->first->replaceAllUsesWith(I->second); 2970932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->first->eraseFromParent(); 2971932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2972932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2973932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics); 2974932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2975932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check debug info intrinsics. 2976932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CheckDebugInfoIntrinsics(TheModule); 2977932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2978d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2979932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2980932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2981d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::InitStream() { 2982d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (LazyStreamer) 2983d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return InitLazyStream(); 2984d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return InitStreamFromBuffer(); 2985d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 2986d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2987d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::InitStreamFromBuffer() { 2988d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *BufPtr = (const unsigned char*)Buffer->getBufferStart(); 2989d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); 2990d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2991d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Buffer->getBufferSize() & 3) { 2992d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isRawBitcode(BufPtr, BufEnd) && !isBitcodeWrapper(BufPtr, BufEnd)) 2993d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 2994d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else 2995d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(BitcodeStreamInvalidSize); 2996d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 2997d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2998d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // If we have a wrapper header, parse it and ignore the non-bc file contents. 2999d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The magic number is 0x0B17C0DE stored in little endian. 3000d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (isBitcodeWrapper(BufPtr, BufEnd)) 3001d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true)) 3002d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeWrapperHeader); 3003d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3004d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamFile.reset(new BitstreamReader(BufPtr, BufEnd)); 3005d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.init(*StreamFile); 3006d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3007d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 3008d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 3009d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3010d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::InitLazyStream() { 3011d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Check and strip off the bitcode wrapper; BitstreamReader expects never to 3012d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // see it. 3013d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamingMemoryObject *Bytes = new StreamingMemoryObject(LazyStreamer); 3014d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamFile.reset(new BitstreamReader(Bytes)); 3015d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.init(*StreamFile); 3016d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3017d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned char buf[16]; 301888f8c52abea50f411c3774c935a6a1e04d17c182Stephen Hines if (Bytes->readBytes(0, 16, buf) == -1) 3019d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(BitcodeStreamInvalidSize); 3020d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3021d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isBitcode(buf, buf + 16)) 3022d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 3023d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3024d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (isBitcodeWrapper(buf, buf + 4)) { 3025d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *bitcodeStart = buf; 3026d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *bitcodeEnd = buf + 16; 3027d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false); 3028d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Bytes->dropLeadingBytes(bitcodeStart - buf); 3029d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Bytes->setKnownObjectSize(bitcodeEnd - bitcodeStart); 3030d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 3031d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 3032d724d097437f40a5689464429f948ec41e4a2415Stephen Hines} 3033d724d097437f40a5689464429f948ec41e4a2415Stephen Hines 3034d724d097437f40a5689464429f948ec41e4a2415Stephen Hinesnamespace { 3035d724d097437f40a5689464429f948ec41e4a2415Stephen Hinesclass BitcodeErrorCategoryType : public _do_message { 3036c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray const char *name() const override { 3037d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "llvm.bitcode"; 3038d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3039c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray std::string message(int IE) const override { 3040d724d097437f40a5689464429f948ec41e4a2415Stephen Hines BitcodeReader::ErrorType E = static_cast<BitcodeReader::ErrorType>(IE); 3041d724d097437f40a5689464429f948ec41e4a2415Stephen Hines switch (E) { 3042d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::BitcodeStreamInvalidSize: 3043d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Bitcode stream length should be >= 16 bytes and a multiple of 4"; 3044d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::ConflictingMETADATA_KINDRecords: 3045d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Conflicting METADATA_KIND records"; 3046d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::CouldNotFindFunctionInStream: 3047d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Could not find function in stream"; 3048d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::ExpectedConstant: 3049d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Expected a constant"; 3050d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InsufficientFunctionProtos: 3051d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Insufficient function protos"; 3052d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidBitcodeSignature: 3053d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid bitcode signature"; 3054d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidBitcodeWrapperHeader: 3055d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid bitcode wrapper header"; 3056d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidConstantReference: 3057d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid ronstant reference"; 3058d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidID: 3059d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid ID"; 3060d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidInstructionWithNoBB: 3061d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid instruction with no BB"; 3062d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidRecord: 3063d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid record"; 3064d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidTypeForValue: 3065d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid type for value"; 3066d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidTYPETable: 3067d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid TYPE table"; 3068d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidType: 3069d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid type"; 3070d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::MalformedBlock: 3071d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Malformed block"; 3072d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::MalformedGlobalInitializerSet: 3073d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Malformed global initializer set"; 3074d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidMultipleBlocks: 3075d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid multiple blocks"; 3076d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::NeverResolvedValueFoundInFunction: 3077d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Never resolved value found in function"; 3078d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidValue: 3079d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid value"; 3080d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3081d724d097437f40a5689464429f948ec41e4a2415Stephen Hines llvm_unreachable("Unknown error type!"); 3082d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3083d724d097437f40a5689464429f948ec41e4a2415Stephen Hines}; 3084d724d097437f40a5689464429f948ec41e4a2415Stephen Hines} 3085d724d097437f40a5689464429f948ec41e4a2415Stephen Hines 3086d724d097437f40a5689464429f948ec41e4a2415Stephen Hinesconst error_category &BitcodeReader::BitcodeErrorCategory() { 3087d724d097437f40a5689464429f948ec41e4a2415Stephen Hines static BitcodeErrorCategoryType O; 3088d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return O; 3089d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 3090932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3091932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 3092932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// External interface 3093932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 3094932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3095932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// getLazyBitcodeModule - lazy function-at-a-time loading from a file. 3096932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// 3097932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesModule *llvm_2_7::getLazyBitcodeModule(MemoryBuffer *Buffer, 3098932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVMContext& Context, 3099932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string *ErrMsg) { 3100932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Module *M = new Module(Buffer->getBufferIdentifier(), Context); 3101932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BitcodeReader *R = new BitcodeReader(Buffer, Context); 3102932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines M->setMaterializer(R); 3103d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = R->ParseBitcodeInto(M)) { 3104932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ErrMsg) 3105d724d097437f40a5689464429f948ec41e4a2415Stephen Hines *ErrMsg = EC.message(); 3106932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3107932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete M; // Also deletes R. 3108932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return 0; 3109932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3110932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Have the BitcodeReader dtor delete 'Buffer'. 3111932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines R->setBufferOwned(true); 3112932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return M; 3113932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3114932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3115932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ParseBitcodeFile - Read the specified bitcode file, returning the module. 3116932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// If an error occurs, return null and fill in *ErrMsg if non-null. 3117932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesModule *llvm_2_7::ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext& Context, 3118932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string *ErrMsg){ 3119932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Module *M = llvm_2_7::getLazyBitcodeModule(Buffer, Context, ErrMsg); 3120932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!M) return 0; 3121932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3122932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether 3123932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // there was an error. 3124932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static_cast<BitcodeReader*>(M->getMaterializer())->setBufferOwned(false); 3125932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3126932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read in the entire module, and destroy the BitcodeReader. 3127c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray if (llvm::error_code ec = M->materializeAllPermanently()) { 3128c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray *ErrMsg = ec.message(); 3129932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete M; 3130932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return 0; 3131932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3132932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3133932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return M; 3134932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3135932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3136932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstd::string llvm_2_7::getBitcodeTargetTriple(MemoryBuffer *Buffer, 3137932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVMContext& Context, 3138932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string *ErrMsg) { 3139932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BitcodeReader *R = new BitcodeReader(Buffer, Context); 3140932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Don't let the BitcodeReader dtor delete 'Buffer'. 3141932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines R->setBufferOwned(false); 3142932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3143932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string Triple(""); 3144d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = R->ParseTriple(Triple)) 3145932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ErrMsg) 3146d724d097437f40a5689464429f948ec41e4a2415Stephen Hines *ErrMsg = EC.message(); 3147932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3148932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete R; 3149932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Triple; 3150932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3151