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 469f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_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: 489f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 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 527f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_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 534f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_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); 554f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 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 736f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_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); 776f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 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 925f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_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); 938f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 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 976f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_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); 989f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 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 1036f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_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); 1050f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 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 1179a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines// FIXME: Delete this in LLVM 4.0 and just assert that the aliasee is a 1180a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines// GlobalObject. 1181a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hinesstatic GlobalObject & 1182a630078b32eb37a8de91ae09e26babf235d4fc9fStephen HinesgetGlobalObjectInExpr(const DenseMap<GlobalAlias *, Constant *> &Map, 1183a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines Constant &C) { 1184a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines auto *GO = dyn_cast<GlobalObject>(&C); 1185a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines if (GO) 1186a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines return *GO; 1187a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines 1188a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines auto *GA = dyn_cast<GlobalAlias>(&C); 1189a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines if (GA) 1190a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines return getGlobalObjectInExpr(Map, *Map.find(GA)->second); 1191a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines 1192a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines auto &CE = cast<ConstantExpr>(C); 1193a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines assert(CE.getOpcode() == Instruction::BitCast || 1194a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines CE.getOpcode() == Instruction::GetElementPtr || 1195a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines CE.getOpcode() == Instruction::AddrSpaceCast); 1196a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines if (CE.getOpcode() == Instruction::GetElementPtr) 1197a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines assert(cast<GEPOperator>(CE).hasAllZeroIndices()); 1198a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines return getGlobalObjectInExpr(Map, *CE.getOperand(0)); 1199a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines} 1200a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines 1201932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ResolveGlobalAndAliasInits - Resolve all of the initializers for global 1202932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// values and aliases that we can. 1203f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_code BitcodeReader::ResolveGlobalAndAliasInits() { 1204932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist; 1205932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist; 1206932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1207932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInitWorklist.swap(GlobalInits); 1208932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInitWorklist.swap(AliasInits); 1209932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1210932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!GlobalInitWorklist.empty()) { 1211932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ValID = GlobalInitWorklist.back().second; 1212932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ValID >= ValueList.size()) { 1213932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Not ready to resolve this yet, it requires something later in the file. 1214932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInits.push_back(GlobalInitWorklist.back()); 1215932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1216932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 1217932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInitWorklist.back().first->setInitializer(C); 1218932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1219d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(ExpectedConstant); 1220932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1221932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInitWorklist.pop_back(); 1222932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1223932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1224a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines // FIXME: Delete this in LLVM 4.0 1225a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines // Older versions of llvm could write an alias pointing to another. We cannot 1226a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines // construct those aliases, so we first collect an alias to aliasee expression 1227a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines // and then compute the actual aliasee. 1228a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines DenseMap<GlobalAlias *, Constant *> AliasInit; 1229a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines 1230932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!AliasInitWorklist.empty()) { 1231932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ValID = AliasInitWorklist.back().second; 1232932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ValID >= ValueList.size()) { 1233932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInits.push_back(AliasInitWorklist.back()); 1234932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1235932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 1236a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines AliasInit.insert(std::make_pair(AliasInitWorklist.back().first, C)); 1237932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1238d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(ExpectedConstant); 1239932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1240932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInitWorklist.pop_back(); 1241932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1242a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines 1243a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines for (auto &Pair : AliasInit) { 1244a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines auto &GO = getGlobalObjectInExpr(AliasInit, *Pair.second); 1245a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines Pair.first->setAliasee(&GO); 1246a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines } 1247a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines 1248f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 1249932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1250932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1251d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesstatic APInt ReadWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) { 1252d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SmallVector<uint64_t, 8> Words(Vals.size()); 1253d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::transform(Vals.begin(), Vals.end(), Words.begin(), 1254d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitcodeReader::decodeSignRotatedValue); 1255d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1256d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return APInt(TypeBits, Words); 1257d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 1258d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1259f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_code BitcodeReader::ParseConstants() { 1260932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) 1261d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1262932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1263932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1264932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1265932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this value table. 1266932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *CurTy = Type::getInt32Ty(Context); 1267932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextCstNo = ValueList.size(); 1268932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 1269d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 1270d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1271d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 1272d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 1273d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 1274d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1275d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 1276d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (NextCstNo != ValueList.size()) 1277d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidConstantReference); 1278d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1279d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Once all the constants have been read, go through and resolve forward 1280d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // references. 1281d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ValueList.ResolveConstantForwardRefs(); 1282f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 1283d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 1284d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 1285932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1286932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1287932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1288932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1289932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1290932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = 0; 1291d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned BitCode = Stream.readRecord(Entry.ID, Record); 1292932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (BitCode) { 1293932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: unknown constant 1294932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_UNDEF: // UNDEF 1295932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); 1296932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1297932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] 1298932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1299d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1300932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[0] >= TypeList.size()) 1301d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1302932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurTy = TypeList[Record[0]]; 1303932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; // Skip the ValueList manipulation. 1304932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_NULL: // NULL 1305932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = Constant::getNullValue(CurTy); 1306932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1307932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_INTEGER: // INTEGER: [intval] 1308932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!CurTy->isIntegerTy() || Record.empty()) 1309d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1310d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0])); 1311932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1312932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval] 1313932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!CurTy->isIntegerTy() || Record.empty()) 1314d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1315932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1316d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt VInt = ReadWideAPInt(Record, 1317d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines cast<IntegerType>(CurTy)->getBitWidth()); 1318d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantInt::get(Context, VInt); 1319d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1320932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1321932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1322932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] 1323932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1324d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1325d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (CurTy->isHalfTy()) 1326d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf, 1327d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(16, (uint16_t)Record[0]))); 1328d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else if (CurTy->isFloatTy()) 1329d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEsingle, 1330d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(32, (uint32_t)Record[0]))); 1331932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurTy->isDoubleTy()) 1332d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEdouble, 1333d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(64, Record[0]))); 1334932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurTy->isX86_FP80Ty()) { 1335932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Bits are not stored the same way as a normal i80 APInt, compensate. 1336932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t Rearrange[2]; 1337932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16); 1338932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Rearrange[1] = Record[0] >> 48; 1339d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::x87DoubleExtended, 1340d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(80, Rearrange))); 1341932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (CurTy->isFP128Ty()) 1342d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEquad, 1343d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(128, Record))); 1344932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurTy->isPPC_FP128Ty()) 1345d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::PPCDoubleDouble, 1346d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(128, Record))); 1347932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1348932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); 1349932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1350932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1351932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1352932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] 1353932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1354d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1355932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1356932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1357b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Constant*, 16> Elts; 1358932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1359932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (StructType *STy = dyn_cast<StructType>(CurTy)) { 1360932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1361932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i], 1362932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines STy->getElementType(i))); 1363932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantStruct::get(STy, Elts); 1364932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) { 1365932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = ATy->getElementType(); 1366932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1367932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 1368932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantArray::get(ATy, Elts); 1369932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) { 1370932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = VTy->getElementType(); 1371932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1372932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 1373932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantVector::get(Elts); 1374932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1375932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); 1376932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1377932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1378932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1379932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_STRING: { // STRING: [values] 1380932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1381d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1382932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1383932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArrayType *ATy = cast<ArrayType>(CurTy); 1384932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = ATy->getElementType(); 1385932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1386932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1387932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Constant*> Elts; 1388932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1389932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ConstantInt::get(EltTy, Record[i])); 1390932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantArray::get(ATy, Elts); 1391932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1392932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1393932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CSTRING: { // CSTRING: [values] 1394932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1395d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1396932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1397932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArrayType *ATy = cast<ArrayType>(CurTy); 1398932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = ATy->getElementType(); 1399932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1400932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1401932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Constant*> Elts; 1402932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1403932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ConstantInt::get(EltTy, Record[i])); 1404932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(Constant::getNullValue(EltTy)); 1405932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantArray::get(ATy, Elts); 1406932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1407932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1408932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] 1409d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1410d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1411932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedBinaryOpcode(Record[0], CurTy); 1412932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc < 0) { 1413932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); // Unknown binop. 1414932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1415932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy); 1416932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy); 1417932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Flags = 0; 1418932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() >= 4) { 1419932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc == Instruction::Add || 1420932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Sub || 1421932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Mul || 1422932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Shl) { 1423932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 1424932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Flags |= OverflowingBinaryOperator::NoSignedWrap; 1425932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 1426932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Flags |= OverflowingBinaryOperator::NoUnsignedWrap; 1427932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (Opc == Instruction::SDiv || 1428932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::UDiv || 1429932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::LShr || 1430932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::AShr) { 1431932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[3] & (1 << bitc::PEO_EXACT)) 1432932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Flags |= SDivOperator::IsExact; 1433932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1434932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1435932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::get(Opc, LHS, RHS, Flags); 1436932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1437932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1438932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1439932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] 1440d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1441d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1442932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedCastOpcode(Record[0]); 1443932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc < 0) { 1444932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); // Unknown cast. 1445932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1446932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[1]); 1447d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!OpTy) 1448d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1449932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); 1450932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getCast(Opc, Op, CurTy); 1451932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1452932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1453932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1454932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_INBOUNDS_GEP: 1455932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands] 1456d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() & 1) 1457d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1458932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Constant*, 16> Elts; 1459932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 1460932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ElTy = getTypeByID(Record[i]); 1461d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!ElTy) 1462d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1463932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); 1464932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1465932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BitCode == bitc::CST_CODE_CE_INBOUNDS_GEP) 1466bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien V = ConstantExpr::getInBoundsGetElementPtr(Elts[0], 1467bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien llvm::ArrayRef<llvm::Constant*>(&Elts[1], Elts.size() - 1)); 1468932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1469bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien V = ConstantExpr::getGetElementPtr(Elts[0], 1470bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien llvm::ArrayRef<llvm::Constant*>(&Elts[1], Elts.size() - 1)); 1471932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1472932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1473932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_SELECT: // CE_SELECT: [opval#, opval#, opval#] 1474d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1475d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1476932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0], 1477932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type::getInt1Ty(Context)), 1478932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.getConstantFwdRef(Record[1],CurTy), 1479932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.getConstantFwdRef(Record[2],CurTy)); 1480932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1481932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval] 1482d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1483d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1484932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = 1485932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1486d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (OpTy == 0) 1487d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1488932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1489932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 1490932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getExtractElement(Op0, Op1); 1491932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1492932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1493932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval] 1494932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1495932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || OpTy == 0) 1496d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1497932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 1498932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[1], 1499932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpTy->getElementType()); 1500932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 1501932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getInsertElement(Op0, Op1, Op2); 1502932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1503932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1504932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] 1505932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1506932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || OpTy == 0) 1507d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1508932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 1509932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); 1510932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 1511932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpTy->getNumElements()); 1512932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy); 1513932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 1514932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1515932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1516932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval] 1517932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *RTy = dyn_cast<VectorType>(CurTy); 1518932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = 1519932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1520932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 4 || RTy == 0 || OpTy == 0) 1521d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1522932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1523932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 1524932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 1525932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines RTy->getNumElements()); 1526932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy); 1527932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 1528932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1529932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1530932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] 1531d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 4) 1532d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1533932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 1534d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (OpTy == 0) 1535d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1536932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1537932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 1538932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1539932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy->isFPOrFPVectorTy()) 1540932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getFCmp(Record[3], Op0, Op1); 1541932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1542932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getICmp(Record[3], Op0, Op1); 1543932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1544932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1545932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_INLINEASM: { 1546d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 2) 1547d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1548932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string AsmStr, ConstrStr; 1549932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool HasSideEffects = Record[0] & 1; 1550932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool IsAlignStack = Record[0] >> 1; 1551932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AsmStrSize = Record[1]; 1552932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (2+AsmStrSize >= Record.size()) 1553d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1554932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ConstStrSize = Record[2+AsmStrSize]; 1555932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (3+AsmStrSize+ConstStrSize > Record.size()) 1556d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1557932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1558932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != AsmStrSize; ++i) 1559932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AsmStr += (char)Record[2+i]; 1560932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != ConstStrSize; ++i) 1561932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ConstrStr += (char)Record[3+AsmStrSize+i]; 1562932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *PTy = cast<PointerType>(CurTy); 1563932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), 1564932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AsmStr, ConstrStr, HasSideEffects, IsAlignStack); 1565932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1566932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1567932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_BLOCKADDRESS:{ 1568d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1569d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1570932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *FnTy = getTypeByID(Record[0]); 1571d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (FnTy == 0) 1572d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1573932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *Fn = 1574932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy)); 1575d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Fn == 0) 1576d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1577b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1578932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalVariable *FwdRef = new GlobalVariable(*Fn->getParent(), 1579932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type::getInt8Ty(Context), 1580932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines false, GlobalValue::InternalLinkage, 1581932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 0, ""); 1582932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BlockAddrFwdRefs[Fn].push_back(std::make_pair(Record[2], FwdRef)); 1583932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = FwdRef; 1584932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1585b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines } 1586932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1587932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1588932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.AssignValue(V, NextCstNo); 1589932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++NextCstNo; 1590932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1591932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1592932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextCstNo != ValueList.size()) 1593d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidConstantReference); 1594932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1595932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 1596d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(ExpectedConstant); 1597932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1598932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Once all the constants have been read, go through and resolve forward 1599932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // references. 1600932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.ResolveConstantForwardRefs(); 1601f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 1602932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1603932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1604932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// RememberAndSkipFunctionBody - When we see the block for a function body, 1605932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// remember where it is and then skip it. This lets us lazily deserialize the 1606932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// functions. 1607f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_code BitcodeReader::RememberAndSkipFunctionBody() { 1608932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Get the function we are talking about. 1609932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FunctionsWithBodies.empty()) 1610d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InsufficientFunctionProtos); 1611932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1612932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *Fn = FunctionsWithBodies.back(); 1613932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionsWithBodies.pop_back(); 1614932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1615932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Save the current stream state. 1616932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t CurBit = Stream.GetCurrentBitNo(); 1617932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DeferredFunctionInfo[Fn] = CurBit; 1618932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1619932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Skip over the function block for now. 1620932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1621d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1622f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 1623932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1624932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1625f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_code BitcodeReader::GlobalCleanup() { 1626d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Patch the initializers for globals and aliases up. 1627d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ResolveGlobalAndAliasInits(); 1628d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!GlobalInits.empty() || !AliasInits.empty()) 1629d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedGlobalInitializerSet); 1630d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1631d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Look for intrinsic functions which need to be upgraded at some point 1632d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); 1633d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines FI != FE; ++FI) { 1634d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Function *NewFn; 1635d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (UpgradeIntrinsicFunction(FI, NewFn)) 1636d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn)); 1637d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 1638d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1639d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Look for global variables which need to be renamed. 1640d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (Module::global_iterator 1641d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines GI = TheModule->global_begin(), GE = TheModule->global_end(); 1642d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines GI != GE; ++GI) 1643d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines UpgradeGlobalVariable(GI); 1644d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Force deallocation of memory for these vectors to favor the client that 1645d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // want lazy deserialization. 1646d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); 1647d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); 1648f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 1649d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 1650d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1651f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_code BitcodeReader::ParseModule(bool Resume) { 1652d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Resume) 1653d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.JumpToBit(NextUnreadBit); 1654d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 1655d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1656932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1657932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1658932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::string> SectionTable; 1659932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::string> GCTable; 1660932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1661932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this module. 1662932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!Stream.AtEndOfStream()) { 1663932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 1664932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 1665932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 1666d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1667932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1668932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Patch the initializers for globals and aliases up. 1669932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveGlobalAndAliasInits(); 1670932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!GlobalInits.empty() || !AliasInits.empty()) 1671d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedGlobalInitializerSet); 1672932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FunctionsWithBodies.empty()) 1673d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InsufficientFunctionProtos); 1674932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1675932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Look for intrinsic functions which need to be upgraded at some point 1676932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); 1677932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FI != FE; ++FI) { 1678932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function* NewFn; 1679932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (UpgradeIntrinsicFunction(FI, NewFn)) 1680932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn)); 1681932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1682932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1683932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Look for global variables which need to be renamed. 1684932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Module::global_iterator 1685932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GI = TheModule->global_begin(), GE = TheModule->global_end(); 1686932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GI != GE; ++GI) 1687932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradeGlobalVariable(GI); 1688932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1689932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Force deallocation of memory for these vectors to favor the client that 1690932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // want lazy deserialization. 1691932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); 1692932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); 1693932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Function*>().swap(FunctionsWithBodies); 1694f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 1695932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1696932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1697932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 1698932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadSubBlockID()) { 1699932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Skip unknown content. 1700932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1701d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1702932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1703932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BLOCKINFO_BLOCK_ID: 1704932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockInfoBlock()) 1705d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1706932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1707932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::PARAMATTR_BLOCK_ID: 1708f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = ParseAttributeBlock()) 1709d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1710932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1711932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_BLOCK_ID_NEW: 1712f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = ParseTypeTable()) 1713d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1714932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1715be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien case TYPE_BLOCK_ID_OLD_3_0: 1716f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = ParseOldTypeTable()) 1717d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1718932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1719be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien case TYPE_SYMTAB_BLOCK_ID_OLD_3_0: 1720f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = ParseOldTypeSymbolTable()) 1721d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1722932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1723932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VALUE_SYMTAB_BLOCK_ID: 1724f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = ParseValueSymbolTable()) 1725d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1726d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SeenValueSymbolTable = true; 1727932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1728932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CONSTANTS_BLOCK_ID: 1729f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = ParseConstants()) 1730d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1731f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = ResolveGlobalAndAliasInits()) 1732d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1733932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1734932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_BLOCK_ID: 1735f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = ParseMetadata()) 1736d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1737932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1738932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNCTION_BLOCK_ID: 1739932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this is the first function body we've seen, reverse the 1740932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FunctionsWithBodies list. 1741d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!SeenFirstFunctionBody) { 1742932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end()); 1743f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = GlobalCleanup()) 1744d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1745d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SeenFirstFunctionBody = true; 1746932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1747932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1748f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = RememberAndSkipFunctionBody()) 1749d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1750d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // For streaming bitcode, suspend parsing when we reach the function 1751d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // bodies. Subsequent materialization calls will resume it when 1752d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // necessary. For streaming, the function bodies must be at the end of 1753d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // the bitcode. If the bitcode file is old, the symbol table will be 1754d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // at the end instead and will not have been seen yet. In this case, 1755d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // just finish the parse now. 1756d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (LazyStreamer && SeenValueSymbolTable) { 1757d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines NextUnreadBit = Stream.GetCurrentBitNo(); 1758f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 1759d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 1760d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 1761932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1762932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1763932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1764932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1765932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1766932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 1767932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 1768932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1769932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1770932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1771932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1772d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 1773932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: break; // Default behavior, ignore unknown content. 1774b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines case bitc::MODULE_CODE_VERSION: { // VERSION: [version#] 1775932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 1776d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1777932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Only version #0 is supported so far. 1778932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[0] != 0) 1779d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 1780932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1781b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines } 1782932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 1783932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1784932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1785d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1786932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule->setTargetTriple(S); 1787932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1788932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1789932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] 1790932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1791932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1792d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1793932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule->setDataLayout(S); 1794932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1795932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1796932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] 1797932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1798932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1799d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1800932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule->setModuleInlineAsm(S); 1801932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1802932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1803932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N] 1804932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1805932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1806d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1807b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // ANDROID: Ignore value, since we never used it anyways. 1808b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // TheModule->addLibrary(S); 1809932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1810932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1811932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] 1812932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1813932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1814d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1815932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SectionTable.push_back(S); 1816932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1817932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1818932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N] 1819932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1820932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1821d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1822932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GCTable.push_back(S); 1823932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1824932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1825932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // GLOBALVAR: [pointer type, isconst, initid, 1826932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // linkage, alignment, section, visibility, threadlocal, 1827932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // unnamed_addr] 1828932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_GLOBALVAR: { 1829932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 6) 1830d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1831932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 1832d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 1833d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1834932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty->isPointerTy()) 1835d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 1836932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); 1837932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Ty = cast<PointerType>(Ty)->getElementType(); 1838932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1839932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool isConstant = Record[1]; 1840932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]); 1841932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Alignment = (1 << Record[4]) >> 1; 1842932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string Section; 1843932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[5]) { 1844932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[5]-1 >= SectionTable.size()) 1845d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 1846932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Section = SectionTable[Record[5]-1]; 1847932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1848932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; 1849932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 6) 1850932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Visibility = GetDecodedVisibility(Record[6]); 18518b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao 18528b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal; 1853932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 7) 18548b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao TLM = GetDecodedThreadLocalMode(Record[7]); 1855932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1856932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool UnnamedAddr = false; 1857932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 8) 1858932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UnnamedAddr = Record[8]; 1859932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1860932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalVariable *NewGV = 1861932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines new GlobalVariable(*TheModule, Ty, isConstant, Linkage, 0, "", 0, 18628b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao TLM, AddressSpace); 1863932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setAlignment(Alignment); 1864932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Section.empty()) 1865932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setSection(Section); 1866932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setVisibility(Visibility); 1867932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setUnnamedAddr(UnnamedAddr); 1868932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1869932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(NewGV); 1870932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1871932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Remember which value to use for the global initializer. 1872932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (unsigned InitID = Record[2]) 1873932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInits.push_back(std::make_pair(NewGV, InitID-1)); 1874932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1875932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1876932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FUNCTION: [type, callingconv, isproto, linkage, paramattr, 1877932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // alignment, section, visibility, gc, unnamed_addr] 1878932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_FUNCTION: { 1879932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 8) 1880d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1881932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 1882d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 1883d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1884932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty->isPointerTy()) 1885d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 1886932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionType *FTy = 1887932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType()); 1888932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy) 1889d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 1890932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1891932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, 1892932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines "", TheModule); 1893932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1894932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setCallingConv(static_cast<CallingConv::ID>(Record[1])); 1895932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool isProto = Record[2]; 1896932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setLinkage(GetDecodedLinkage(Record[3])); 1897932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setAttributes(getAttributes(Record[4])); 1898932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1899932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setAlignment((1 << Record[5]) >> 1); 1900932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[6]) { 1901932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[6]-1 >= SectionTable.size()) 1902d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 1903932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setSection(SectionTable[Record[6]-1]); 1904932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1905932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setVisibility(GetDecodedVisibility(Record[7])); 1906932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 8 && Record[8]) { 1907932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[8]-1 > GCTable.size()) 1908d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 1909932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setGC(GCTable[Record[8]-1].c_str()); 1910932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1911932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool UnnamedAddr = false; 1912932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 9) 1913932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UnnamedAddr = Record[9]; 1914932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setUnnamedAddr(UnnamedAddr); 1915932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(Func); 1916932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1917932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this is a function with a body, remember the prototype we are 1918932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // creating now, so that we can match up the body with them later. 1919d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isProto) { 1920932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionsWithBodies.push_back(Func); 1921d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (LazyStreamer) DeferredFunctionInfo[Func] = 0; 1922d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 1923932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1924932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1925932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // ALIAS: [alias type, aliasee val#, linkage] 1926932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // ALIAS: [alias type, aliasee val#, linkage, visibility] 1927932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_ALIAS: { 1928932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 1929d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1930932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 1931d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 1932d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1933a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines auto *PTy = dyn_cast<PointerType>(Ty); 1934a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines if (!PTy) 1935d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 1936932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1937a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines GlobalAlias *NewGA = 1938a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(), 1939a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines GetDecodedLinkage(Record[2]), "", 0, TheModule); 1940932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Old bitcode files didn't have visibility field. 1941932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 3) 1942932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGA->setVisibility(GetDecodedVisibility(Record[3])); 1943932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(NewGA); 1944932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInits.push_back(std::make_pair(NewGA, Record[1])); 1945932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1946932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1947932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// MODULE_CODE_PURGEVALS: [numvals] 1948932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_PURGEVALS: 1949932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Trim down the value list to the specified size. 1950932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1 || Record[0] > ValueList.size()) 1951d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1952932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.shrinkTo(Record[0]); 1953932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1954932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1955932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1956932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1957932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1958d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(BitcodeStreamInvalidSize); 1959932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1960932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1961f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_code BitcodeReader::ParseBitcodeInto(Module *M) { 1962932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule = 0; 1963932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1964f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = InitStream()) 1965d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1966932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1967932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Sniff for the signature. 1968932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.Read(8) != 'B' || 1969932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(8) != 'C' || 1970932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0x0 || 1971932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xC || 1972932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xE || 1973932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xD) 1974d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 1975932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1976932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We expect a number of well-defined blocks, though we don't necessarily 1977932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // need to understand them all. 1978d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 1979d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.AtEndOfStream()) 1980f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 1981d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1982d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = 1983d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs); 1984932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1985d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 1986d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 1987d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1988d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 1989f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 1990932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1991d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: 1992d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.ID) { 1993d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::BLOCKINFO_BLOCK_ID: 1994d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.ReadBlockInfoBlock()) 1995d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1996d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 1997d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::MODULE_BLOCK_ID: 1998d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Reject multiple MODULE_BLOCK's in a single bitstream. 1999d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (TheModule) 2000d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidMultipleBlocks); 2001d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines TheModule = M; 2002f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = ParseModule(false)) 2003d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2004d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (LazyStreamer) 2005f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 2006d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 2007d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines default: 2008d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.SkipBlock()) 2009d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2010d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 2011d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 2012d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 2013d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2014d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // There should be no records in the top-level of blocks. 2015d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2016d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The ranlib in Xcode 4 will align archive members by appending newlines 2017d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // to the end of them. If this file size is a multiple of 4 but not 8, we 2018d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // have to read and ignore these final 4 bytes :-( 2019d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.getAbbrevIDWidth() == 2 && Entry.ID == 2 && 2020932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a && 2021b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines Stream.AtEndOfStream()) 2022f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 2023932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2024d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2025932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2026932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2027932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2028932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2029f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_code BitcodeReader::ParseModuleTriple(std::string &Triple) { 2030932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 2031d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2032932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2033932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 2034932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2035932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this module. 2036d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2037d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 2038932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2039d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2040d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 2041d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2042d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2043d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2044f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 2045d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2046d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 2047d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 2048932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2049932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2050932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 2051d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 2052932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: break; // Default behavior, ignore unknown content. 2053932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_VERSION: // VERSION: [version#] 2054932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 2055d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2056932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Only version #0 is supported so far. 2057932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[0] != 0) 2058d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2059932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2060932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 2061932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 2062932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 2063d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2064932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Triple = S; 2065932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2066932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2067932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2068932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 2069932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2070932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2071d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(BitcodeStreamInvalidSize); 2072932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2073932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2074f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_code BitcodeReader::ParseTriple(std::string &Triple) { 2075f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = InitStream()) 2076d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2077932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2078932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Sniff for the signature. 2079932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.Read(8) != 'B' || 2080932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(8) != 'C' || 2081932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0x0 || 2082932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xC || 2083932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xE || 2084932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xD) 2085d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 2086932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2087932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We expect a number of well-defined blocks, though we don't necessarily 2088932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // need to understand them all. 2089d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2090d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advance(); 2091932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2092d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2093d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2094d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2095d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2096f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 2097932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2098d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: 2099d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Entry.ID == bitc::MODULE_BLOCK_ID) 2100d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return ParseModuleTriple(Triple); 2101932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2102d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Ignore other sub-blocks. 2103d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Stream.SkipBlock()) 2104d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2105d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 2106d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2107d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2108d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.skipRecord(Entry.ID); 2109d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 2110932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2111932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2112932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2113932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2114932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ParseMetadataAttachment - Parse metadata attachments. 2115f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_code BitcodeReader::ParseMetadataAttachment() { 2116932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) 2117d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2118932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2119932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 2120d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2121d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 2122d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2123d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2124d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 2125d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2126d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2127d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2128f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 2129d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2130d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 2131932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2132932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2133d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2134932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a metadata attachment record. 2135932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 2136d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 2137932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: ignore. 2138932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2139932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case METADATA_ATTACHMENT_2_7: 2140932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 2141932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_ATTACHMENT: { 2142932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned RecordLength = Record.size(); 2143932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty() || (RecordLength - 1) % 2 == 1) 2144d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2145932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Instruction *Inst = InstructionList[Record[0]]; 2146932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1; i != RecordLength; i = i+2) { 2147932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Kind = Record[i]; 2148932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DenseMap<unsigned, unsigned>::iterator I = 2149932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDKindMap.find(Kind); 2150932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I == MDKindMap.end()) 2151d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 2152932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Node = MDValueList.getValueFwdRef(Record[i+1]); 2153932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Inst->setMetadata(I->second, cast<MDNode>(Node)); 2154932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2155932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2156932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2157932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2158932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2159932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2160932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2161932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ParseFunctionBody - Lazily parse the specified function body block. 2162f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_code BitcodeReader::ParseFunctionBody(Function *F) { 2163932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) 2164d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2165932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2166932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.clear(); 2167932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ModuleValueListSize = ValueList.size(); 2168932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ModuleMDValueListSize = MDValueList.size(); 2169932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2170932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Add all the function arguments to the value table. 2171932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) 2172932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(I); 2173932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2174932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextValueNo = ValueList.size(); 2175932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *CurBB = 0; 2176932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned CurBBNo = 0; 2177932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2178932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DebugLoc LastLoc; 2179b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2180932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records. 2181932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 2182932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 2183932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 2184932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 2185932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 2186d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2187932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2188932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2189932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2190932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 2191932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadSubBlockID()) { 2192932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Skip unknown content. 2193932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 2194d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2195932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2196932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CONSTANTS_BLOCK_ID: 2197f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = ParseConstants()) 2198d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2199932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NextValueNo = ValueList.size(); 2200932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2201932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VALUE_SYMTAB_BLOCK_ID: 2202f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = ParseValueSymbolTable()) 2203d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2204932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2205932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_ATTACHMENT_ID: 2206f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = ParseMetadataAttachment()) 2207d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2208932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2209932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_BLOCK_ID: 2210f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = ParseMetadata()) 2211d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2212932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2213932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2214932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2215932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2216932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2217932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 2218932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 2219932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2220932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2221932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2222932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 2223932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 2224932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Instruction *I = 0; 2225d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned BitCode = Stream.readRecord(Code, Record); 2226932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (BitCode) { 2227932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: reject 2228d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 2229932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks] 2230932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1 || Record[0] == 0) 2231d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2232932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create all the basic blocks for the function. 2233932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionBBs.resize(Record[0]); 2234932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) 2235932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionBBs[i] = BasicBlock::Create(Context, "", F); 2236932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurBB = FunctionBBs[0]; 2237932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2238b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2239932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN 2240932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // This record indicates that the last instruction is at the same 2241932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // location as the previous instruction with a location. 2242932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; 2243b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2244932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Get the last instruction emitted. 2245932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CurBB && !CurBB->empty()) 2246932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &CurBB->back(); 2247932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurBBNo && FunctionBBs[CurBBNo-1] && 2248932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines !FunctionBBs[CurBBNo-1]->empty()) 2249932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &FunctionBBs[CurBBNo-1]->back(); 2250b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2251d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (I == 0) 2252d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2253932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->setDebugLoc(LastLoc); 2254932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; 2255932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2256b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2257932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_DEBUG_LOC_2_7: 2258932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 2259932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia] 2260932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; // Get the last instruction emitted. 2261932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CurBB && !CurBB->empty()) 2262932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &CurBB->back(); 2263932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurBBNo && FunctionBBs[CurBBNo-1] && 2264932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines !FunctionBBs[CurBBNo-1]->empty()) 2265932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &FunctionBBs[CurBBNo-1]->back(); 2266932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I == 0 || Record.size() < 4) 2267d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2268b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2269932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Line = Record[0], Col = Record[1]; 2270932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ScopeID = Record[2], IAID = Record[3]; 2271b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2272932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDNode *Scope = 0, *IA = 0; 2273932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ScopeID) Scope = cast<MDNode>(MDValueList.getValueFwdRef(ScopeID-1)); 2274932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (IAID) IA = cast<MDNode>(MDValueList.getValueFwdRef(IAID-1)); 2275932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LastLoc = DebugLoc::get(Line, Col, Scope, IA); 2276932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->setDebugLoc(LastLoc); 2277932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; 2278932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2279932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2280932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2281932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode] 2282932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2283932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *LHS, *RHS; 2284932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 2285932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, LHS->getType(), RHS) || 2286932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+1 > Record.size()) 2287d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2288932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2289932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); 2290d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Opc == -1) 2291d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2292932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); 2293932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2294932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpNum < Record.size()) { 2295932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc == Instruction::Add || 2296932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Sub || 2297932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Mul || 2298932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Shl) { 2299932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 2300932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<BinaryOperator>(I)->setHasNoSignedWrap(true); 2301932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 2302932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true); 2303932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (Opc == Instruction::SDiv || 2304932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::UDiv || 2305932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::LShr || 2306932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::AShr) { 2307932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[OpNum] & (1 << bitc::PEO_EXACT)) 2308932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<BinaryOperator>(I)->setIsExact(true); 2309932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2310932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2311932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2312932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2313932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc] 2314932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2315932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2316932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2317932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) 2318d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2319932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2320932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ResTy = getTypeByID(Record[OpNum]); 2321932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedCastOpcode(Record[OpNum+1]); 2322932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc == -1 || ResTy == 0) 2323d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2324932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy); 2325932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2326932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2327932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2328932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INBOUNDS_GEP: 2329932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands] 2330932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2331932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *BasePtr; 2332932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) 2333d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2334932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2335932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 16> GEPIdx; 2336932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (OpNum != Record.size()) { 2337932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2338932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2339d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2340932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GEPIdx.push_back(Op); 2341932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2342932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2343bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien I = GetElementPtrInst::Create(BasePtr, GEPIdx); 2344932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2345932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP) 2346932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<GetElementPtrInst>(I)->setIsInBounds(true); 2347932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2348932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2349932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2350932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_EXTRACTVAL: { 2351932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // EXTRACTVAL: [opty, opval, n x indices] 2352932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2353932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Agg; 2354932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2355d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2356932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2357932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<unsigned, 4> EXTRACTVALIdx; 2358932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned RecSize = Record.size(); 2359932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum != RecSize; ++OpNum) { 2360932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t Index = Record[OpNum]; 2361932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((unsigned)Index != Index) 2362d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 2363932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EXTRACTVALIdx.push_back((unsigned)Index); 2364932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2365932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2366932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ExtractValueInst::Create(Agg, EXTRACTVALIdx); 2367932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2368932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2369932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2370932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2371932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INSERTVAL: { 2372932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // INSERTVAL: [opty, opval, opty, opval, n x indices] 2373932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2374932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Agg; 2375932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2376d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2377932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Val; 2378932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Val)) 2379d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2380932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2381932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<unsigned, 4> INSERTVALIdx; 2382932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned RecSize = Record.size(); 2383932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum != RecSize; ++OpNum) { 2384932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t Index = Record[OpNum]; 2385932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((unsigned)Index != Index) 2386d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 2387932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines INSERTVALIdx.push_back((unsigned)Index); 2388932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2389932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2390932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = InsertValueInst::Create(Agg, Val, INSERTVALIdx); 2391932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2392932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2393932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2394932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2395932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval] 2396932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // obsolete form of select 2397932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // handles select i1 ... in old bitcode 2398932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2399932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *TrueVal, *FalseVal, *Cond; 2400932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 2401932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 2402932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Type::getInt1Ty(Context), Cond)) 2403d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2404932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2405932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = SelectInst::Create(Cond, TrueVal, FalseVal); 2406932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2407932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2408932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2409932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2410932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred] 2411932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // new form of select 2412932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // handles select i1 or select [N x i1] 2413932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2414932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *TrueVal, *FalseVal, *Cond; 2415932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 2416932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 2417932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValueTypePair(Record, OpNum, NextValueNo, Cond)) 2418d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2419932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2420932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // select condition can be either i1 or [N x i1] 2421932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (VectorType* vector_type = 2422932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast<VectorType>(Cond->getType())) { 2423932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // expect <n x i1> 2424932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (vector_type->getElementType() != Type::getInt1Ty(Context)) 2425d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 2426932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2427932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // expect i1 2428932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Cond->getType() != Type::getInt1Ty(Context)) 2429d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 2430932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2431932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2432932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = SelectInst::Create(Cond, TrueVal, FalseVal); 2433932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2434932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2435932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2436932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2437932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval] 2438932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2439932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Vec, *Idx; 2440932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 2441932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 2442d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2443932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ExtractElementInst::Create(Vec, Idx); 2444932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2445932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2446932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2447932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2448932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval] 2449932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2450932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Vec, *Elt, *Idx; 2451932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 2452932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, 2453932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<VectorType>(Vec->getType())->getElementType(), Elt) || 2454932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 2455d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2456932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = InsertElementInst::Create(Vec, Elt, Idx); 2457932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2458932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2459932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2460932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2461932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval] 2462932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2463932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Vec1, *Vec2, *Mask; 2464932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) || 2465932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Vec1->getType(), Vec2)) 2466d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2467932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2468932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) 2469d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2470932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new ShuffleVectorInst(Vec1, Vec2, Mask); 2471932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2472932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2473932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2474932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2475932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred] 2476932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Old form of ICmp/FCmp returning bool 2477932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were 2478932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // both legal on vectors but had different behaviour. 2479932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred] 2480932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FCmp/ICmp returning bool or vector of bool 2481932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2482932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2483932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *LHS, *RHS; 2484932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 2485932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, LHS->getType(), RHS) || 2486932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+1 != Record.size()) 2487d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2488932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2489932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (LHS->getType()->isFPOrFPVectorTy()) 2490932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); 2491932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 2492932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS); 2493932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2494932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2495932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2496932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2497932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_GETRESULT_2_7: { 2498932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != 2) { 2499d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2500932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2501932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2502932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2503932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValueTypePair(Record, OpNum, NextValueNo, Op); 2504932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Index = Record[1]; 2505932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ExtractValueInst::Create(Op, Index); 2506932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2507932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2508932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2509932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2510932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>] 2511932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines { 2512932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 2513932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Size == 0) { 2514932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ReturnInst::Create(Context); 2515932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2516932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2517932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2518932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2519932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2520932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op = NULL; 2521932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2522d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2523932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpNum != Record.size()) 2524d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2525932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2526932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ReturnInst::Create(Context, Op); 2527932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2528932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2529932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2530932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] 2531932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != 1 && Record.size() != 3) 2532d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2533932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *TrueDest = getBasicBlock(Record[0]); 2534932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TrueDest == 0) 2535d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2536932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2537932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() == 1) { 2538932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = BranchInst::Create(TrueDest); 2539932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2540932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2541932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else { 2542932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *FalseDest = getBasicBlock(Record[1]); 2543932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Cond = getFnValueByID(Record[2], Type::getInt1Ty(Context)); 2544932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FalseDest == 0 || Cond == 0) 2545d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2546932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = BranchInst::Create(TrueDest, FalseDest, Cond); 2547932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2548932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2549932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2550932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2551932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...] 2552932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || (Record.size() & 1) == 0) 2553d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2554932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 2555932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Cond = getFnValueByID(Record[1], OpTy); 2556932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *Default = getBasicBlock(Record[2]); 2557932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy == 0 || Cond == 0 || Default == 0) 2558d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2559932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumCases = (Record.size()-3)/2; 2560932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); 2561932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(SI); 2562932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = NumCases; i != e; ++i) { 2563932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ConstantInt *CaseVal = 2564932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy)); 2565932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); 2566932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CaseVal == 0 || DestBB == 0) { 2567932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete SI; 2568d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2569932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2570932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SI->addCase(CaseVal, DestBB); 2571932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2572932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = SI; 2573932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2574932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2575932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] 2576932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 2577d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2578932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 2579932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Address = getFnValueByID(Record[1], OpTy); 2580932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy == 0 || Address == 0) 2581d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2582932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumDests = Record.size()-2; 2583932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); 2584932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(IBI); 2585932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = NumDests; i != e; ++i) { 2586932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) { 2587932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IBI->addDestination(DestBB); 2588932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2589932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete IBI; 2590d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2591932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2592932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2593932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = IBI; 2594932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2595932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2596b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2597932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INVOKE: { 2598932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] 2599d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 4) 2600d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2601b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines AttributeSet PAL = getAttributes(Record[0]); 2602932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned CCInfo = Record[1]; 2603932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *NormalBB = getBasicBlock(Record[2]); 2604932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *UnwindBB = getBasicBlock(Record[3]); 2605932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2606932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 4; 2607932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Callee; 2608932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 2609d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2610932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2611932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); 2612932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionType *FTy = !CalleeTy ? 0 : 2613932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast<FunctionType>(CalleeTy->getElementType()); 2614932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2615932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check that the right number of fixed parameters are here. 2616932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FTy == 0 || NormalBB == 0 || UnwindBB == 0 || 2617932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.size() < OpNum+FTy->getNumParams()) 2618d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2619932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2620932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 16> Ops; 2621932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 2622932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Ops.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 2623d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Ops.back() == 0) 2624d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2625932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2626932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2627932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy->isVarArg()) { 2628932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != OpNum) 2629d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2630932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2631932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read type/value pairs for varargs params. 2632932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (OpNum != Record.size()) { 2633932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2634932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2635d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2636932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Ops.push_back(Op); 2637932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2638932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2639932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2640932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops); 2641932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2642932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<InvokeInst>(I)->setCallingConv( 2643932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static_cast<CallingConv::ID>(CCInfo)); 2644932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<InvokeInst>(I)->setAttributes(PAL); 2645932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2646932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2647c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao case FUNC_CODE_INST_UNWIND_2_7: { // UNWIND_OLD 2648c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao // 'unwind' instruction has been removed in LLVM 3.1 2649c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao // Replace 'unwind' with 'landingpad' and 'resume'. 2650c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Type *ExnTy = StructType::get(Type::getInt8PtrTy(Context), 2651c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Type::getInt32Ty(Context), NULL); 2652c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Constant *PersFn = 2653c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao F->getParent()-> 2654c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao getOrInsertFunction("__gcc_personality_v0", 2655c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao FunctionType::get(Type::getInt32Ty(Context), true)); 2656c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 2657c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao LandingPadInst *LP = LandingPadInst::Create(ExnTy, PersFn, 1); 2658c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao LP->setCleanup(true); 2659c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 2660c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao CurBB->getInstList().push_back(LP); 2661c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao I = ResumeInst::Create(LP); 2662932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2663932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2664c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao } 2665932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE 2666932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new UnreachableInst(Context); 2667932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2668932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2669932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...] 2670932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1 || ((Record.size()-1)&1)) 2671d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2672932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 2673d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 2674d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2675932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2676932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2); 2677932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(PN); 2678932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2679932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) { 2680932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = getFnValueByID(Record[1+i], Ty); 2681932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *BB = getBasicBlock(Record[2+i]); 2682d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!V || !BB) 2683d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2684932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PN->addIncoming(V, BB); 2685932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2686932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = PN; 2687932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2688932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2689932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2690932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_MALLOC_2_7: { // MALLOC: [instty, op, align] 2691932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Autoupgrade malloc instruction to malloc call. 2692932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME: Remove in LLVM 3.0. 2693932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) { 2694d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2695932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2696932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *Ty = 2697932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<PointerType>(getTypeByID(Record[0])); 2698932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Size = getFnValueByID(Record[1], Type::getInt32Ty(Context)); 2699d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty || !Size) 2700d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2701d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!CurBB) 2702d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidInstructionWithNoBB); 2703932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Int32Ty = IntegerType::getInt32Ty(CurBB->getContext()); 2704932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *AllocSize = ConstantExpr::getSizeOf(Ty->getElementType()); 2705932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, Int32Ty); 2706932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CallInst::CreateMalloc(CurBB, Int32Ty, Ty->getElementType(), 2707932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AllocSize, Size, NULL); 2708932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2709932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2710932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2711932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_FREE_2_7: { // FREE: [op, opty] 2712932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2713932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2714932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2715932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum != Record.size()) { 2716d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2717932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2718d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!CurBB) 2719d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidInstructionWithNoBB); 2720932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CallInst::CreateFree(Op, CurBB); 2721932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2722932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2723932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2724932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2725932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align] 2726932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // For backward compatibility, tolerate a lack of an opty, and use i32. 2727932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Remove this in LLVM 3.0. 2728932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || Record.size() > 4) { 2729d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2730932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2731932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2732932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *Ty = 2733932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<PointerType>(getTypeByID(Record[OpNum++])); 2734932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = Record.size() == 4 ? getTypeByID(Record[OpNum++]) : 2735932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type::getInt32Ty(Context); 2736932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Size = getFnValueByID(Record[OpNum++], OpTy); 2737932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Align = Record[OpNum++]; 2738d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty || !Size) 2739d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2740932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); 2741932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2742932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2743932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2744932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol] 2745932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2746932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2747932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2748932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) 2749d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2750932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2751932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2752932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2753932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2754932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2755932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_STORE: { // STORE2:[ptrty, ptr, val, align, vol] 2756932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2757932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Val, *Ptr; 2758932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 2759932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, 2760932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<PointerType>(Ptr->getType())->getElementType(), Val) || 2761932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) 2762d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2763932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2764932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2765932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2766932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2767932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2768932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_STORE_2_7: { 2769932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2770932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Val, *Ptr; 2771932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Val) || 2772932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, 2773932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType::getUnqual(Val->getType()), Ptr)|| 2774932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) { 2775d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2776932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2777932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2778932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2779932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2780932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2781932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_CALL_2_7: 2782932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 2783932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CALL: { 2784932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] 2785932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 2786d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2787932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2788b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines AttributeSet PAL = getAttributes(Record[0]); 2789932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned CCInfo = Record[1]; 2790932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2791932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 2; 2792932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Callee; 2793932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 2794d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2795932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2796932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); 2797932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionType *FTy = 0; 2798932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType()); 2799932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy || Record.size() < FTy->getNumParams()+OpNum) 2800d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2801932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2802932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 16> Args; 2803932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read the fixed params. 2804932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 2805932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FTy->getParamType(i)->isLabelTy()) 2806932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Args.push_back(getBasicBlock(Record[OpNum])); 2807932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 2808932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Args.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 2809d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Args.back() == 0) 2810d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2811932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2812932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2813932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read type/value pairs for varargs params. 2814932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy->isVarArg()) { 2815932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpNum != Record.size()) 2816d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2817932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2818932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (OpNum != Record.size()) { 2819932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2820932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2821d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2822932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Args.push_back(Op); 2823932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2824932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2825932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2826932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CallInst::Create(Callee, Args); 2827932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2828932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<CallInst>(I)->setCallingConv( 2829932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static_cast<CallingConv::ID>(CCInfo>>1)); 2830932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<CallInst>(I)->setTailCall(CCInfo & 1); 2831932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<CallInst>(I)->setAttributes(PAL); 2832932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2833932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2834932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] 2835932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 2836d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2837932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 2838932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op = getFnValueByID(Record[1], OpTy); 2839932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ResTy = getTypeByID(Record[2]); 2840932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!OpTy || !Op || !ResTy) 2841d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2842932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new VAArgInst(Op, ResTy); 2843932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2844932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2845932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2846932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2847932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2848932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Add instruction to end of current BB. If there is no current BB, reject 2849932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // this file. 2850932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CurBB == 0) { 2851932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete I; 2852d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidInstructionWithNoBB); 2853932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2854932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurBB->getInstList().push_back(I); 2855932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2856932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this was a terminator instruction, move to the next block. 2857932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (isa<TerminatorInst>(I)) { 2858932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++CurBBNo; 2859932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0; 2860932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2861932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2862932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Non-void values get registered in the value table for future use. 2863932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I && !I->getType()->isVoidTy()) 2864932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.AssignValue(I, NextValueNo++); 2865932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2866932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2867932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check the function list for unresolved values. 2868932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Argument *A = dyn_cast<Argument>(ValueList.back())) { 2869932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (A->getParent() == 0) { 2870932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We found at least one unresolved value. Nuke them all to avoid leaks. 2871932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){ 2872932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((A = dyn_cast<Argument>(ValueList[i])) && A->getParent() == 0) { 2873932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines A->replaceAllUsesWith(UndefValue::get(A->getType())); 2874932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete A; 2875932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2876932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2877d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(NeverResolvedValueFoundInFunction); 2878932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2879932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2880932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2881932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME: Check for unresolved forward-declared metadata references 2882932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // and clean up leaks. 2883932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2884932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // See if anything took the address of blocks in this function. If so, 2885932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // resolve them now. 2886932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DenseMap<Function*, std::vector<BlockAddrRefTy> >::iterator BAFRI = 2887932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BlockAddrFwdRefs.find(F); 2888932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BAFRI != BlockAddrFwdRefs.end()) { 2889932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<BlockAddrRefTy> &RefList = BAFRI->second; 2890932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = RefList.size(); i != e; ++i) { 2891932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned BlockIdx = RefList[i].first; 2892932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BlockIdx >= FunctionBBs.size()) 2893d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 2894b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2895932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalVariable *FwdRef = RefList[i].second; 2896932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx])); 2897932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FwdRef->eraseFromParent(); 2898932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2899b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2900932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BlockAddrFwdRefs.erase(BAFRI); 2901932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2902932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2903932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NewMDValueListSize = MDValueList.size(); 2904932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Trim the value list down to the size it was before we parsed this function. 2905932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.shrinkTo(ModuleValueListSize); 2906932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.shrinkTo(ModuleMDValueListSize); 2907932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2908932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (LLVM2_7MetadataDetected) { 2909932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.resize(NewMDValueListSize); 2910932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2911932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2912932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<BasicBlock*>().swap(FunctionBBs); 2913f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 2914932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2915932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2916932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 2917932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// GVMaterializer implementation 2918932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 2919932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2920932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2921932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::isMaterializable(const GlobalValue *GV) const { 2922932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (const Function *F = dyn_cast<Function>(GV)) { 2923932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return F->isDeclaration() && 2924932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DeferredFunctionInfo.count(const_cast<Function*>(F)); 2925932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2926932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 2927932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2928932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2929f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_code BitcodeReader::Materialize(GlobalValue *GV) { 2930932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *F = dyn_cast<Function>(GV); 2931932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If it's not a function or is already material, ignore the request. 2932d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!F || !F->isMaterializable()) 2933f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 2934932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2935932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F); 2936932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!"); 2937932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2938932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Move the bit stream to the saved position of the deferred function body. 2939932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.JumpToBit(DFII->second); 2940932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2941f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = ParseFunctionBody(F)) 2942d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2943932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2944932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Upgrade any old intrinsic calls in the function. 2945932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(), 2946932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines E = UpgradedIntrinsics.end(); I != E; ++I) { 2947932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I->first != I->second) { 2948932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Value::use_iterator UI = I->first->use_begin(), 2949932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UE = I->first->use_end(); UI != UE; ) { 2950932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 2951932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradeIntrinsicCall(CI, I->second); 2952932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2953932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2954932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2955932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2956f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 2957932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2958932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2959932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::isDematerializable(const GlobalValue *GV) const { 2960932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines const Function *F = dyn_cast<Function>(GV); 2961932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!F || F->isDeclaration()) 2962932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 2963932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return DeferredFunctionInfo.count(const_cast<Function*>(F)); 2964932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2965932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2966932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReader::Dematerialize(GlobalValue *GV) { 2967932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *F = dyn_cast<Function>(GV); 2968932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this function isn't dematerializable, this is a noop. 2969932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!F || !isDematerializable(F)) 2970932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 2971932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2972932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(DeferredFunctionInfo.count(F) && "No info to read function later?"); 2973932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2974932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Just forget the function body, we can remat it later. 2975932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines F->deleteBody(); 2976932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2977932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2978932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2979f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_code BitcodeReader::MaterializeModule(Module *M) { 2980932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(M == TheModule && 2981932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines "Can only Materialize the Module this BitcodeReader is attached to."); 2982932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Iterate over the module, deserializing any functions that are still on 2983932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // disk. 2984932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Module::iterator F = TheModule->begin(), E = TheModule->end(); 2985d724d097437f40a5689464429f948ec41e4a2415Stephen Hines F != E; ++F) { 2986d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (F->isMaterializable()) { 2987f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = Materialize(F)) 2988d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2989d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 2990d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 2991932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2992932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Upgrade any intrinsic calls that slipped through (should not happen!) and 2993932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // delete the old functions to clean up. We can't do this unless the entire 2994932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // module is materialized because there could always be another function body 2995932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // with calls to the old function. 2996932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (std::vector<std::pair<Function*, Function*> >::iterator I = 2997932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) { 2998932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I->first != I->second) { 2999932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Value::use_iterator UI = I->first->use_begin(), 3000932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UE = I->first->use_end(); UI != UE; ) { 3001932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 3002932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradeIntrinsicCall(CI, I->second); 3003932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3004932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!I->first->use_empty()) 3005932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->first->replaceAllUsesWith(I->second); 3006932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->first->eraseFromParent(); 3007932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3008932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3009932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics); 3010932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3011932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check debug info intrinsics. 3012932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CheckDebugInfoIntrinsics(TheModule); 3013932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3014f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 3015932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3016932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3017f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_code BitcodeReader::InitStream() { 3018d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (LazyStreamer) 3019d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return InitLazyStream(); 3020d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return InitStreamFromBuffer(); 3021d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 3022d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3023f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_code BitcodeReader::InitStreamFromBuffer() { 3024d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *BufPtr = (const unsigned char*)Buffer->getBufferStart(); 3025d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); 3026d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3027d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Buffer->getBufferSize() & 3) { 3028d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isRawBitcode(BufPtr, BufEnd) && !isBitcodeWrapper(BufPtr, BufEnd)) 3029d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 3030d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else 3031d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(BitcodeStreamInvalidSize); 3032d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 3033d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3034d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // If we have a wrapper header, parse it and ignore the non-bc file contents. 3035d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The magic number is 0x0B17C0DE stored in little endian. 3036d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (isBitcodeWrapper(BufPtr, BufEnd)) 3037d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true)) 3038d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeWrapperHeader); 3039d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3040d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamFile.reset(new BitstreamReader(BufPtr, BufEnd)); 3041d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.init(*StreamFile); 3042d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3043f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 3044d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 3045d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3046f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesstd::error_code BitcodeReader::InitLazyStream() { 3047d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Check and strip off the bitcode wrapper; BitstreamReader expects never to 3048d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // see it. 3049d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamingMemoryObject *Bytes = new StreamingMemoryObject(LazyStreamer); 3050d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamFile.reset(new BitstreamReader(Bytes)); 3051d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.init(*StreamFile); 3052d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3053d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned char buf[16]; 305488f8c52abea50f411c3774c935a6a1e04d17c182Stephen Hines if (Bytes->readBytes(0, 16, buf) == -1) 3055d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(BitcodeStreamInvalidSize); 3056d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3057d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isBitcode(buf, buf + 16)) 3058d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 3059d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3060d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (isBitcodeWrapper(buf, buf + 4)) { 3061d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *bitcodeStart = buf; 3062d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *bitcodeEnd = buf + 16; 3063d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false); 3064d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Bytes->dropLeadingBytes(bitcodeStart - buf); 3065d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Bytes->setKnownObjectSize(bitcodeEnd - bitcodeStart); 3066d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 3067f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines return std::error_code(); 3068d724d097437f40a5689464429f948ec41e4a2415Stephen Hines} 3069d724d097437f40a5689464429f948ec41e4a2415Stephen Hines 3070d724d097437f40a5689464429f948ec41e4a2415Stephen Hinesnamespace { 30718f5c2a1c1392a6d6bdb5700f73eeadd7b01ea0b7Stephen Hinesclass BitcodeErrorCategoryType : public std::error_category { 30728f5c2a1c1392a6d6bdb5700f73eeadd7b01ea0b7Stephen Hines const char *name() const LLVM_NOEXCEPT override { 3073d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "llvm.bitcode"; 3074d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3075c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray std::string message(int IE) const override { 3076d724d097437f40a5689464429f948ec41e4a2415Stephen Hines BitcodeReader::ErrorType E = static_cast<BitcodeReader::ErrorType>(IE); 3077d724d097437f40a5689464429f948ec41e4a2415Stephen Hines switch (E) { 3078d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::BitcodeStreamInvalidSize: 3079d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Bitcode stream length should be >= 16 bytes and a multiple of 4"; 3080d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::ConflictingMETADATA_KINDRecords: 3081d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Conflicting METADATA_KIND records"; 3082d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::CouldNotFindFunctionInStream: 3083d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Could not find function in stream"; 3084d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::ExpectedConstant: 3085d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Expected a constant"; 3086d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InsufficientFunctionProtos: 3087d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Insufficient function protos"; 3088d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidBitcodeSignature: 3089d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid bitcode signature"; 3090d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidBitcodeWrapperHeader: 3091d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid bitcode wrapper header"; 3092d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidConstantReference: 3093d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid ronstant reference"; 3094d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidID: 3095d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid ID"; 3096d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidInstructionWithNoBB: 3097d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid instruction with no BB"; 3098d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidRecord: 3099d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid record"; 3100d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidTypeForValue: 3101d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid type for value"; 3102d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidTYPETable: 3103d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid TYPE table"; 3104d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidType: 3105d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid type"; 3106d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::MalformedBlock: 3107d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Malformed block"; 3108d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::MalformedGlobalInitializerSet: 3109d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Malformed global initializer set"; 3110d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidMultipleBlocks: 3111d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid multiple blocks"; 3112d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::NeverResolvedValueFoundInFunction: 3113d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Never resolved value found in function"; 3114d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidValue: 3115d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid value"; 3116d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3117d724d097437f40a5689464429f948ec41e4a2415Stephen Hines llvm_unreachable("Unknown error type!"); 3118d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3119d724d097437f40a5689464429f948ec41e4a2415Stephen Hines}; 3120d724d097437f40a5689464429f948ec41e4a2415Stephen Hines} 3121d724d097437f40a5689464429f948ec41e4a2415Stephen Hines 3122f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hinesconst std::error_category &BitcodeReader::BitcodeErrorCategory() { 3123d724d097437f40a5689464429f948ec41e4a2415Stephen Hines static BitcodeErrorCategoryType O; 3124d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return O; 3125d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 3126932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3127932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 3128932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// External interface 3129932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 3130932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3131932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// getLazyBitcodeModule - lazy function-at-a-time loading from a file. 3132932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// 3133932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesModule *llvm_2_7::getLazyBitcodeModule(MemoryBuffer *Buffer, 3134932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVMContext& Context, 3135932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string *ErrMsg) { 3136932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Module *M = new Module(Buffer->getBufferIdentifier(), Context); 3137932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BitcodeReader *R = new BitcodeReader(Buffer, Context); 3138932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines M->setMaterializer(R); 3139f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = R->ParseBitcodeInto(M)) { 3140932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ErrMsg) 3141d724d097437f40a5689464429f948ec41e4a2415Stephen Hines *ErrMsg = EC.message(); 3142932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3143932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete M; // Also deletes R. 3144932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return 0; 3145932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3146932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Have the BitcodeReader dtor delete 'Buffer'. 3147932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines R->setBufferOwned(true); 3148932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return M; 3149932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3150932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3151932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ParseBitcodeFile - Read the specified bitcode file, returning the module. 3152932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// If an error occurs, return null and fill in *ErrMsg if non-null. 3153932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesModule *llvm_2_7::ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext& Context, 3154932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string *ErrMsg){ 3155932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Module *M = llvm_2_7::getLazyBitcodeModule(Buffer, Context, ErrMsg); 3156932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!M) return 0; 3157932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3158932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether 3159932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // there was an error. 3160932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static_cast<BitcodeReader*>(M->getMaterializer())->setBufferOwned(false); 3161932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3162932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read in the entire module, and destroy the BitcodeReader. 3163f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code ec = M->materializeAllPermanently()) { 3164c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray *ErrMsg = ec.message(); 3165932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete M; 3166932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return 0; 3167932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3168932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3169932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return M; 3170932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3171932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3172932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstd::string llvm_2_7::getBitcodeTargetTriple(MemoryBuffer *Buffer, 3173932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVMContext& Context, 3174932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string *ErrMsg) { 3175932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BitcodeReader *R = new BitcodeReader(Buffer, Context); 3176932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Don't let the BitcodeReader dtor delete 'Buffer'. 3177932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines R->setBufferOwned(false); 3178932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3179932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string Triple(""); 3180f21590eae009b4f596d7e448d0b8e142c46fc382Stephen Hines if (std::error_code EC = R->ParseTriple(Triple)) 3181932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ErrMsg) 3182d724d097437f40a5689464429f948ec41e4a2415Stephen Hines *ErrMsg = EC.message(); 3183932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3184932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete R; 3185932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Triple; 3186932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3187