BitcodeReader.cpp revision d9216ebb9c114242b713cd4dad33b3a83eb86761
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" 19b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/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 { 50be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien /// This function strips all debug info intrinsics, except for llvm.dbg.declare. 51be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien /// If an llvm.dbg.declare intrinsic is invalid, then this function simply 52be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien /// strips that use. 53be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien void CheckDebugInfoIntrinsics(Module *M) { 54be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (Function *FuncStart = M->getFunction("llvm.dbg.func.start")) { 55be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien while (!FuncStart->use_empty()) 56be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien cast<CallInst>(FuncStart->use_back())->eraseFromParent(); 57be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien FuncStart->eraseFromParent(); 58be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien } 59b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 60be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (Function *StopPoint = M->getFunction("llvm.dbg.stoppoint")) { 61be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien while (!StopPoint->use_empty()) 62be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien cast<CallInst>(StopPoint->use_back())->eraseFromParent(); 63be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien StopPoint->eraseFromParent(); 64be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien } 65b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 66be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (Function *RegionStart = M->getFunction("llvm.dbg.region.start")) { 67be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien while (!RegionStart->use_empty()) 68be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien cast<CallInst>(RegionStart->use_back())->eraseFromParent(); 69be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien RegionStart->eraseFromParent(); 70be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien } 71b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 72be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (Function *RegionEnd = M->getFunction("llvm.dbg.region.end")) { 73be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien while (!RegionEnd->use_empty()) 74be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien cast<CallInst>(RegionEnd->use_back())->eraseFromParent(); 75be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien RegionEnd->eraseFromParent(); 76be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien } 77b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 78be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (Function *Declare = M->getFunction("llvm.dbg.declare")) { 79be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (!Declare->use_empty()) { 80be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien DbgDeclareInst *DDI = cast<DbgDeclareInst>(Declare->use_back()); 81be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (!isa<MDNode>(DDI->getArgOperand(0)) || 82be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien !isa<MDNode>(DDI->getArgOperand(1))) { 83be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien while (!Declare->use_empty()) { 84be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien CallInst *CI = cast<CallInst>(Declare->use_back()); 85be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien CI->eraseFromParent(); 86be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien } 87be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien Declare->eraseFromParent(); 88be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien } 89be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien } 90be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien } 91be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien } 92be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien} // end anonymous namespace 93be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien 94932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReader::FreeState() { 95932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BufferOwned) 96932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete Buffer; 97932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Buffer = 0; 98932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Type*>().swap(TypeList); 99932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.clear(); 100932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.clear(); 101932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 102b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines std::vector<AttributeSet>().swap(MAttributes); 103932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<BasicBlock*>().swap(FunctionBBs); 104932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Function*>().swap(FunctionsWithBodies); 105932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DeferredFunctionInfo.clear(); 106932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDKindMap.clear(); 107932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 108932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 109932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 110932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// Helper functions to implement forward reference resolution, etc. 111932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 112932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 113932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ConvertToString - Convert a string from a record into an std::string, return 114932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// true on failure. 115932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinestemplate<typename StrTy> 116932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic bool ConvertToString(SmallVector<uint64_t, 64> &Record, unsigned Idx, 117932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StrTy &Result) { 118932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx > Record.size()) 119932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 120932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 121932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = Idx, e = Record.size(); i != e; ++i) 122932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Result += (char)Record[i]; 123932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 124932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 125932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 126932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) { 127932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Val) { 128932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Map unknown/new linkages to external 129932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 0: return GlobalValue::ExternalLinkage; 130932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 1: return GlobalValue::WeakAnyLinkage; 131932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 2: return GlobalValue::AppendingLinkage; 132932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 3: return GlobalValue::InternalLinkage; 133932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 4: return GlobalValue::LinkOnceAnyLinkage; 134932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 5: return GlobalValue::DLLImportLinkage; 135932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 6: return GlobalValue::DLLExportLinkage; 136932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 7: return GlobalValue::ExternalWeakLinkage; 137932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 8: return GlobalValue::CommonLinkage; 138932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 9: return GlobalValue::PrivateLinkage; 139932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 10: return GlobalValue::WeakODRLinkage; 140932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 11: return GlobalValue::LinkOnceODRLinkage; 141932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 12: return GlobalValue::AvailableExternallyLinkage; 142932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 13: return GlobalValue::LinkerPrivateLinkage; 143932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 14: return GlobalValue::LinkerPrivateWeakLinkage; 144dd9c0baa7efb4b31dc2360c78759ece6ca81073fStephen Hines case 15: return GlobalValue::LinkOnceODRAutoHideLinkage; 145932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 146932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 147932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 148932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) { 149932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Val) { 150932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Map unknown visibilities to default. 151932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 0: return GlobalValue::DefaultVisibility; 152932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 1: return GlobalValue::HiddenVisibility; 153932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 2: return GlobalValue::ProtectedVisibility; 154932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 155932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 156932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1578b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liaostatic GlobalVariable::ThreadLocalMode GetDecodedThreadLocalMode(unsigned Val) { 1588b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao switch (Val) { 1598b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 0: return GlobalVariable::NotThreadLocal; 1608b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao default: // Map unknown non-zero value to general dynamic. 1618b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 1: return GlobalVariable::GeneralDynamicTLSModel; 1628b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 2: return GlobalVariable::LocalDynamicTLSModel; 1638b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 3: return GlobalVariable::InitialExecTLSModel; 1648b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 4: return GlobalVariable::LocalExecTLSModel; 1658b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao } 1668b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao} 1678b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao 168932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic int GetDecodedCastOpcode(unsigned Val) { 169932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Val) { 170932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: return -1; 171932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_TRUNC : return Instruction::Trunc; 172932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_ZEXT : return Instruction::ZExt; 173932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_SEXT : return Instruction::SExt; 174932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPTOUI : return Instruction::FPToUI; 175932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPTOSI : return Instruction::FPToSI; 176932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_UITOFP : return Instruction::UIToFP; 177932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_SITOFP : return Instruction::SIToFP; 178932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPTRUNC : return Instruction::FPTrunc; 179932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPEXT : return Instruction::FPExt; 180932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_PTRTOINT: return Instruction::PtrToInt; 181932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_INTTOPTR: return Instruction::IntToPtr; 182932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_BITCAST : return Instruction::BitCast; 183932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 184932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 185932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic int GetDecodedBinaryOpcode(unsigned Val, Type *Ty) { 186932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Val) { 187932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: return -1; 188932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_ADD: 189932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FAdd : Instruction::Add; 190932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SUB: 191932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FSub : Instruction::Sub; 192932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_MUL: 193932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FMul : Instruction::Mul; 194932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_UDIV: return Instruction::UDiv; 195932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SDIV: 196932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FDiv : Instruction::SDiv; 197932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_UREM: return Instruction::URem; 198932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SREM: 199932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FRem : Instruction::SRem; 200932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SHL: return Instruction::Shl; 201932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_LSHR: return Instruction::LShr; 202932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_ASHR: return Instruction::AShr; 203932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_AND: return Instruction::And; 204932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_OR: return Instruction::Or; 205932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_XOR: return Instruction::Xor; 206932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 207932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 208932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 209932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesnamespace llvm { 210932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesnamespace { 211932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// @brief A class for maintaining the slot number definition 212932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// as a placeholder for the actual definition for forward constants defs. 213932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines class ConstantPlaceHolder : public ConstantExpr { 214932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines void operator=(const ConstantPlaceHolder &); // DO NOT IMPLEMENT 215932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines public: 216932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // allocate space for exactly one operand 217932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines void *operator new(size_t s) { 218932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return User::operator new(s, 1); 219932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 220932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines explicit ConstantPlaceHolder(Type *Ty, LLVMContext& Context) 221932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) { 222932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Op<0>() = UndefValue::get(Type::getInt32Ty(Context)); 223932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 224932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 225932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// @brief Methods to support type inquiry through isa, cast, and dyn_cast. 226932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines //static inline bool classof(const ConstantPlaceHolder *) { return true; } 227932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static bool classof(const Value *V) { 228932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return isa<ConstantExpr>(V) && 229932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1; 230932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 231932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 232932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 233932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// Provide fast operand accessors 234932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines //DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 235932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines }; 236932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 237932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 238932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// FIXME: can we inherit this from ConstantExpr? 239932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinestemplate <> 240932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstruct OperandTraits<ConstantPlaceHolder> : 241932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines public FixedNumOperandTraits<ConstantPlaceHolder, 1> { 242932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines}; 243932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 244932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 245932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 246932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) { 247932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx == size()) { 248932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines push_back(V); 249932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 250932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 251932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 252932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 253932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx+1); 254932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 255932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines WeakVH &OldV = ValuePtrs[Idx]; 256932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OldV == 0) { 257932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV = V; 258932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 259932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 260932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 261932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Handle constants and non-constants (e.g. instrs) differently for 262932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // efficiency. 263932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Constant *PHC = dyn_cast<Constant>(&*OldV)) { 264932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveConstants.push_back(std::make_pair(PHC, Idx)); 265932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV = V; 266932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 267932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If there was a forward reference to this value, replace it. 268932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *PrevVal = OldV; 269932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV->replaceAllUsesWith(V); 270932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete PrevVal; 271932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 272932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 273932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 274932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 275932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesConstant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, 276932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty) { 277932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 278932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx + 1); 279932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 280932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Value *V = ValuePtrs[Idx]) { 281932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(Ty == V->getType() && "Type mismatch in constant table!"); 282932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return cast<Constant>(V); 283932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 284932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 285932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create and return a placeholder, which will later be RAUW'd. 286932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *C = new ConstantPlaceHolder(Ty, Context); 287932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValuePtrs[Idx] = C; 288932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return C; 289932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 290932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 291932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesValue *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty) { 292932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 293932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx + 1); 294932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 295932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Value *V = ValuePtrs[Idx]) { 296932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!"); 297932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V; 298932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 299932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 300932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No type specified, must be invalid reference. 301932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Ty == 0) return 0; 302932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 303932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create and return a placeholder, which will later be RAUW'd. 304932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = new Argument(Ty); 305932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValuePtrs[Idx] = V; 306932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V; 307932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 308932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 309932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ResolveConstantForwardRefs - Once all constants are read, this method bulk 310932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// resolves any forward references. The idea behind this is that we sometimes 311932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// get constants (such as large arrays) which reference *many* forward ref 312932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// constants. Replacing each of these causes a lot of thrashing when 313932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// building/reuniquing the constant. Instead of doing this, we look at all the 314932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// uses and rewrite all the place holders at once for any constant that uses 315932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// a placeholder. 316932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReaderValueList::ResolveConstantForwardRefs() { 317932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Sort the values by-pointer so that they are efficient to look up with a 318932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // binary search. 319932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::sort(ResolveConstants.begin(), ResolveConstants.end()); 320932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 321932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Constant*, 64> NewOps; 322932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 323932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!ResolveConstants.empty()) { 324932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *RealVal = operator[](ResolveConstants.back().second); 325932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Placeholder = ResolveConstants.back().first; 326932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveConstants.pop_back(); 327932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 328932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Loop over all users of the placeholder, updating them to reference the 329932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // new value. If they reference more than one placeholder, update them all 330932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // at once. 331932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!Placeholder->use_empty()) { 332932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value::use_iterator UI = Placeholder->use_begin(); 333932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines User *U = *UI; 334932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 335932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If the using object isn't uniqued, just update the operands. This 336932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // handles instructions and initializers for global variables. 337932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!isa<Constant>(U) || isa<GlobalValue>(U)) { 338932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UI.getUse().set(RealVal); 339932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 340932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 341932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 342932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Otherwise, we have a constant that uses the placeholder. Replace that 343932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // constant with a new constant that has *all* placeholder uses updated. 344932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *UserC = cast<Constant>(U); 345932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (User::op_iterator I = UserC->op_begin(), E = UserC->op_end(); 346932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I != E; ++I) { 347932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *NewOp; 348932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!isa<ConstantPlaceHolder>(*I)) { 349932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Not a placeholder reference. 350932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOp = *I; 351932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (*I == Placeholder) { 352932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Common case is that it just references this one placeholder. 353932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOp = RealVal; 354932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 355932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Otherwise, look up the placeholder in ResolveConstants. 356932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveConstantsTy::iterator It = 357932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::lower_bound(ResolveConstants.begin(), ResolveConstants.end(), 358932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::pair<Constant*, unsigned>(cast<Constant>(*I), 359932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 0)); 360932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(It != ResolveConstants.end() && It->first == *I); 361932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOp = operator[](It->second); 362932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 363932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 364932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOps.push_back(cast<Constant>(NewOp)); 365932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 366932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 367932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Make the new constant. 368932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *NewC; 369932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) { 370932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = ConstantArray::get(UserCA->getType(), NewOps); 371932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) { 372932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = ConstantStruct::get(UserCS->getType(), NewOps); 373932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (isa<ConstantVector>(UserC)) { 374932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = ConstantVector::get(NewOps); 375932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 376932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr."); 377932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = cast<ConstantExpr>(UserC)->getWithOperands(NewOps); 378932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 379932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 380932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UserC->replaceAllUsesWith(NewC); 381932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UserC->destroyConstant(); 382932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOps.clear(); 383932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 384932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 385932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Update all ValueHandles, they should be the only users at this point. 386932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Placeholder->replaceAllUsesWith(RealVal); 387932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete Placeholder; 388932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 389932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 390932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 391932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReaderMDValueList::AssignValue(Value *V, unsigned Idx) { 392932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx == size()) { 393932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines push_back(V); 394932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 395932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 396932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 397932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 398932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx+1); 399932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 400932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines WeakVH &OldV = MDValuePtrs[Idx]; 401932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OldV == 0) { 402932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV = V; 403932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 404932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 405932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 406932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If there was a forward reference to this value, replace it. 407932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDNode *PrevVal = cast<MDNode>(OldV); 408932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV->replaceAllUsesWith(V); 409932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDNode::deleteTemporary(PrevVal); 410932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Deleting PrevVal sets Idx value in MDValuePtrs to null. Set new 411932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // value for Idx. 412932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValuePtrs[Idx] = V; 413932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 414932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 415932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesValue *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { 416932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 417932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx + 1); 418932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 419932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Value *V = MDValuePtrs[Idx]) { 420932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(V->getType()->isMetadataTy() && "Type mismatch in value table!"); 421932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V; 422932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 423932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 424932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create and return a placeholder, which will later be RAUW'd. 425932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = MDNode::getTemporary(Context, ArrayRef<Value*>()); 426932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValuePtrs[Idx] = V; 427932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V; 428932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 429932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 430932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesType *BitcodeReader::getTypeByID(unsigned ID) { 431932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // The type table size is always specified correctly. 432932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ID >= TypeList.size()) 433932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return 0; 434b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 435932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *Ty = TypeList[ID]) 436932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty; 437932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 438932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we have a forward reference, the only possible case is when it is to a 439932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // named struct. Just create a placeholder for now. 440b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines return TypeList[ID] = StructType::create(Context); 441932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 442932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 443932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// FIXME: Remove in LLVM 3.1, only used by ParseOldTypeTable. 444932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesType *BitcodeReader::getTypeByIDOrNull(unsigned ID) { 445932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ID >= TypeList.size()) 446932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList.resize(ID+1); 447b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 448932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return TypeList[ID]; 449932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 450932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 451932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 452932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 453932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// Functions for parsing blocks from the bitcode file 454932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 455932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 456d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 457d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// \brief This fills an AttrBuilder object with the LLVM attributes that have 458d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// been decoded from the given integer. This function must stay in sync with 459d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// 'encodeLLVMAttributesForBitcode'. 460d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesstatic void decodeLLVMAttributesForBitcode(AttrBuilder &B, 461d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines uint64_t EncodedAttrs) { 462d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // FIXME: Remove in 4.0. 463d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 464d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The alignment is stored as a 16-bit raw value from bits 31--16. We shift 465d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // the bits above 31 down by 11 bits. 466d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16; 467d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines assert((!Alignment || isPowerOf2_32(Alignment)) && 468d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines "Alignment must be a power of two."); 469d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 470d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Alignment) 471d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines B.addAlignmentAttr(Alignment); 472d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines B.addRawValue(((EncodedAttrs & (0xfffffULL << 32)) >> 11) | 473d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines (EncodedAttrs & 0xffff)); 474d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 475d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 476932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseAttributeBlock() { 477932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) 478932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 479932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 480932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!MAttributes.empty()) 481932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Multiple PARAMATTR blocks found!"); 482932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 483932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 484932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 485d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SmallVector<AttributeSet, 8> Attrs; 486932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 487932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records. 488932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 489d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 490932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 491d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 492d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 493d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 494d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return Error("Error at end of PARAMATTR block"); 495d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 496d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return false; 497d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 498d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 499d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 500932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 501932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 502932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 503932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 504d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 505932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: ignore. 506932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 507d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::PARAMATTR_CODE_ENTRY_OLD: { // ENTRY: [paramidx0, attr0, ...] 508932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() & 1) 509932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid ENTRY record"); 510932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 511b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 512d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines AttrBuilder B; 513d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines decodeLLVMAttributesForBitcode(B, Record[i+1]); 514d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.push_back(AttributeSet::get(Context, Record[i], B)); 515932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 516932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 517d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines MAttributes.push_back(AttributeSet::get(Context, Attrs)); 518d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.clear(); 519d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 520d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 521d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [attrgrp0, attrgrp1, ...] 522d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (unsigned i = 0, e = Record.size(); i != e; ++i) 523d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.push_back(MAttributeGroups[Record[i]]); 524932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 525b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines MAttributes.push_back(AttributeSet::get(Context, Attrs)); 526932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Attrs.clear(); 527932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 528932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 529932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 530932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 531932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 532932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 533d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 534932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseTypeTable() { 535932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW)) 536932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 537b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 538932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return ParseTypeTableBody(); 539932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 540932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 541932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseTypeTableBody() { 542932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!TypeList.empty()) 543932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Multiple TYPE_BLOCKs found!"); 544932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 545932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 546932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumRecords = 0; 547932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 548932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<64> TypeName; 549b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 550932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this type table. 551932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 552d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 553d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 554d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 555d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 556d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 557d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Error("Error in the type table block"); 558d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return true; 559d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 560932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords != TypeList.size()) 561932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid type forward reference in TYPE_BLOCK"); 562932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 563d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 564d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 565d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 566932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 567932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 568932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 569932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 570932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ResultTy = 0; 571d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 572932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: return Error("unknown type in type table"); 573932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 574932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // TYPE_CODE_NUMENTRY contains a count of the number of types in the 575932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // type list. This allows us to reserve space. 576932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 577932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid TYPE_CODE_NUMENTRY record"); 578932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList.resize(Record[0]); 579932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 580932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VOID: // VOID 581932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getVoidTy(Context); 582932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 583d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::TYPE_CODE_HALF: // HALF 584d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ResultTy = Type::getHalfTy(Context); 585d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 586932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FLOAT: // FLOAT 587932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFloatTy(Context); 588932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 589932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_DOUBLE: // DOUBLE 590932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getDoubleTy(Context); 591932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 592932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_FP80: // X86_FP80 593932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_FP80Ty(Context); 594932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 595932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FP128: // FP128 596932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFP128Ty(Context); 597932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 598932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 599932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getPPC_FP128Ty(Context); 600932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 601932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_LABEL: // LABEL 602932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getLabelTy(Context); 603932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 604932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_METADATA: // METADATA 605932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getMetadataTy(Context); 606932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 607932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_MMX: // X86_MMX 608932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_MMXTy(Context); 609932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 610932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 611932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 612932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid Integer type record"); 613932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 614932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = IntegerType::get(Context, Record[0]); 615932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 616932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 617932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // [pointee type, address space] 618932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 619932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid POINTER type record"); 620932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AddressSpace = 0; 621932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() == 2) 622932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AddressSpace = Record[1]; 623932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = getTypeByID(Record[0]); 624932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ResultTy == 0) return Error("invalid element type in pointer type"); 625932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = PointerType::get(ResultTy, AddressSpace); 626932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 627932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 6283e88bf7dfe2af63827099a7d5be0173cf4c74f4dStephen Hines case bitc::TYPE_CODE_FUNCTION_OLD: { 629b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // FIXME: attrid is dead, remove it in LLVM 4.0 630932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FUNCTION: [vararg, attrid, retty, paramty x N] 631932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 632932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid FUNCTION type record"); 633b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Type*, 8> ArgTys; 634932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 3, e = Record.size(); i != e; ++i) { 635932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *T = getTypeByID(Record[i])) 636932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArgTys.push_back(T); 637932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 638932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 639932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 640b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 641932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = getTypeByID(Record[2]); 642932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ResultTy == 0 || ArgTys.size() < Record.size()-3) 643932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("invalid type in function type"); 644932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 645932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 646932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 647932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 648932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N] 649932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 650932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid STRUCT type record"); 651b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Type*, 8> EltTys; 652932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1, e = Record.size(); i != e; ++i) { 653932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *T = getTypeByID(Record[i])) 654932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EltTys.push_back(T); 655932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 656932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 657932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 658932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (EltTys.size() != Record.size()-1) 659932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("invalid type in struct type"); 660932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = StructType::get(Context, EltTys, Record[0]); 661932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 662932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 663932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N] 664932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, TypeName)) 665932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid STRUCT_NAME record"); 666932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 667932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 668932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N] 669932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 670932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid STRUCT type record"); 671b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 672932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords >= TypeList.size()) 673932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("invalid TYPE table"); 674b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 675932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check to see if this was forward referenced, if so fill in the temp. 676932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 677932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Res) { 678932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Res->setName(TypeName); 679932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NumRecords] = 0; 680932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else // Otherwise, create a new struct. 681bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien Res = StructType::create(Context, TypeName); 682932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeName.clear(); 683b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 684932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Type*, 8> EltTys; 685932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1, e = Record.size(); i != e; ++i) { 686932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *T = getTypeByID(Record[i])) 687932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EltTys.push_back(T); 688932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 689932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 690932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 691932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (EltTys.size() != Record.size()-1) 692932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("invalid STRUCT type record"); 693932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Res->setBody(EltTys, Record[0]); 694932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Res; 695932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 696932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 697932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: [] 698932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != 1) 699932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid OPAQUE type record"); 700932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 701932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords >= TypeList.size()) 702932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("invalid TYPE table"); 703b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 704932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check to see if this was forward referenced, if so fill in the temp. 705932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 706932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Res) { 707932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Res->setName(TypeName); 708932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NumRecords] = 0; 709932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else // Otherwise, create a new struct with no body. 710bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien Res = StructType::create(Context, TypeName); 711932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeName.clear(); 712932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Res; 713932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 714b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines } 715932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 716932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 717932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid ARRAY type record"); 718932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByID(Record[1]))) 719932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = ArrayType::get(ResultTy, Record[0]); 720932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 721932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid ARRAY type element"); 722932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 723932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 724932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 725932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid VECTOR type record"); 726932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByID(Record[1]))) 727932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = VectorType::get(ResultTy, Record[0]); 728932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 729932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid ARRAY type element"); 730932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 731932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 732932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 733932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords >= TypeList.size()) 734932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("invalid TYPE table"); 735932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(ResultTy && "Didn't read a type?"); 736932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(TypeList[NumRecords] == 0 && "Already read type?"); 737932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NumRecords++] = ResultTy; 738932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 739932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 740932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 741932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// FIXME: Remove in LLVM 3.1 742932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseOldTypeTable() { 743be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (Stream.EnterSubBlock(TYPE_BLOCK_ID_OLD_3_0)) 744932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 745932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 746932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!TypeList.empty()) 747932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Multiple TYPE_BLOCKs found!"); 748b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 749b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 750932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // While horrible, we have no good ordering of types in the bc file. Just 751932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // iteratively parse types out of the bc file in multiple passes until we get 752932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // them all. Do this by saving a cursor for the start of the type block. 753932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BitstreamCursor StartOfTypeBlockCursor(Stream); 754b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 755932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumTypesRead = 0; 756b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 757932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 758932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesRestartScan: 759932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextTypeID = 0; 760932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool ReadAnyTypes = false; 761b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 762932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this type table. 763932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 764932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 765932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 766932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID != TypeList.size()) 767932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid type forward reference in TYPE_BLOCK_ID_OLD"); 768b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 769932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we haven't read all of the types yet, iterate again. 770932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumTypesRead != TypeList.size()) { 771932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we didn't successfully read any types in this pass, then we must 772932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // have an unhandled forward reference. 773932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!ReadAnyTypes) 774932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Obsolete bitcode contains unhandled recursive type"); 775b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 776932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream = StartOfTypeBlockCursor; 777932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines goto RestartScan; 778932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 779b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 780932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 781932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Error at end of type table block"); 782932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 783932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 784b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 785932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 786932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 787932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 788932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 789932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 790932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 791932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 792b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 793932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 794932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 795932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 796932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 797b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 798932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 799932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 800932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ResultTy = 0; 801d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 802932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: return Error("unknown type in type table"); 803932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 804932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // TYPE_CODE_NUMENTRY contains a count of the number of types in the 805932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // type list. This allows us to reserve space. 806932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 807932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid TYPE_CODE_NUMENTRY record"); 808932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList.resize(Record[0]); 809932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 810932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VOID: // VOID 811932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getVoidTy(Context); 812932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 813932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FLOAT: // FLOAT 814932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFloatTy(Context); 815932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 816932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_DOUBLE: // DOUBLE 817932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getDoubleTy(Context); 818932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 819932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_FP80: // X86_FP80 820932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_FP80Ty(Context); 821932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 822932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FP128: // FP128 823932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFP128Ty(Context); 824932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 825932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 826932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getPPC_FP128Ty(Context); 827932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 828932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_LABEL: // LABEL 829932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getLabelTy(Context); 830932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 831932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_METADATA: // METADATA 832932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getMetadataTy(Context); 833932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 834932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_MMX: // X86_MMX 835932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_MMXTy(Context); 836932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 837932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 838932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 839932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid Integer type record"); 840932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = IntegerType::get(Context, Record[0]); 841932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 842932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_OPAQUE: // OPAQUE 843932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID < TypeList.size() && TypeList[NextTypeID] == 0) 844bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien ResultTy = StructType::create(Context, ""); 845932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 846be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien case TYPE_CODE_STRUCT_OLD_3_0: {// STRUCT_OLD 847932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID >= TypeList.size()) break; 848932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we already read it, don't reprocess. 849932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TypeList[NextTypeID] && 850932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines !cast<StructType>(TypeList[NextTypeID])->isOpaque()) 851932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 852932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 853932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Set a type. 854932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TypeList[NextTypeID] == 0) 855bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien TypeList[NextTypeID] = StructType::create(Context, ""); 856932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 857932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Type*> EltTys; 858932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1, e = Record.size(); i != e; ++i) { 859932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *Elt = getTypeByIDOrNull(Record[i])) 860932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EltTys.push_back(Elt); 861932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 862932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 863932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 864932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 865932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (EltTys.size() != Record.size()-1) 866932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; // Not all elements are ready. 867b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 868932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<StructType>(TypeList[NextTypeID])->setBody(EltTys, Record[0]); 869932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = TypeList[NextTypeID]; 870932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NextTypeID] = 0; 871932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 872932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 873932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 874932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // [pointee type, address space] 875932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 876932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid POINTER type record"); 877932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AddressSpace = 0; 878932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() == 2) 879932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AddressSpace = Record[1]; 880932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[0]))) 881932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = PointerType::get(ResultTy, AddressSpace); 882932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 883932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 8843e88bf7dfe2af63827099a7d5be0173cf4c74f4dStephen Hines case bitc::TYPE_CODE_FUNCTION_OLD: { 885932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME: attrid is dead, remove it in LLVM 3.0 886932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FUNCTION: [vararg, attrid, retty, paramty x N] 887932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 888932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid FUNCTION type record"); 889932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Type*> ArgTys; 890932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 3, e = Record.size(); i != e; ++i) { 891932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *Elt = getTypeByIDOrNull(Record[i])) 892932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArgTys.push_back(Elt); 893932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 894932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 895932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 896932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ArgTys.size()+3 != Record.size()) 897932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; // Something was null. 898932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[2]))) 899932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 900932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 901932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 902932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 903932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 904932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid ARRAY type record"); 905932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[1]))) 906932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = ArrayType::get(ResultTy, Record[0]); 907932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 908932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 909932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 910932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid VECTOR type record"); 911932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[1]))) 912932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = VectorType::get(ResultTy, Record[0]); 913932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 914932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 915b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 916932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID >= TypeList.size()) 917932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("invalid TYPE table"); 918b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 919932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ResultTy && TypeList[NextTypeID] == 0) { 920932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++NumTypesRead; 921932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ReadAnyTypes = true; 922b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 923932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NextTypeID] = ResultTy; 924932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 925b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 926932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++NextTypeID; 927932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 928932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 929932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 930932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 931932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseOldTypeSymbolTable() { 932be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (Stream.EnterSubBlock(TYPE_SYMTAB_BLOCK_ID_OLD_3_0)) 933932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 934932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 935932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 936932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 937932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this type table. 938932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string TypeName; 939932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 940932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 941932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 942932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 943932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Error at end of type symbol table block"); 944932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 945932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 946932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 947932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 948932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 949932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 950932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 951932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 952932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 953932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 954932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 955932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 956932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 957932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 958932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 959932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 960932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 961932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 962d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 963932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: unknown type. 964932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 965932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TST_CODE_ENTRY: // TST_ENTRY: [typeid, namechar x N] 966932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 1, TypeName)) 967932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid TST_ENTRY record"); 968932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned TypeID = Record[0]; 969932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TypeID >= TypeList.size()) 970932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid Type ID in TST_ENTRY record"); 971932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 972932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Only apply the type name to a struct type with no name. 973932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (StructType *STy = dyn_cast<StructType>(TypeList[TypeID])) 974bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien if (!STy->isLiteral() && !STy->hasName()) 975932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines STy->setName(TypeName); 976932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeName.clear(); 977932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 978932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 979932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 980932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 981932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 982932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseValueSymbolTable() { 983932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) 984932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 985932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 986932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 987932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 988932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this value table. 989932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<128> ValueName; 990932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 991932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 992932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 993932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 994932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Error at end of value symbol table block"); 995932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 996932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 997932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 998932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 999932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 1000932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1001932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 1002932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1003932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1004932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1005932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 1006932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 1007932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1008932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1009932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1010932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1011932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1012d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 1013932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: unknown type. 1014932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1015932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N] 1016932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 1, ValueName)) 1017932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid VST_ENTRY record"); 1018932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ValueID = Record[0]; 1019932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ValueID >= ValueList.size()) 1020932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid Value ID in VST_ENTRY record"); 1021932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = ValueList[ValueID]; 1022932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1023932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V->setName(StringRef(ValueName.data(), ValueName.size())); 1024932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueName.clear(); 1025932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1026932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1027932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VST_CODE_BBENTRY: { 1028932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 1, ValueName)) 1029932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid VST_BBENTRY record"); 1030932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *BB = getBasicBlock(Record[0]); 1031932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BB == 0) 1032932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid BB ID in VST_BBENTRY record"); 1033932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1034932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BB->setName(StringRef(ValueName.data(), ValueName.size())); 1035932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueName.clear(); 1036932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1037932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1038932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1039932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1040932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1041932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1042932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseMetadata() { 1043932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextMDValueNo = MDValueList.size(); 1044932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1045932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) 1046932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 1047932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1048932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1049932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1050932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records. 1051932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 1052932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 1053932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 1054932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 1055932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Error at end of PARAMATTR block"); 1056932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 1057932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1058932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1059932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 1060932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 1061932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 1062932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1063932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 1064932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1065932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1066932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1067932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 1068932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 1069932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1070932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1071932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1072932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool IsFunctionLocal = false; 1073932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1074932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1075d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Code = Stream.readRecord(Code, Record); 1076932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Code) { 1077932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: ignore. 1078932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1079932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_NAME: { 1080932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read named of the named metadata. 1081932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NameLength = Record.size(); 1082932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<8> Name; 1083932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Name.resize(NameLength); 1084932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != NameLength; ++i) 1085932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Name[i] = Record[i]; 1086932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1087932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Code = Stream.ReadCode(); 1088932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1089932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // METADATA_NAME is always followed by METADATA_NAMED_NODE. 1090d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned NextBitCode = Stream.readRecord(Code, Record); 1091932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextBitCode == METADATA_NAMED_NODE_2_7) { 1092932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 1093932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (NextBitCode != bitc::METADATA_NAMED_NODE) { 1094932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(!"Invalid Named Metadata record."); (void)NextBitCode; 1095932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1096932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1097932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read named metadata elements. 1098932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1099932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NamedMDNode *NMD = TheModule->getOrInsertNamedMetadata(Name); 1100932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) { 1101932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDNode *MD = dyn_cast<MDNode>(MDValueList.getValueFwdRef(Record[i])); 1102932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (MD == 0) 1103932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed metadata record"); 1104932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NMD->addOperand(MD); 1105932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1106932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1107932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (LLVM2_7MetadataDetected) { 1108932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.AssignValue(0, NextMDValueNo++); 1109932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1110932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1111932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1112932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case METADATA_FN_NODE_2_7: 1113932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_FN_NODE: 1114932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IsFunctionLocal = true; 1115932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // fall-through 1116932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case METADATA_NODE_2_7: 1117932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_NODE: { 1118932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == METADATA_FN_NODE_2_7 || 1119932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Code == METADATA_NODE_2_7) { 1120932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 1121932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1122932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1123932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() % 2 == 1) 1124932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid METADATA_NODE record"); 1125932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1126932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1127932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 8> Elts; 1128932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; i += 2) { 1129932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[i]); 1130932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty) return Error("Invalid METADATA_NODE record"); 1131932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Ty->isMetadataTy()) 1132932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); 1133932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (!Ty->isVoidTy()) 1134932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty)); 1135932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1136932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(NULL); 1137932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1138932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = MDNode::getWhenValsUnresolved(Context, Elts, IsFunctionLocal); 1139932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IsFunctionLocal = false; 1140932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.AssignValue(V, NextMDValueNo++); 1141932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1142932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1143932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_STRING: { 1144932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned MDStringLength = Record.size(); 1145932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<8> String; 1146932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines String.resize(MDStringLength); 1147932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != MDStringLength; ++i) 1148932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines String[i] = Record[i]; 1149932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = MDString::get(Context, 1150932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StringRef(String.data(), String.size())); 1151932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.AssignValue(V, NextMDValueNo++); 1152932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1153932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1154932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_KIND: { 1155932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned RecordLength = Record.size(); 1156932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty() || RecordLength < 2) 1157932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid METADATA_KIND record"); 1158932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<8> Name; 1159932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Name.resize(RecordLength-1); 1160932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Kind = Record[0]; 1161932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1; i != RecordLength; ++i) 1162932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Name[i-1] = Record[i]; 1163b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1164932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NewKind = TheModule->getMDKindID(Name.str()); 1165932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) 1166932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Conflicting METADATA_KIND records"); 1167932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1168932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1169932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1170932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1171932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1172932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1173d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// decodeSignRotatedValue - Decode a signed value stored with the sign bit in 1174932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// the LSB for dense VBR encoding. 1175d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesuint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) { 1176932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((V & 1) == 0) 1177932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V >> 1; 1178932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (V != 1) 1179932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return -(V >> 1); 1180932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // There is no such thing as -0 with integers. "-0" really means MININT. 1181932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return 1ULL << 63; 1182932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1183932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1184932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ResolveGlobalAndAliasInits - Resolve all of the initializers for global 1185932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// values and aliases that we can. 1186932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ResolveGlobalAndAliasInits() { 1187932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist; 1188932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist; 1189932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1190932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInitWorklist.swap(GlobalInits); 1191932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInitWorklist.swap(AliasInits); 1192932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1193932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!GlobalInitWorklist.empty()) { 1194932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ValID = GlobalInitWorklist.back().second; 1195932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ValID >= ValueList.size()) { 1196932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Not ready to resolve this yet, it requires something later in the file. 1197932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInits.push_back(GlobalInitWorklist.back()); 1198932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1199932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 1200932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInitWorklist.back().first->setInitializer(C); 1201932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1202932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Global variable initializer is not a constant!"); 1203932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1204932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInitWorklist.pop_back(); 1205932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1206932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1207932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!AliasInitWorklist.empty()) { 1208932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ValID = AliasInitWorklist.back().second; 1209932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ValID >= ValueList.size()) { 1210932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInits.push_back(AliasInitWorklist.back()); 1211932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1212932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 1213932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInitWorklist.back().first->setAliasee(C); 1214932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1215932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Alias initializer is not a constant!"); 1216932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1217932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInitWorklist.pop_back(); 1218932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1219932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 1220932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1221932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1222d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesstatic APInt ReadWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) { 1223d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SmallVector<uint64_t, 8> Words(Vals.size()); 1224d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::transform(Vals.begin(), Vals.end(), Words.begin(), 1225d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitcodeReader::decodeSignRotatedValue); 1226d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1227d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return APInt(TypeBits, Words); 1228d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 1229d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1230932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseConstants() { 1231932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) 1232932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 1233932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1234932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1235932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1236932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this value table. 1237932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *CurTy = Type::getInt32Ty(Context); 1238932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextCstNo = ValueList.size(); 1239932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 1240d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 1241d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1242d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 1243d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 1244d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 1245d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return Error("malformed block record in AST file"); 1246d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 1247d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (NextCstNo != ValueList.size()) 1248d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return Error("Invalid constant reference!"); 1249d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1250d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Once all the constants have been read, go through and resolve forward 1251d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // references. 1252d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ValueList.ResolveConstantForwardRefs(); 1253d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return false; 1254d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 1255d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 1256932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1257932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1258932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1259932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1260932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1261932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = 0; 1262d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned BitCode = Stream.readRecord(Entry.ID, Record); 1263932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (BitCode) { 1264932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: unknown constant 1265932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_UNDEF: // UNDEF 1266932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); 1267932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1268932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] 1269932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1270932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed CST_SETTYPE record"); 1271932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[0] >= TypeList.size()) 1272932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid Type ID in CST_SETTYPE record"); 1273932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurTy = TypeList[Record[0]]; 1274932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; // Skip the ValueList manipulation. 1275932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_NULL: // NULL 1276932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = Constant::getNullValue(CurTy); 1277932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1278932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_INTEGER: // INTEGER: [intval] 1279932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!CurTy->isIntegerTy() || Record.empty()) 1280932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CST_INTEGER record"); 1281d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0])); 1282932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1283932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval] 1284932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!CurTy->isIntegerTy() || Record.empty()) 1285932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid WIDE_INTEGER record"); 1286932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1287d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt VInt = ReadWideAPInt(Record, 1288d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines cast<IntegerType>(CurTy)->getBitWidth()); 1289d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantInt::get(Context, VInt); 1290d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1291932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1292932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1293932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] 1294932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1295932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid FLOAT record"); 1296d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (CurTy->isHalfTy()) 1297d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf, 1298d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(16, (uint16_t)Record[0]))); 1299d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else if (CurTy->isFloatTy()) 1300d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEsingle, 1301d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(32, (uint32_t)Record[0]))); 1302932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurTy->isDoubleTy()) 1303d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEdouble, 1304d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(64, Record[0]))); 1305932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurTy->isX86_FP80Ty()) { 1306932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Bits are not stored the same way as a normal i80 APInt, compensate. 1307932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t Rearrange[2]; 1308932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16); 1309932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Rearrange[1] = Record[0] >> 48; 1310d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::x87DoubleExtended, 1311d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(80, Rearrange))); 1312932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (CurTy->isFP128Ty()) 1313d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEquad, 1314d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(128, Record))); 1315932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurTy->isPPC_FP128Ty()) 1316d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::PPCDoubleDouble, 1317d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(128, Record))); 1318932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1319932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); 1320932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1321932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1322932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1323932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] 1324932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1325932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CST_AGGREGATE record"); 1326932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1327932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1328b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Constant*, 16> Elts; 1329932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1330932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (StructType *STy = dyn_cast<StructType>(CurTy)) { 1331932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1332932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i], 1333932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines STy->getElementType(i))); 1334932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantStruct::get(STy, Elts); 1335932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) { 1336932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = ATy->getElementType(); 1337932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1338932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 1339932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantArray::get(ATy, Elts); 1340932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) { 1341932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = VTy->getElementType(); 1342932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1343932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 1344932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantVector::get(Elts); 1345932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1346932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); 1347932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1348932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1349932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1350932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_STRING: { // STRING: [values] 1351932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1352932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CST_AGGREGATE record"); 1353932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1354932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArrayType *ATy = cast<ArrayType>(CurTy); 1355932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = ATy->getElementType(); 1356932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1357932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1358932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Constant*> Elts; 1359932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1360932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ConstantInt::get(EltTy, Record[i])); 1361932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantArray::get(ATy, Elts); 1362932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1363932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1364932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CSTRING: { // CSTRING: [values] 1365932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1366932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CST_AGGREGATE record"); 1367932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1368932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArrayType *ATy = cast<ArrayType>(CurTy); 1369932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = ATy->getElementType(); 1370932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1371932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1372932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Constant*> Elts; 1373932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1374932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ConstantInt::get(EltTy, Record[i])); 1375932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(Constant::getNullValue(EltTy)); 1376932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantArray::get(ATy, Elts); 1377932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1378932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1379932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] 1380932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) return Error("Invalid CE_BINOP record"); 1381932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedBinaryOpcode(Record[0], CurTy); 1382932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc < 0) { 1383932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); // Unknown binop. 1384932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1385932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy); 1386932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy); 1387932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Flags = 0; 1388932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() >= 4) { 1389932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc == Instruction::Add || 1390932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Sub || 1391932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Mul || 1392932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Shl) { 1393932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 1394932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Flags |= OverflowingBinaryOperator::NoSignedWrap; 1395932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 1396932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Flags |= OverflowingBinaryOperator::NoUnsignedWrap; 1397932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (Opc == Instruction::SDiv || 1398932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::UDiv || 1399932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::LShr || 1400932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::AShr) { 1401932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[3] & (1 << bitc::PEO_EXACT)) 1402932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Flags |= SDivOperator::IsExact; 1403932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1404932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1405932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::get(Opc, LHS, RHS, Flags); 1406932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1407932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1408932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1409932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] 1410932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) return Error("Invalid CE_CAST record"); 1411932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedCastOpcode(Record[0]); 1412932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc < 0) { 1413932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); // Unknown cast. 1414932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1415932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[1]); 1416932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!OpTy) return Error("Invalid CE_CAST record"); 1417932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); 1418932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getCast(Opc, Op, CurTy); 1419932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1420932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1421932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1422932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_INBOUNDS_GEP: 1423932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands] 1424932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() & 1) return Error("Invalid CE_GEP record"); 1425932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Constant*, 16> Elts; 1426932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 1427932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ElTy = getTypeByID(Record[i]); 1428932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!ElTy) return Error("Invalid CE_GEP record"); 1429932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); 1430932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1431932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BitCode == bitc::CST_CODE_CE_INBOUNDS_GEP) 1432bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien V = ConstantExpr::getInBoundsGetElementPtr(Elts[0], 1433bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien llvm::ArrayRef<llvm::Constant*>(&Elts[1], Elts.size() - 1)); 1434932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1435bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien V = ConstantExpr::getGetElementPtr(Elts[0], 1436bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien llvm::ArrayRef<llvm::Constant*>(&Elts[1], Elts.size() - 1)); 1437932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1438932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1439932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_SELECT: // CE_SELECT: [opval#, opval#, opval#] 1440932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) return Error("Invalid CE_SELECT record"); 1441932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0], 1442932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type::getInt1Ty(Context)), 1443932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.getConstantFwdRef(Record[1],CurTy), 1444932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.getConstantFwdRef(Record[2],CurTy)); 1445932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1446932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval] 1447932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) return Error("Invalid CE_EXTRACTELT record"); 1448932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = 1449932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1450932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy == 0) return Error("Invalid CE_EXTRACTELT record"); 1451932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1452932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 1453932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getExtractElement(Op0, Op1); 1454932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1455932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1456932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval] 1457932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1458932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || OpTy == 0) 1459932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CE_INSERTELT record"); 1460932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 1461932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[1], 1462932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpTy->getElementType()); 1463932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 1464932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getInsertElement(Op0, Op1, Op2); 1465932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1466932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1467932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] 1468932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1469932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || OpTy == 0) 1470932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CE_SHUFFLEVEC record"); 1471932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 1472932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); 1473932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 1474932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpTy->getNumElements()); 1475932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy); 1476932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 1477932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1478932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1479932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval] 1480932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *RTy = dyn_cast<VectorType>(CurTy); 1481932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = 1482932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1483932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 4 || RTy == 0 || OpTy == 0) 1484932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CE_SHUFVEC_EX record"); 1485932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1486932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 1487932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 1488932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines RTy->getNumElements()); 1489932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy); 1490932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 1491932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1492932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1493932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] 1494932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 4) return Error("Invalid CE_CMP record"); 1495932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 1496932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy == 0) return Error("Invalid CE_CMP record"); 1497932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1498932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 1499932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1500932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy->isFPOrFPVectorTy()) 1501932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getFCmp(Record[3], Op0, Op1); 1502932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1503932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getICmp(Record[3], Op0, Op1); 1504932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1505932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1506932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_INLINEASM: { 1507932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) return Error("Invalid INLINEASM record"); 1508932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string AsmStr, ConstrStr; 1509932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool HasSideEffects = Record[0] & 1; 1510932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool IsAlignStack = Record[0] >> 1; 1511932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AsmStrSize = Record[1]; 1512932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (2+AsmStrSize >= Record.size()) 1513932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INLINEASM record"); 1514932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ConstStrSize = Record[2+AsmStrSize]; 1515932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (3+AsmStrSize+ConstStrSize > Record.size()) 1516932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INLINEASM record"); 1517932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1518932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != AsmStrSize; ++i) 1519932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AsmStr += (char)Record[2+i]; 1520932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != ConstStrSize; ++i) 1521932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ConstrStr += (char)Record[3+AsmStrSize+i]; 1522932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *PTy = cast<PointerType>(CurTy); 1523932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), 1524932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AsmStr, ConstrStr, HasSideEffects, IsAlignStack); 1525932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1526932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1527932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_BLOCKADDRESS:{ 1528932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) return Error("Invalid CE_BLOCKADDRESS record"); 1529932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *FnTy = getTypeByID(Record[0]); 1530932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FnTy == 0) return Error("Invalid CE_BLOCKADDRESS record"); 1531932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *Fn = 1532932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy)); 1533932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Fn == 0) return Error("Invalid CE_BLOCKADDRESS record"); 1534b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1535932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalVariable *FwdRef = new GlobalVariable(*Fn->getParent(), 1536932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type::getInt8Ty(Context), 1537932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines false, GlobalValue::InternalLinkage, 1538932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 0, ""); 1539932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BlockAddrFwdRefs[Fn].push_back(std::make_pair(Record[2], FwdRef)); 1540932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = FwdRef; 1541932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1542b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines } 1543932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1544932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1545932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.AssignValue(V, NextCstNo); 1546932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++NextCstNo; 1547932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1548932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1549932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextCstNo != ValueList.size()) 1550932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid constant reference!"); 1551932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1552932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 1553932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Error at end of constants block"); 1554932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1555932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Once all the constants have been read, go through and resolve forward 1556932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // references. 1557932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.ResolveConstantForwardRefs(); 1558932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 1559932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1560932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1561932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// RememberAndSkipFunctionBody - When we see the block for a function body, 1562932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// remember where it is and then skip it. This lets us lazily deserialize the 1563932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// functions. 1564932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::RememberAndSkipFunctionBody() { 1565932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Get the function we are talking about. 1566932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FunctionsWithBodies.empty()) 1567932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Insufficient function protos"); 1568932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1569932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *Fn = FunctionsWithBodies.back(); 1570932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionsWithBodies.pop_back(); 1571932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1572932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Save the current stream state. 1573932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t CurBit = Stream.GetCurrentBitNo(); 1574932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DeferredFunctionInfo[Fn] = CurBit; 1575932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1576932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Skip over the function block for now. 1577932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1578932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 1579932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 1580932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1581932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1582d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesbool BitcodeReader::GlobalCleanup() { 1583d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Patch the initializers for globals and aliases up. 1584d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ResolveGlobalAndAliasInits(); 1585d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!GlobalInits.empty() || !AliasInits.empty()) 1586d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return Error("Malformed global initializer set"); 1587d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1588d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Look for intrinsic functions which need to be upgraded at some point 1589d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); 1590d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines FI != FE; ++FI) { 1591d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Function *NewFn; 1592d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (UpgradeIntrinsicFunction(FI, NewFn)) 1593d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn)); 1594d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 1595d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1596d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Look for global variables which need to be renamed. 1597d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (Module::global_iterator 1598d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines GI = TheModule->global_begin(), GE = TheModule->global_end(); 1599d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines GI != GE; ++GI) 1600d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines UpgradeGlobalVariable(GI); 1601d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Force deallocation of memory for these vectors to favor the client that 1602d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // want lazy deserialization. 1603d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); 1604d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); 1605d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return false; 1606d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 1607d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1608d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesbool BitcodeReader::ParseModule(bool Resume) { 1609d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Resume) 1610d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.JumpToBit(NextUnreadBit); 1611d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 1612932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 1613932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1614932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1615932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::string> SectionTable; 1616932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::string> GCTable; 1617932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1618932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this module. 1619932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!Stream.AtEndOfStream()) { 1620932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 1621932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 1622932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 1623932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Error at end of module block"); 1624932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1625932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Patch the initializers for globals and aliases up. 1626932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveGlobalAndAliasInits(); 1627932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!GlobalInits.empty() || !AliasInits.empty()) 1628932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed global initializer set"); 1629932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FunctionsWithBodies.empty()) 1630932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Too few function bodies found"); 1631932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1632932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Look for intrinsic functions which need to be upgraded at some point 1633932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); 1634932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FI != FE; ++FI) { 1635932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function* NewFn; 1636932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (UpgradeIntrinsicFunction(FI, NewFn)) 1637932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn)); 1638932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1639932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1640932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Look for global variables which need to be renamed. 1641932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Module::global_iterator 1642932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GI = TheModule->global_begin(), GE = TheModule->global_end(); 1643932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GI != GE; ++GI) 1644932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradeGlobalVariable(GI); 1645932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1646932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Force deallocation of memory for these vectors to favor the client that 1647932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // want lazy deserialization. 1648932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); 1649932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); 1650932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Function*>().swap(FunctionsWithBodies); 1651932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 1652932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1653932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1654932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 1655932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadSubBlockID()) { 1656932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Skip unknown content. 1657932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1658932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 1659932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1660932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BLOCKINFO_BLOCK_ID: 1661932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockInfoBlock()) 1662932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed BlockInfoBlock"); 1663932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1664932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::PARAMATTR_BLOCK_ID: 1665932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseAttributeBlock()) 1666932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 1667932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1668932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_BLOCK_ID_NEW: 1669932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseTypeTable()) 1670932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 1671932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1672be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien case TYPE_BLOCK_ID_OLD_3_0: 1673932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseOldTypeTable()) 1674932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 1675932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1676be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien case TYPE_SYMTAB_BLOCK_ID_OLD_3_0: 1677932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseOldTypeSymbolTable()) 1678932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 1679932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1680932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VALUE_SYMTAB_BLOCK_ID: 1681932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseValueSymbolTable()) 1682932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 1683d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SeenValueSymbolTable = true; 1684932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1685932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CONSTANTS_BLOCK_ID: 1686932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseConstants() || ResolveGlobalAndAliasInits()) 1687932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 1688932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1689932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_BLOCK_ID: 1690932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseMetadata()) 1691932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 1692932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1693932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNCTION_BLOCK_ID: 1694932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this is the first function body we've seen, reverse the 1695932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FunctionsWithBodies list. 1696d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!SeenFirstFunctionBody) { 1697932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end()); 1698d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (GlobalCleanup()) 1699d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return true; 1700d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SeenFirstFunctionBody = true; 1701932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1702932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1703932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (RememberAndSkipFunctionBody()) 1704932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 1705d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // For streaming bitcode, suspend parsing when we reach the function 1706d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // bodies. Subsequent materialization calls will resume it when 1707d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // necessary. For streaming, the function bodies must be at the end of 1708d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // the bitcode. If the bitcode file is old, the symbol table will be 1709d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // at the end instead and will not have been seen yet. In this case, 1710d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // just finish the parse now. 1711d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (LazyStreamer && SeenValueSymbolTable) { 1712d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines NextUnreadBit = Stream.GetCurrentBitNo(); 1713d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return false; 1714d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 1715d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 1716932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1717932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1718932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1719932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1720932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1721932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 1722932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 1723932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1724932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1725932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1726932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1727d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 1728932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: break; // Default behavior, ignore unknown content. 1729b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines case bitc::MODULE_CODE_VERSION: { // VERSION: [version#] 1730932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 1731932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed MODULE_CODE_VERSION"); 1732932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Only version #0 is supported so far. 1733932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[0] != 0) 1734932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Unknown bitstream version!"); 1735932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1736b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines } 1737932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 1738932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1739932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1740932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_CODE_TRIPLE record"); 1741932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule->setTargetTriple(S); 1742932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1743932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1744932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] 1745932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1746932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1747932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_CODE_DATALAYOUT record"); 1748932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule->setDataLayout(S); 1749932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1750932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1751932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] 1752932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1753932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1754932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_CODE_ASM record"); 1755932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule->setModuleInlineAsm(S); 1756932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1757932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1758932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N] 1759932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1760932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1761932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_CODE_DEPLIB record"); 1762b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // ANDROID: Ignore value, since we never used it anyways. 1763b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // TheModule->addLibrary(S); 1764932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1765932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1766932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] 1767932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1768932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1769932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_CODE_SECTIONNAME record"); 1770932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SectionTable.push_back(S); 1771932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1772932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1773932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N] 1774932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1775932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1776932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_CODE_GCNAME record"); 1777932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GCTable.push_back(S); 1778932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1779932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1780932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // GLOBALVAR: [pointer type, isconst, initid, 1781932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // linkage, alignment, section, visibility, threadlocal, 1782932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // unnamed_addr] 1783932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_GLOBALVAR: { 1784932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 6) 1785932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_CODE_GLOBALVAR record"); 1786932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 1787932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty) return Error("Invalid MODULE_CODE_GLOBALVAR record"); 1788932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty->isPointerTy()) 1789932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Global not a pointer type!"); 1790932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); 1791932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Ty = cast<PointerType>(Ty)->getElementType(); 1792932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1793932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool isConstant = Record[1]; 1794932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]); 1795932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Alignment = (1 << Record[4]) >> 1; 1796932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string Section; 1797932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[5]) { 1798932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[5]-1 >= SectionTable.size()) 1799932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid section ID"); 1800932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Section = SectionTable[Record[5]-1]; 1801932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1802932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; 1803932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 6) 1804932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Visibility = GetDecodedVisibility(Record[6]); 18058b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao 18068b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal; 1807932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 7) 18088b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao TLM = GetDecodedThreadLocalMode(Record[7]); 1809932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1810932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool UnnamedAddr = false; 1811932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 8) 1812932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UnnamedAddr = Record[8]; 1813932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1814932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalVariable *NewGV = 1815932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines new GlobalVariable(*TheModule, Ty, isConstant, Linkage, 0, "", 0, 18168b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao TLM, AddressSpace); 1817932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setAlignment(Alignment); 1818932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Section.empty()) 1819932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setSection(Section); 1820932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setVisibility(Visibility); 1821932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setUnnamedAddr(UnnamedAddr); 1822932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1823932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(NewGV); 1824932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1825932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Remember which value to use for the global initializer. 1826932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (unsigned InitID = Record[2]) 1827932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInits.push_back(std::make_pair(NewGV, InitID-1)); 1828932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1829932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1830932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FUNCTION: [type, callingconv, isproto, linkage, paramattr, 1831932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // alignment, section, visibility, gc, unnamed_addr] 1832932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_FUNCTION: { 1833932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 8) 1834932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_CODE_FUNCTION record"); 1835932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 1836932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty) return Error("Invalid MODULE_CODE_FUNCTION record"); 1837932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty->isPointerTy()) 1838932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Function not a pointer type!"); 1839932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionType *FTy = 1840932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType()); 1841932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy) 1842932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Function not a pointer to function type!"); 1843932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1844932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, 1845932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines "", TheModule); 1846932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1847932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setCallingConv(static_cast<CallingConv::ID>(Record[1])); 1848932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool isProto = Record[2]; 1849932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setLinkage(GetDecodedLinkage(Record[3])); 1850932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setAttributes(getAttributes(Record[4])); 1851932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1852932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setAlignment((1 << Record[5]) >> 1); 1853932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[6]) { 1854932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[6]-1 >= SectionTable.size()) 1855932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid section ID"); 1856932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setSection(SectionTable[Record[6]-1]); 1857932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1858932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setVisibility(GetDecodedVisibility(Record[7])); 1859932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 8 && Record[8]) { 1860932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[8]-1 > GCTable.size()) 1861932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid GC ID"); 1862932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setGC(GCTable[Record[8]-1].c_str()); 1863932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1864932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool UnnamedAddr = false; 1865932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 9) 1866932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UnnamedAddr = Record[9]; 1867932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setUnnamedAddr(UnnamedAddr); 1868932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(Func); 1869932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1870932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this is a function with a body, remember the prototype we are 1871932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // creating now, so that we can match up the body with them later. 1872d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isProto) { 1873932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionsWithBodies.push_back(Func); 1874d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (LazyStreamer) DeferredFunctionInfo[Func] = 0; 1875d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 1876932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1877932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1878932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // ALIAS: [alias type, aliasee val#, linkage] 1879932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // ALIAS: [alias type, aliasee val#, linkage, visibility] 1880932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_ALIAS: { 1881932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 1882932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_ALIAS record"); 1883932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 1884932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty) return Error("Invalid MODULE_ALIAS record"); 1885932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty->isPointerTy()) 1886932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Function not a pointer type!"); 1887932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1888932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]), 1889932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines "", 0, TheModule); 1890932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Old bitcode files didn't have visibility field. 1891932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 3) 1892932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGA->setVisibility(GetDecodedVisibility(Record[3])); 1893932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(NewGA); 1894932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInits.push_back(std::make_pair(NewGA, Record[1])); 1895932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1896932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1897932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// MODULE_CODE_PURGEVALS: [numvals] 1898932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_PURGEVALS: 1899932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Trim down the value list to the specified size. 1900932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1 || Record[0] > ValueList.size()) 1901932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_PURGEVALS record"); 1902932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.shrinkTo(Record[0]); 1903932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1904932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1905932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1906932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1907932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1908932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Premature end of bitstream"); 1909932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1910932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1911932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseBitcodeInto(Module *M) { 1912932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule = 0; 1913932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1914d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (InitStream()) return true; 1915932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1916932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Sniff for the signature. 1917932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.Read(8) != 'B' || 1918932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(8) != 'C' || 1919932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0x0 || 1920932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xC || 1921932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xE || 1922932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xD) 1923932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid bitcode signature"); 1924932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1925932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We expect a number of well-defined blocks, though we don't necessarily 1926932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // need to understand them all. 1927d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 1928d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.AtEndOfStream()) 1929d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return false; 1930d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1931d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = 1932d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs); 1933932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1934d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 1935d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 1936d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Error("malformed module file"); 1937d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return true; 1938d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 1939d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return false; 1940932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1941d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: 1942d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.ID) { 1943d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::BLOCKINFO_BLOCK_ID: 1944d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.ReadBlockInfoBlock()) 1945d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return Error("Malformed BlockInfoBlock"); 1946d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 1947d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::MODULE_BLOCK_ID: 1948d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Reject multiple MODULE_BLOCK's in a single bitstream. 1949d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (TheModule) 1950d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return Error("Multiple MODULE_BLOCKs in same stream"); 1951d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines TheModule = M; 1952d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (ParseModule(false)) 1953d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return true; 1954d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (LazyStreamer) return false; 1955d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 1956d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines default: 1957d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.SkipBlock()) 1958d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return Error("Malformed block record"); 1959d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 1960d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 1961d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 1962d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 1963d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // There should be no records in the top-level of blocks. 1964d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1965d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The ranlib in Xcode 4 will align archive members by appending newlines 1966d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // to the end of them. If this file size is a multiple of 4 but not 8, we 1967d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // have to read and ignore these final 4 bytes :-( 1968d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.getAbbrevIDWidth() == 2 && Entry.ID == 2 && 1969932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a && 1970b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines Stream.AtEndOfStream()) 1971932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 1972932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1973932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid record at top-level"); 1974932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1975932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1976932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1977932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1978932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseModuleTriple(std::string &Triple) { 1979932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 1980932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 1981932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1982932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1983932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1984932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this module. 1985d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 1986d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 1987932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1988d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 1989d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 1990d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 1991d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return Error("malformed module block"); 1992d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 1993932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 1994d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 1995d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 1996d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 1997932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1998932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1999932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 2000d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 2001932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: break; // Default behavior, ignore unknown content. 2002932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_VERSION: // VERSION: [version#] 2003932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 2004932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed MODULE_CODE_VERSION"); 2005932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Only version #0 is supported so far. 2006932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[0] != 0) 2007932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Unknown bitstream version!"); 2008932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2009932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 2010932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 2011932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 2012932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_CODE_TRIPLE record"); 2013932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Triple = S; 2014932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2015932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2016932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2017932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 2018932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2019932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2020932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Premature end of bitstream"); 2021932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2022932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2023932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseTriple(std::string &Triple) { 2024d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (InitStream()) return true; 2025932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2026932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Sniff for the signature. 2027932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.Read(8) != 'B' || 2028932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(8) != 'C' || 2029932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0x0 || 2030932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xC || 2031932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xE || 2032932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xD) 2033932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid bitcode signature"); 2034932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2035932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We expect a number of well-defined blocks, though we don't necessarily 2036932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // need to understand them all. 2037d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2038d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advance(); 2039932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2040d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2041d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2042d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Error("malformed module file"); 2043d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return true; 2044d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2045d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return false; 2046932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2047d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: 2048d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Entry.ID == bitc::MODULE_BLOCK_ID) 2049d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return ParseModuleTriple(Triple); 2050932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2051d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Ignore other sub-blocks. 2052d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.SkipBlock()) { 2053d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Error("malformed block record in AST file"); 2054932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 2055d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 2056d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 2057d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2058d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2059d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.skipRecord(Entry.ID); 2060d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 2061932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2062932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2063932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2064932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2065932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ParseMetadataAttachment - Parse metadata attachments. 2066932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseMetadataAttachment() { 2067932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) 2068932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 2069932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2070932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 2071d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2072d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 2073d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2074d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2075d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 2076d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2077d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return Error("malformed metadata block"); 2078d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2079d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return false; 2080d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2081d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 2082932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2083932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2084d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2085932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a metadata attachment record. 2086932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 2087d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 2088932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: ignore. 2089932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2090932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case METADATA_ATTACHMENT_2_7: 2091932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 2092932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_ATTACHMENT: { 2093932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned RecordLength = Record.size(); 2094932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty() || (RecordLength - 1) % 2 == 1) 2095932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error ("Invalid METADATA_ATTACHMENT reader!"); 2096932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Instruction *Inst = InstructionList[Record[0]]; 2097932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1; i != RecordLength; i = i+2) { 2098932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Kind = Record[i]; 2099932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DenseMap<unsigned, unsigned>::iterator I = 2100932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDKindMap.find(Kind); 2101932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I == MDKindMap.end()) 2102932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid metadata kind ID"); 2103932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Node = MDValueList.getValueFwdRef(Record[i+1]); 2104932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Inst->setMetadata(I->second, cast<MDNode>(Node)); 2105932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2106932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2107932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2108932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2109932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2110932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2111932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2112932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ParseFunctionBody - Lazily parse the specified function body block. 2113932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseFunctionBody(Function *F) { 2114932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) 2115932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 2116932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2117932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.clear(); 2118932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ModuleValueListSize = ValueList.size(); 2119932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ModuleMDValueListSize = MDValueList.size(); 2120932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2121932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Add all the function arguments to the value table. 2122932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) 2123932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(I); 2124932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2125932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextValueNo = ValueList.size(); 2126932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *CurBB = 0; 2127932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned CurBBNo = 0; 2128932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2129932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DebugLoc LastLoc; 2130b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2131932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records. 2132932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 2133932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 2134932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 2135932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 2136932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 2137932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Error at end of function block"); 2138932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2139932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2140932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2141932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 2142932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadSubBlockID()) { 2143932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Skip unknown content. 2144932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 2145932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 2146932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2147932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CONSTANTS_BLOCK_ID: 2148932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseConstants()) return true; 2149932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NextValueNo = ValueList.size(); 2150932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2151932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VALUE_SYMTAB_BLOCK_ID: 2152932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseValueSymbolTable()) return true; 2153932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2154932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_ATTACHMENT_ID: 2155932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseMetadataAttachment()) return true; 2156932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2157932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_BLOCK_ID: 2158932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseMetadata()) return true; 2159932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2160932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2161932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2162932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2163932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2164932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 2165932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 2166932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2167932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2168932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2169932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 2170932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 2171932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Instruction *I = 0; 2172d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned BitCode = Stream.readRecord(Code, Record); 2173932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (BitCode) { 2174932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: reject 2175932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Unknown instruction"); 2176932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks] 2177932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1 || Record[0] == 0) 2178932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid DECLAREBLOCKS record"); 2179932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create all the basic blocks for the function. 2180932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionBBs.resize(Record[0]); 2181932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) 2182932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionBBs[i] = BasicBlock::Create(Context, "", F); 2183932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurBB = FunctionBBs[0]; 2184932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2185b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2186932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN 2187932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // This record indicates that the last instruction is at the same 2188932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // location as the previous instruction with a location. 2189932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; 2190b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2191932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Get the last instruction emitted. 2192932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CurBB && !CurBB->empty()) 2193932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &CurBB->back(); 2194932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurBBNo && FunctionBBs[CurBBNo-1] && 2195932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines !FunctionBBs[CurBBNo-1]->empty()) 2196932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &FunctionBBs[CurBBNo-1]->back(); 2197b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2198932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I == 0) return Error("Invalid DEBUG_LOC_AGAIN record"); 2199932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->setDebugLoc(LastLoc); 2200932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; 2201932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2202b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2203932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_DEBUG_LOC_2_7: 2204932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 2205932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia] 2206932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; // Get the last instruction emitted. 2207932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CurBB && !CurBB->empty()) 2208932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &CurBB->back(); 2209932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurBBNo && FunctionBBs[CurBBNo-1] && 2210932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines !FunctionBBs[CurBBNo-1]->empty()) 2211932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &FunctionBBs[CurBBNo-1]->back(); 2212932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I == 0 || Record.size() < 4) 2213932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid FUNC_CODE_DEBUG_LOC record"); 2214b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2215932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Line = Record[0], Col = Record[1]; 2216932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ScopeID = Record[2], IAID = Record[3]; 2217b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2218932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDNode *Scope = 0, *IA = 0; 2219932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ScopeID) Scope = cast<MDNode>(MDValueList.getValueFwdRef(ScopeID-1)); 2220932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (IAID) IA = cast<MDNode>(MDValueList.getValueFwdRef(IAID-1)); 2221932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LastLoc = DebugLoc::get(Line, Col, Scope, IA); 2222932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->setDebugLoc(LastLoc); 2223932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; 2224932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2225932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2226932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2227932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode] 2228932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2229932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *LHS, *RHS; 2230932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 2231932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, LHS->getType(), RHS) || 2232932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+1 > Record.size()) 2233932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid BINOP record"); 2234932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2235932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); 2236932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc == -1) return Error("Invalid BINOP record"); 2237932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); 2238932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2239932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpNum < Record.size()) { 2240932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc == Instruction::Add || 2241932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Sub || 2242932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Mul || 2243932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Shl) { 2244932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 2245932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<BinaryOperator>(I)->setHasNoSignedWrap(true); 2246932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 2247932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true); 2248932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (Opc == Instruction::SDiv || 2249932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::UDiv || 2250932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::LShr || 2251932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::AShr) { 2252932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[OpNum] & (1 << bitc::PEO_EXACT)) 2253932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<BinaryOperator>(I)->setIsExact(true); 2254932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2255932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2256932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2257932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2258932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc] 2259932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2260932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2261932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2262932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) 2263932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CAST record"); 2264932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2265932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ResTy = getTypeByID(Record[OpNum]); 2266932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedCastOpcode(Record[OpNum+1]); 2267932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc == -1 || ResTy == 0) 2268932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CAST record"); 2269932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy); 2270932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2271932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2272932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2273932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INBOUNDS_GEP: 2274932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands] 2275932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2276932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *BasePtr; 2277932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) 2278932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid GEP record"); 2279932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2280932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 16> GEPIdx; 2281932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (OpNum != Record.size()) { 2282932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2283932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2284932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid GEP record"); 2285932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GEPIdx.push_back(Op); 2286932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2287932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2288bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien I = GetElementPtrInst::Create(BasePtr, GEPIdx); 2289932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2290932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP) 2291932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<GetElementPtrInst>(I)->setIsInBounds(true); 2292932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2293932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2294932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2295932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_EXTRACTVAL: { 2296932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // EXTRACTVAL: [opty, opval, n x indices] 2297932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2298932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Agg; 2299932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2300932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid EXTRACTVAL record"); 2301932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2302932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<unsigned, 4> EXTRACTVALIdx; 2303932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned RecSize = Record.size(); 2304932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum != RecSize; ++OpNum) { 2305932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t Index = Record[OpNum]; 2306932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((unsigned)Index != Index) 2307932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid EXTRACTVAL index"); 2308932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EXTRACTVALIdx.push_back((unsigned)Index); 2309932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2310932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2311932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ExtractValueInst::Create(Agg, EXTRACTVALIdx); 2312932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2313932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2314932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2315932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2316932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INSERTVAL: { 2317932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // INSERTVAL: [opty, opval, opty, opval, n x indices] 2318932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2319932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Agg; 2320932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2321932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INSERTVAL record"); 2322932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Val; 2323932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Val)) 2324932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INSERTVAL record"); 2325932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2326932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<unsigned, 4> INSERTVALIdx; 2327932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned RecSize = Record.size(); 2328932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum != RecSize; ++OpNum) { 2329932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t Index = Record[OpNum]; 2330932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((unsigned)Index != Index) 2331932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INSERTVAL index"); 2332932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines INSERTVALIdx.push_back((unsigned)Index); 2333932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2334932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2335932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = InsertValueInst::Create(Agg, Val, INSERTVALIdx); 2336932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2337932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2338932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2339932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2340932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval] 2341932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // obsolete form of select 2342932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // handles select i1 ... in old bitcode 2343932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2344932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *TrueVal, *FalseVal, *Cond; 2345932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 2346932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 2347932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Type::getInt1Ty(Context), Cond)) 2348932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid SELECT record"); 2349932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2350932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = SelectInst::Create(Cond, TrueVal, FalseVal); 2351932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2352932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2353932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2354932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2355932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred] 2356932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // new form of select 2357932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // handles select i1 or select [N x i1] 2358932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2359932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *TrueVal, *FalseVal, *Cond; 2360932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 2361932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 2362932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValueTypePair(Record, OpNum, NextValueNo, Cond)) 2363932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid SELECT record"); 2364932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2365932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // select condition can be either i1 or [N x i1] 2366932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (VectorType* vector_type = 2367932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast<VectorType>(Cond->getType())) { 2368932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // expect <n x i1> 2369932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (vector_type->getElementType() != Type::getInt1Ty(Context)) 2370932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid SELECT condition type"); 2371932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2372932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // expect i1 2373932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Cond->getType() != Type::getInt1Ty(Context)) 2374932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid SELECT condition type"); 2375932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2376932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2377932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = SelectInst::Create(Cond, TrueVal, FalseVal); 2378932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2379932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2380932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2381932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2382932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval] 2383932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2384932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Vec, *Idx; 2385932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 2386932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 2387932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid EXTRACTELT record"); 2388932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ExtractElementInst::Create(Vec, Idx); 2389932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2390932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2391932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2392932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2393932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval] 2394932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2395932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Vec, *Elt, *Idx; 2396932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 2397932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, 2398932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<VectorType>(Vec->getType())->getElementType(), Elt) || 2399932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 2400932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INSERTELT record"); 2401932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = InsertElementInst::Create(Vec, Elt, Idx); 2402932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2403932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2404932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2405932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2406932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval] 2407932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2408932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Vec1, *Vec2, *Mask; 2409932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) || 2410932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Vec1->getType(), Vec2)) 2411932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid SHUFFLEVEC record"); 2412932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2413932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) 2414932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid SHUFFLEVEC record"); 2415932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new ShuffleVectorInst(Vec1, Vec2, Mask); 2416932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2417932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2418932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2419932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2420932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred] 2421932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Old form of ICmp/FCmp returning bool 2422932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were 2423932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // both legal on vectors but had different behaviour. 2424932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred] 2425932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FCmp/ICmp returning bool or vector of bool 2426932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2427932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2428932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *LHS, *RHS; 2429932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 2430932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, LHS->getType(), RHS) || 2431932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+1 != Record.size()) 2432932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CMP record"); 2433932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2434932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (LHS->getType()->isFPOrFPVectorTy()) 2435932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); 2436932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 2437932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS); 2438932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2439932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2440932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2441932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2442932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_GETRESULT_2_7: { 2443932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != 2) { 2444932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid GETRESULT record"); 2445932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2446932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2447932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2448932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValueTypePair(Record, OpNum, NextValueNo, Op); 2449932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Index = Record[1]; 2450932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ExtractValueInst::Create(Op, Index); 2451932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2452932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2453932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2454932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2455932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>] 2456932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines { 2457932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 2458932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Size == 0) { 2459932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ReturnInst::Create(Context); 2460932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2461932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2462932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2463932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2464932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2465932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op = NULL; 2466932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2467932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid RET record"); 2468932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpNum != Record.size()) 2469932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid RET record"); 2470932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2471932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ReturnInst::Create(Context, Op); 2472932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2473932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2474932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2475932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] 2476932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != 1 && Record.size() != 3) 2477932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid BR record"); 2478932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *TrueDest = getBasicBlock(Record[0]); 2479932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TrueDest == 0) 2480932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid BR record"); 2481932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2482932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() == 1) { 2483932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = BranchInst::Create(TrueDest); 2484932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2485932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2486932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else { 2487932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *FalseDest = getBasicBlock(Record[1]); 2488932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Cond = getFnValueByID(Record[2], Type::getInt1Ty(Context)); 2489932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FalseDest == 0 || Cond == 0) 2490932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid BR record"); 2491932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = BranchInst::Create(TrueDest, FalseDest, Cond); 2492932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2493932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2494932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2495932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2496932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...] 2497932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || (Record.size() & 1) == 0) 2498932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid SWITCH record"); 2499932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 2500932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Cond = getFnValueByID(Record[1], OpTy); 2501932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *Default = getBasicBlock(Record[2]); 2502932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy == 0 || Cond == 0 || Default == 0) 2503932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid SWITCH record"); 2504932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumCases = (Record.size()-3)/2; 2505932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); 2506932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(SI); 2507932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = NumCases; i != e; ++i) { 2508932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ConstantInt *CaseVal = 2509932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy)); 2510932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); 2511932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CaseVal == 0 || DestBB == 0) { 2512932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete SI; 2513932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid SWITCH record!"); 2514932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2515932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SI->addCase(CaseVal, DestBB); 2516932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2517932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = SI; 2518932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2519932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2520932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] 2521932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 2522932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INDIRECTBR record"); 2523932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 2524932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Address = getFnValueByID(Record[1], OpTy); 2525932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy == 0 || Address == 0) 2526932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INDIRECTBR record"); 2527932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumDests = Record.size()-2; 2528932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); 2529932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(IBI); 2530932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = NumDests; i != e; ++i) { 2531932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) { 2532932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IBI->addDestination(DestBB); 2533932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2534932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete IBI; 2535932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INDIRECTBR record!"); 2536932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2537932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2538932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = IBI; 2539932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2540932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2541b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2542932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INVOKE: { 2543932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] 2544932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 4) return Error("Invalid INVOKE record"); 2545b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines AttributeSet PAL = getAttributes(Record[0]); 2546932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned CCInfo = Record[1]; 2547932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *NormalBB = getBasicBlock(Record[2]); 2548932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *UnwindBB = getBasicBlock(Record[3]); 2549932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2550932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 4; 2551932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Callee; 2552932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 2553932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INVOKE record"); 2554932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2555932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); 2556932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionType *FTy = !CalleeTy ? 0 : 2557932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast<FunctionType>(CalleeTy->getElementType()); 2558932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2559932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check that the right number of fixed parameters are here. 2560932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FTy == 0 || NormalBB == 0 || UnwindBB == 0 || 2561932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.size() < OpNum+FTy->getNumParams()) 2562932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INVOKE record"); 2563932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2564932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 16> Ops; 2565932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 2566932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Ops.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 2567932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Ops.back() == 0) return Error("Invalid INVOKE record"); 2568932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2569932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2570932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy->isVarArg()) { 2571932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != OpNum) 2572932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INVOKE record"); 2573932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2574932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read type/value pairs for varargs params. 2575932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (OpNum != Record.size()) { 2576932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2577932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2578932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INVOKE record"); 2579932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Ops.push_back(Op); 2580932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2581932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2582932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2583932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops); 2584932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2585932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<InvokeInst>(I)->setCallingConv( 2586932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static_cast<CallingConv::ID>(CCInfo)); 2587932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<InvokeInst>(I)->setAttributes(PAL); 2588932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2589932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2590c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao case FUNC_CODE_INST_UNWIND_2_7: { // UNWIND_OLD 2591c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao // 'unwind' instruction has been removed in LLVM 3.1 2592c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao // Replace 'unwind' with 'landingpad' and 'resume'. 2593c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Type *ExnTy = StructType::get(Type::getInt8PtrTy(Context), 2594c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Type::getInt32Ty(Context), NULL); 2595c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Constant *PersFn = 2596c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao F->getParent()-> 2597c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao getOrInsertFunction("__gcc_personality_v0", 2598c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao FunctionType::get(Type::getInt32Ty(Context), true)); 2599c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 2600c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao LandingPadInst *LP = LandingPadInst::Create(ExnTy, PersFn, 1); 2601c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao LP->setCleanup(true); 2602c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 2603c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao CurBB->getInstList().push_back(LP); 2604c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao I = ResumeInst::Create(LP); 2605932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2606932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2607c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao } 2608932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE 2609932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new UnreachableInst(Context); 2610932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2611932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2612932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...] 2613932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1 || ((Record.size()-1)&1)) 2614932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid PHI record"); 2615932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 2616932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty) return Error("Invalid PHI record"); 2617932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2618932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2); 2619932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(PN); 2620932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2621932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) { 2622932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = getFnValueByID(Record[1+i], Ty); 2623932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *BB = getBasicBlock(Record[2+i]); 2624932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!V || !BB) return Error("Invalid PHI record"); 2625932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PN->addIncoming(V, BB); 2626932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2627932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = PN; 2628932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2629932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2630932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2631932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_MALLOC_2_7: { // MALLOC: [instty, op, align] 2632932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Autoupgrade malloc instruction to malloc call. 2633932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME: Remove in LLVM 3.0. 2634932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) { 2635932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MALLOC record"); 2636932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2637932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *Ty = 2638932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<PointerType>(getTypeByID(Record[0])); 2639932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Size = getFnValueByID(Record[1], Type::getInt32Ty(Context)); 2640932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty || !Size) return Error("Invalid MALLOC record"); 2641932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!CurBB) return Error("Invalid malloc instruction with no BB"); 2642932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Int32Ty = IntegerType::getInt32Ty(CurBB->getContext()); 2643932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *AllocSize = ConstantExpr::getSizeOf(Ty->getElementType()); 2644932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, Int32Ty); 2645932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CallInst::CreateMalloc(CurBB, Int32Ty, Ty->getElementType(), 2646932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AllocSize, Size, NULL); 2647932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2648932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2649932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2650932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_FREE_2_7: { // FREE: [op, opty] 2651932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2652932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2653932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2654932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum != Record.size()) { 2655932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid FREE record"); 2656932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2657932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!CurBB) return Error("Invalid free instruction with no BB"); 2658932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CallInst::CreateFree(Op, CurBB); 2659932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2660932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2661932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2662932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2663932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align] 2664932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // For backward compatibility, tolerate a lack of an opty, and use i32. 2665932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Remove this in LLVM 3.0. 2666932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || Record.size() > 4) { 2667932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid ALLOCA record"); 2668932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2669932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2670932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *Ty = 2671932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<PointerType>(getTypeByID(Record[OpNum++])); 2672932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = Record.size() == 4 ? getTypeByID(Record[OpNum++]) : 2673932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type::getInt32Ty(Context); 2674932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Size = getFnValueByID(Record[OpNum++], OpTy); 2675932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Align = Record[OpNum++]; 2676932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty || !Size) return Error("Invalid ALLOCA record"); 2677932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); 2678932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2679932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2680932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2681932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol] 2682932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2683932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2684932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2685932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) 2686932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid LOAD record"); 2687932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2688932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2689932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2690932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2691932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2692932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_STORE: { // STORE2:[ptrty, ptr, val, align, vol] 2693932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2694932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Val, *Ptr; 2695932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 2696932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, 2697932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<PointerType>(Ptr->getType())->getElementType(), Val) || 2698932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) 2699932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid STORE record"); 2700932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2701932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2702932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2703932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2704932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2705932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_STORE_2_7: { 2706932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2707932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Val, *Ptr; 2708932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Val) || 2709932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, 2710932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType::getUnqual(Val->getType()), Ptr)|| 2711932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) { 2712932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid STORE record"); 2713932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2714932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2715932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2716932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2717932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2718932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_CALL_2_7: 2719932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 2720932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CALL: { 2721932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] 2722932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 2723932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CALL record"); 2724932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2725b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines AttributeSet PAL = getAttributes(Record[0]); 2726932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned CCInfo = Record[1]; 2727932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2728932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 2; 2729932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Callee; 2730932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 2731932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CALL record"); 2732932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2733932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); 2734932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionType *FTy = 0; 2735932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType()); 2736932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy || Record.size() < FTy->getNumParams()+OpNum) 2737932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CALL record"); 2738932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2739932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 16> Args; 2740932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read the fixed params. 2741932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 2742932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FTy->getParamType(i)->isLabelTy()) 2743932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Args.push_back(getBasicBlock(Record[OpNum])); 2744932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 2745932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Args.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 2746932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Args.back() == 0) return Error("Invalid CALL record"); 2747932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2748932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2749932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read type/value pairs for varargs params. 2750932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy->isVarArg()) { 2751932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpNum != Record.size()) 2752932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CALL record"); 2753932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2754932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (OpNum != Record.size()) { 2755932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2756932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2757932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CALL record"); 2758932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Args.push_back(Op); 2759932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2760932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2761932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2762932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CallInst::Create(Callee, Args); 2763932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2764932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<CallInst>(I)->setCallingConv( 2765932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static_cast<CallingConv::ID>(CCInfo>>1)); 2766932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<CallInst>(I)->setTailCall(CCInfo & 1); 2767932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<CallInst>(I)->setAttributes(PAL); 2768932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2769932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2770932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] 2771932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 2772932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid VAARG record"); 2773932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 2774932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op = getFnValueByID(Record[1], OpTy); 2775932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ResTy = getTypeByID(Record[2]); 2776932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!OpTy || !Op || !ResTy) 2777932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid VAARG record"); 2778932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new VAArgInst(Op, ResTy); 2779932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2780932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2781932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2782932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2783932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2784932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Add instruction to end of current BB. If there is no current BB, reject 2785932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // this file. 2786932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CurBB == 0) { 2787932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete I; 2788932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid instruction with no BB"); 2789932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2790932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurBB->getInstList().push_back(I); 2791932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2792932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this was a terminator instruction, move to the next block. 2793932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (isa<TerminatorInst>(I)) { 2794932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++CurBBNo; 2795932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0; 2796932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2797932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2798932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Non-void values get registered in the value table for future use. 2799932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I && !I->getType()->isVoidTy()) 2800932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.AssignValue(I, NextValueNo++); 2801932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2802932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2803932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check the function list for unresolved values. 2804932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Argument *A = dyn_cast<Argument>(ValueList.back())) { 2805932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (A->getParent() == 0) { 2806932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We found at least one unresolved value. Nuke them all to avoid leaks. 2807932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){ 2808932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((A = dyn_cast<Argument>(ValueList[i])) && A->getParent() == 0) { 2809932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines A->replaceAllUsesWith(UndefValue::get(A->getType())); 2810932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete A; 2811932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2812932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2813932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Never resolved value found in function!"); 2814932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2815932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2816932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2817932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME: Check for unresolved forward-declared metadata references 2818932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // and clean up leaks. 2819932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2820932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // See if anything took the address of blocks in this function. If so, 2821932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // resolve them now. 2822932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DenseMap<Function*, std::vector<BlockAddrRefTy> >::iterator BAFRI = 2823932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BlockAddrFwdRefs.find(F); 2824932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BAFRI != BlockAddrFwdRefs.end()) { 2825932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<BlockAddrRefTy> &RefList = BAFRI->second; 2826932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = RefList.size(); i != e; ++i) { 2827932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned BlockIdx = RefList[i].first; 2828932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BlockIdx >= FunctionBBs.size()) 2829932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid blockaddress block #"); 2830b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2831932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalVariable *FwdRef = RefList[i].second; 2832932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx])); 2833932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FwdRef->eraseFromParent(); 2834932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2835b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2836932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BlockAddrFwdRefs.erase(BAFRI); 2837932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2838932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2839932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NewMDValueListSize = MDValueList.size(); 2840932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Trim the value list down to the size it was before we parsed this function. 2841932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.shrinkTo(ModuleValueListSize); 2842932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.shrinkTo(ModuleMDValueListSize); 2843932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2844932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (LLVM2_7MetadataDetected) { 2845932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.resize(NewMDValueListSize); 2846932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2847932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2848932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<BasicBlock*>().swap(FunctionBBs); 2849932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 2850932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2851932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2852932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 2853932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// GVMaterializer implementation 2854932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 2855932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2856932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2857932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::isMaterializable(const GlobalValue *GV) const { 2858932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (const Function *F = dyn_cast<Function>(GV)) { 2859932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return F->isDeclaration() && 2860932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DeferredFunctionInfo.count(const_cast<Function*>(F)); 2861932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2862932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 2863932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2864932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2865932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::Materialize(GlobalValue *GV, std::string *ErrInfo) { 2866932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *F = dyn_cast<Function>(GV); 2867932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If it's not a function or is already material, ignore the request. 2868932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!F || !F->isMaterializable()) return false; 2869932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2870932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F); 2871932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!"); 2872932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2873932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Move the bit stream to the saved position of the deferred function body. 2874932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.JumpToBit(DFII->second); 2875932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2876932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseFunctionBody(F)) { 2877932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ErrInfo) *ErrInfo = ErrorString; 2878932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 2879932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2880932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2881932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Upgrade any old intrinsic calls in the function. 2882932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(), 2883932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines E = UpgradedIntrinsics.end(); I != E; ++I) { 2884932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I->first != I->second) { 2885932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Value::use_iterator UI = I->first->use_begin(), 2886932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UE = I->first->use_end(); UI != UE; ) { 2887932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 2888932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradeIntrinsicCall(CI, I->second); 2889932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2890932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2891932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2892932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2893932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 2894932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2895932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2896932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::isDematerializable(const GlobalValue *GV) const { 2897932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines const Function *F = dyn_cast<Function>(GV); 2898932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!F || F->isDeclaration()) 2899932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 2900932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return DeferredFunctionInfo.count(const_cast<Function*>(F)); 2901932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2902932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2903932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReader::Dematerialize(GlobalValue *GV) { 2904932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *F = dyn_cast<Function>(GV); 2905932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this function isn't dematerializable, this is a noop. 2906932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!F || !isDematerializable(F)) 2907932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 2908932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2909932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(DeferredFunctionInfo.count(F) && "No info to read function later?"); 2910932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2911932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Just forget the function body, we can remat it later. 2912932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines F->deleteBody(); 2913932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2914932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2915932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2916932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::MaterializeModule(Module *M, std::string *ErrInfo) { 2917932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(M == TheModule && 2918932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines "Can only Materialize the Module this BitcodeReader is attached to."); 2919932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Iterate over the module, deserializing any functions that are still on 2920932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // disk. 2921932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Module::iterator F = TheModule->begin(), E = TheModule->end(); 2922932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines F != E; ++F) 2923932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (F->isMaterializable() && 2924932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Materialize(F, ErrInfo)) 2925932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 2926932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2927932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Upgrade any intrinsic calls that slipped through (should not happen!) and 2928932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // delete the old functions to clean up. We can't do this unless the entire 2929932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // module is materialized because there could always be another function body 2930932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // with calls to the old function. 2931932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (std::vector<std::pair<Function*, Function*> >::iterator I = 2932932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) { 2933932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I->first != I->second) { 2934932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Value::use_iterator UI = I->first->use_begin(), 2935932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UE = I->first->use_end(); UI != UE; ) { 2936932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 2937932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradeIntrinsicCall(CI, I->second); 2938932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2939932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!I->first->use_empty()) 2940932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->first->replaceAllUsesWith(I->second); 2941932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->first->eraseFromParent(); 2942932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2943932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2944932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics); 2945932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2946932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check debug info intrinsics. 2947932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CheckDebugInfoIntrinsics(TheModule); 2948932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2949932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 2950932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2951932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2952d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesbool BitcodeReader::InitStream() { 2953d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (LazyStreamer) return InitLazyStream(); 2954d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return InitStreamFromBuffer(); 2955d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 2956d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2957d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesbool BitcodeReader::InitStreamFromBuffer() { 2958d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *BufPtr = (const unsigned char*)Buffer->getBufferStart(); 2959d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); 2960d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2961d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Buffer->getBufferSize() & 3) { 2962d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isRawBitcode(BufPtr, BufEnd) && !isBitcodeWrapper(BufPtr, BufEnd)) 2963d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return Error("Invalid bitcode signature"); 2964d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else 2965d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return Error("Bitcode stream should be a multiple of 4 bytes in length"); 2966d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 2967d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2968d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // If we have a wrapper header, parse it and ignore the non-bc file contents. 2969d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The magic number is 0x0B17C0DE stored in little endian. 2970d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (isBitcodeWrapper(BufPtr, BufEnd)) 2971d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true)) 2972d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return Error("Invalid bitcode wrapper header"); 2973d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2974d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamFile.reset(new BitstreamReader(BufPtr, BufEnd)); 2975d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.init(*StreamFile); 2976d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2977d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return false; 2978d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 2979d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2980d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesbool BitcodeReader::InitLazyStream() { 2981d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Check and strip off the bitcode wrapper; BitstreamReader expects never to 2982d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // see it. 2983d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamingMemoryObject *Bytes = new StreamingMemoryObject(LazyStreamer); 2984d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamFile.reset(new BitstreamReader(Bytes)); 2985d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.init(*StreamFile); 2986d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2987d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned char buf[16]; 2988d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Bytes->readBytes(0, 16, buf, NULL) == -1) 2989d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return Error("Bitcode stream must be at least 16 bytes in length"); 2990d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2991d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isBitcode(buf, buf + 16)) 2992d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return Error("Invalid bitcode signature"); 2993d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2994d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (isBitcodeWrapper(buf, buf + 4)) { 2995d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *bitcodeStart = buf; 2996d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *bitcodeEnd = buf + 16; 2997d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false); 2998d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Bytes->dropLeadingBytes(bitcodeStart - buf); 2999d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Bytes->setKnownObjectSize(bitcodeEnd - bitcodeStart); 3000d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 3001d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return false; 3002d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 3003932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3004932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 3005932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// External interface 3006932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 3007932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3008932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// getLazyBitcodeModule - lazy function-at-a-time loading from a file. 3009932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// 3010932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesModule *llvm_2_7::getLazyBitcodeModule(MemoryBuffer *Buffer, 3011932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVMContext& Context, 3012932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string *ErrMsg) { 3013932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Module *M = new Module(Buffer->getBufferIdentifier(), Context); 3014932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BitcodeReader *R = new BitcodeReader(Buffer, Context); 3015932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines M->setMaterializer(R); 3016932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (R->ParseBitcodeInto(M)) { 3017932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ErrMsg) 3018932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines *ErrMsg = R->getErrorString(); 3019932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3020932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete M; // Also deletes R. 3021932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return 0; 3022932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3023932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Have the BitcodeReader dtor delete 'Buffer'. 3024932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines R->setBufferOwned(true); 3025932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return M; 3026932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3027932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3028932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ParseBitcodeFile - Read the specified bitcode file, returning the module. 3029932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// If an error occurs, return null and fill in *ErrMsg if non-null. 3030932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesModule *llvm_2_7::ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext& Context, 3031932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string *ErrMsg){ 3032932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Module *M = llvm_2_7::getLazyBitcodeModule(Buffer, Context, ErrMsg); 3033932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!M) return 0; 3034932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3035932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether 3036932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // there was an error. 3037932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static_cast<BitcodeReader*>(M->getMaterializer())->setBufferOwned(false); 3038932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3039932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read in the entire module, and destroy the BitcodeReader. 3040932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (M->MaterializeAllPermanently(ErrMsg)) { 3041932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete M; 3042932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return 0; 3043932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3044932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3045932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return M; 3046932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3047932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3048932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstd::string llvm_2_7::getBitcodeTargetTriple(MemoryBuffer *Buffer, 3049932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVMContext& Context, 3050932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string *ErrMsg) { 3051932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BitcodeReader *R = new BitcodeReader(Buffer, Context); 3052932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Don't let the BitcodeReader dtor delete 'Buffer'. 3053932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines R->setBufferOwned(false); 3054932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3055932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string Triple(""); 3056932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (R->ParseTriple(Triple)) 3057932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ErrMsg) 3058932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines *ErrMsg = R->getErrorString(); 3059932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3060932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete R; 3061932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Triple; 3062932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3063