BitcodeReader.cpp revision d724d097437f40a5689464429f948ec41e4a2415
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; 144d724d097437f40a5689464429f948ec41e4a2415Stephen Hines //ANDROID: convert LinkOnceODRAutoHideLinkage -> LinkOnceODRLinkage 145d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case 15: return GlobalValue::LinkOnceODRLinkage; 146932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 147932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 148932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 149932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) { 150932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Val) { 151932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Map unknown visibilities to default. 152932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 0: return GlobalValue::DefaultVisibility; 153932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 1: return GlobalValue::HiddenVisibility; 154932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 2: return GlobalValue::ProtectedVisibility; 155932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 156932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 157932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1588b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liaostatic GlobalVariable::ThreadLocalMode GetDecodedThreadLocalMode(unsigned Val) { 1598b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao switch (Val) { 1608b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 0: return GlobalVariable::NotThreadLocal; 1618b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao default: // Map unknown non-zero value to general dynamic. 1628b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 1: return GlobalVariable::GeneralDynamicTLSModel; 1638b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 2: return GlobalVariable::LocalDynamicTLSModel; 1648b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 3: return GlobalVariable::InitialExecTLSModel; 1658b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 4: return GlobalVariable::LocalExecTLSModel; 1668b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao } 1678b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao} 1688b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao 169932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic int GetDecodedCastOpcode(unsigned Val) { 170932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Val) { 171932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: return -1; 172932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_TRUNC : return Instruction::Trunc; 173932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_ZEXT : return Instruction::ZExt; 174932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_SEXT : return Instruction::SExt; 175932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPTOUI : return Instruction::FPToUI; 176932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPTOSI : return Instruction::FPToSI; 177932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_UITOFP : return Instruction::UIToFP; 178932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_SITOFP : return Instruction::SIToFP; 179932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPTRUNC : return Instruction::FPTrunc; 180932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPEXT : return Instruction::FPExt; 181932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_PTRTOINT: return Instruction::PtrToInt; 182932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_INTTOPTR: return Instruction::IntToPtr; 183932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_BITCAST : return Instruction::BitCast; 184932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 185932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 186932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic int GetDecodedBinaryOpcode(unsigned Val, Type *Ty) { 187932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Val) { 188932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: return -1; 189932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_ADD: 190932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FAdd : Instruction::Add; 191932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SUB: 192932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FSub : Instruction::Sub; 193932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_MUL: 194932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FMul : Instruction::Mul; 195932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_UDIV: return Instruction::UDiv; 196932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SDIV: 197932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FDiv : Instruction::SDiv; 198932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_UREM: return Instruction::URem; 199932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SREM: 200932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FRem : Instruction::SRem; 201932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SHL: return Instruction::Shl; 202932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_LSHR: return Instruction::LShr; 203932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_ASHR: return Instruction::AShr; 204932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_AND: return Instruction::And; 205932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_OR: return Instruction::Or; 206932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_XOR: return Instruction::Xor; 207932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 208932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 209932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 210932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesnamespace llvm { 211932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesnamespace { 212932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// @brief A class for maintaining the slot number definition 213932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// as a placeholder for the actual definition for forward constants defs. 214932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines class ConstantPlaceHolder : public ConstantExpr { 215932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines void operator=(const ConstantPlaceHolder &); // DO NOT IMPLEMENT 216932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines public: 217932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // allocate space for exactly one operand 218932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines void *operator new(size_t s) { 219932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return User::operator new(s, 1); 220932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 221932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines explicit ConstantPlaceHolder(Type *Ty, LLVMContext& Context) 222932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) { 223932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Op<0>() = UndefValue::get(Type::getInt32Ty(Context)); 224932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 225932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 226932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// @brief Methods to support type inquiry through isa, cast, and dyn_cast. 227932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines //static inline bool classof(const ConstantPlaceHolder *) { return true; } 228932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static bool classof(const Value *V) { 229932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return isa<ConstantExpr>(V) && 230932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1; 231932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 232932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 233932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 234932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// Provide fast operand accessors 235932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines //DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 236932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines }; 237932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 238932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 239932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// FIXME: can we inherit this from ConstantExpr? 240932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinestemplate <> 241932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstruct OperandTraits<ConstantPlaceHolder> : 242932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines public FixedNumOperandTraits<ConstantPlaceHolder, 1> { 243932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines}; 244932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 245932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 246932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 247932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) { 248932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx == size()) { 249932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines push_back(V); 250932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 251932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 252932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 253932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 254932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx+1); 255932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 256932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines WeakVH &OldV = ValuePtrs[Idx]; 257932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OldV == 0) { 258932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV = V; 259932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 260932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 261932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 262932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Handle constants and non-constants (e.g. instrs) differently for 263932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // efficiency. 264932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Constant *PHC = dyn_cast<Constant>(&*OldV)) { 265932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveConstants.push_back(std::make_pair(PHC, Idx)); 266932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV = V; 267932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 268932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If there was a forward reference to this value, replace it. 269932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *PrevVal = OldV; 270932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV->replaceAllUsesWith(V); 271932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete PrevVal; 272932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 273932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 274932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 275932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 276932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesConstant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, 277932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty) { 278932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 279932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx + 1); 280932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 281932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Value *V = ValuePtrs[Idx]) { 282932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(Ty == V->getType() && "Type mismatch in constant table!"); 283932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return cast<Constant>(V); 284932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 285932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 286932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create and return a placeholder, which will later be RAUW'd. 287932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *C = new ConstantPlaceHolder(Ty, Context); 288932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValuePtrs[Idx] = C; 289932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return C; 290932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 291932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 292932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesValue *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty) { 293932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 294932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx + 1); 295932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 296932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Value *V = ValuePtrs[Idx]) { 297932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!"); 298932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V; 299932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 300932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 301932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No type specified, must be invalid reference. 302932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Ty == 0) return 0; 303932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 304932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create and return a placeholder, which will later be RAUW'd. 305932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = new Argument(Ty); 306932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValuePtrs[Idx] = V; 307932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V; 308932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 309932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 310932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ResolveConstantForwardRefs - Once all constants are read, this method bulk 311932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// resolves any forward references. The idea behind this is that we sometimes 312932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// get constants (such as large arrays) which reference *many* forward ref 313932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// constants. Replacing each of these causes a lot of thrashing when 314932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// building/reuniquing the constant. Instead of doing this, we look at all the 315932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// uses and rewrite all the place holders at once for any constant that uses 316932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// a placeholder. 317932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReaderValueList::ResolveConstantForwardRefs() { 318932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Sort the values by-pointer so that they are efficient to look up with a 319932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // binary search. 320932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::sort(ResolveConstants.begin(), ResolveConstants.end()); 321932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 322932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Constant*, 64> NewOps; 323932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 324932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!ResolveConstants.empty()) { 325932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *RealVal = operator[](ResolveConstants.back().second); 326932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Placeholder = ResolveConstants.back().first; 327932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveConstants.pop_back(); 328932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 329932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Loop over all users of the placeholder, updating them to reference the 330932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // new value. If they reference more than one placeholder, update them all 331932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // at once. 332932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!Placeholder->use_empty()) { 333932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value::use_iterator UI = Placeholder->use_begin(); 334932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines User *U = *UI; 335932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 336932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If the using object isn't uniqued, just update the operands. This 337932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // handles instructions and initializers for global variables. 338932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!isa<Constant>(U) || isa<GlobalValue>(U)) { 339932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UI.getUse().set(RealVal); 340932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 341932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 342932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 343932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Otherwise, we have a constant that uses the placeholder. Replace that 344932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // constant with a new constant that has *all* placeholder uses updated. 345932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *UserC = cast<Constant>(U); 346932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (User::op_iterator I = UserC->op_begin(), E = UserC->op_end(); 347932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I != E; ++I) { 348932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *NewOp; 349932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!isa<ConstantPlaceHolder>(*I)) { 350932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Not a placeholder reference. 351932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOp = *I; 352932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (*I == Placeholder) { 353932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Common case is that it just references this one placeholder. 354932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOp = RealVal; 355932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 356932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Otherwise, look up the placeholder in ResolveConstants. 357932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveConstantsTy::iterator It = 358932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::lower_bound(ResolveConstants.begin(), ResolveConstants.end(), 359932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::pair<Constant*, unsigned>(cast<Constant>(*I), 360932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 0)); 361932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(It != ResolveConstants.end() && It->first == *I); 362932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOp = operator[](It->second); 363932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 364932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 365932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOps.push_back(cast<Constant>(NewOp)); 366932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 367932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 368932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Make the new constant. 369932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *NewC; 370932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) { 371932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = ConstantArray::get(UserCA->getType(), NewOps); 372932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) { 373932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = ConstantStruct::get(UserCS->getType(), NewOps); 374932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (isa<ConstantVector>(UserC)) { 375932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = ConstantVector::get(NewOps); 376932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 377932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr."); 378932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = cast<ConstantExpr>(UserC)->getWithOperands(NewOps); 379932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 380932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 381932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UserC->replaceAllUsesWith(NewC); 382932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UserC->destroyConstant(); 383932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOps.clear(); 384932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 385932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 386932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Update all ValueHandles, they should be the only users at this point. 387932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Placeholder->replaceAllUsesWith(RealVal); 388932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete Placeholder; 389932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 390932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 391932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 392932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReaderMDValueList::AssignValue(Value *V, unsigned Idx) { 393932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx == size()) { 394932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines push_back(V); 395932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 396932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 397932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 398932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 399932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx+1); 400932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 401932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines WeakVH &OldV = MDValuePtrs[Idx]; 402932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OldV == 0) { 403932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV = V; 404932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 405932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 406932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 407932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If there was a forward reference to this value, replace it. 408932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDNode *PrevVal = cast<MDNode>(OldV); 409932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV->replaceAllUsesWith(V); 410932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDNode::deleteTemporary(PrevVal); 411932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Deleting PrevVal sets Idx value in MDValuePtrs to null. Set new 412932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // value for Idx. 413932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValuePtrs[Idx] = V; 414932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 415932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 416932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesValue *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { 417932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 418932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx + 1); 419932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 420932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Value *V = MDValuePtrs[Idx]) { 421932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(V->getType()->isMetadataTy() && "Type mismatch in value table!"); 422932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V; 423932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 424932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 425932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create and return a placeholder, which will later be RAUW'd. 426932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = MDNode::getTemporary(Context, ArrayRef<Value*>()); 427932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValuePtrs[Idx] = V; 428932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V; 429932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 430932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 431932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesType *BitcodeReader::getTypeByID(unsigned ID) { 432932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // The type table size is always specified correctly. 433932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ID >= TypeList.size()) 434932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return 0; 435b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 436932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *Ty = TypeList[ID]) 437932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty; 438932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 439932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we have a forward reference, the only possible case is when it is to a 440932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // named struct. Just create a placeholder for now. 441b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines return TypeList[ID] = StructType::create(Context); 442932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 443932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 444932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// FIXME: Remove in LLVM 3.1, only used by ParseOldTypeTable. 445932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesType *BitcodeReader::getTypeByIDOrNull(unsigned ID) { 446932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ID >= TypeList.size()) 447932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList.resize(ID+1); 448b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 449932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return TypeList[ID]; 450932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 451932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 452932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 453932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 454932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// Functions for parsing blocks from the bitcode file 455932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 456932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 457d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 458d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// \brief This fills an AttrBuilder object with the LLVM attributes that have 459d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// been decoded from the given integer. This function must stay in sync with 460d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// 'encodeLLVMAttributesForBitcode'. 461d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesstatic void decodeLLVMAttributesForBitcode(AttrBuilder &B, 462d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines uint64_t EncodedAttrs) { 463d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // FIXME: Remove in 4.0. 464d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 465d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The alignment is stored as a 16-bit raw value from bits 31--16. We shift 466d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // the bits above 31 down by 11 bits. 467d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16; 468d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines assert((!Alignment || isPowerOf2_32(Alignment)) && 469d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines "Alignment must be a power of two."); 470d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 471d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Alignment) 472d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines B.addAlignmentAttr(Alignment); 473d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines B.addRawValue(((EncodedAttrs & (0xfffffULL << 32)) >> 11) | 474d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines (EncodedAttrs & 0xffff)); 475d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 476d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 477d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseAttributeBlock() { 478932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) 479d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 480932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 481932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!MAttributes.empty()) 482d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidMultipleBlocks); 483932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 484932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 485932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 486d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SmallVector<AttributeSet, 8> Attrs; 487932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 488932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records. 489932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 490d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 491932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 492d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 493d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 494d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 495d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 496d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 497d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 498d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 499d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 500d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 501932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 502932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 503932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 504932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 505d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 506932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: ignore. 507932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 508d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::PARAMATTR_CODE_ENTRY_OLD: { // ENTRY: [paramidx0, attr0, ...] 509932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() & 1) 510d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 511932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 512b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 513d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines AttrBuilder B; 514d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines decodeLLVMAttributesForBitcode(B, Record[i+1]); 515d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.push_back(AttributeSet::get(Context, Record[i], B)); 516932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 517932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 518d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines MAttributes.push_back(AttributeSet::get(Context, Attrs)); 519d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.clear(); 520d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 521d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 522d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [attrgrp0, attrgrp1, ...] 523d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (unsigned i = 0, e = Record.size(); i != e; ++i) 524d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.push_back(MAttributeGroups[Record[i]]); 525932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 526b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines MAttributes.push_back(AttributeSet::get(Context, Attrs)); 527932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Attrs.clear(); 528932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 529932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 530932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 531932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 532932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 533932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 534d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 535d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseTypeTable() { 536932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW)) 537d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 538b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 539932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return ParseTypeTableBody(); 540932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 541932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 542d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseTypeTableBody() { 543932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!TypeList.empty()) 544d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidMultipleBlocks); 545932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 546932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 547932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumRecords = 0; 548932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 549932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<64> TypeName; 550b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 551932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this type table. 552932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 553d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 554d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 555d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 556d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 557d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 558d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 559d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 560932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords != TypeList.size()) 561d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 562d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 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)) { 572d724d097437f40a5689464429f948ec41e4a2415Stephen Hines default: 573d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 574932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 575932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // TYPE_CODE_NUMENTRY contains a count of the number of types in the 576932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // type list. This allows us to reserve space. 577932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 578d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 579932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList.resize(Record[0]); 580932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 581932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VOID: // VOID 582932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getVoidTy(Context); 583932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 584d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::TYPE_CODE_HALF: // HALF 585d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ResultTy = Type::getHalfTy(Context); 586d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 587932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FLOAT: // FLOAT 588932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFloatTy(Context); 589932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 590932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_DOUBLE: // DOUBLE 591932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getDoubleTy(Context); 592932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 593932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_FP80: // X86_FP80 594932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_FP80Ty(Context); 595932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 596932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FP128: // FP128 597932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFP128Ty(Context); 598932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 599932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 600932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getPPC_FP128Ty(Context); 601932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 602932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_LABEL: // LABEL 603932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getLabelTy(Context); 604932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 605932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_METADATA: // METADATA 606932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getMetadataTy(Context); 607932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 608932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_MMX: // X86_MMX 609932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_MMXTy(Context); 610932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 611932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 612932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 613d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 614932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 615932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = IntegerType::get(Context, Record[0]); 616932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 617932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 618932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // [pointee type, address space] 619932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 620d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 621932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AddressSpace = 0; 622932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() == 2) 623932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AddressSpace = Record[1]; 624932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = getTypeByID(Record[0]); 625d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (ResultTy == 0) 626d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 627932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = PointerType::get(ResultTy, AddressSpace); 628932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 629932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 6303e88bf7dfe2af63827099a7d5be0173cf4c74f4dStephen Hines case bitc::TYPE_CODE_FUNCTION_OLD: { 631b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // FIXME: attrid is dead, remove it in LLVM 4.0 632932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FUNCTION: [vararg, attrid, retty, paramty x N] 633932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 634d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 635b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Type*, 8> ArgTys; 636932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 3, e = Record.size(); i != e; ++i) { 637932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *T = getTypeByID(Record[i])) 638932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArgTys.push_back(T); 639932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 640932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 641932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 642b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 643932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = getTypeByID(Record[2]); 644932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ResultTy == 0 || ArgTys.size() < Record.size()-3) 645d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 646932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 647932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 648932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 649932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 650932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N] 651932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 652d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 653b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Type*, 8> EltTys; 654932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1, e = Record.size(); i != e; ++i) { 655932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *T = getTypeByID(Record[i])) 656932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EltTys.push_back(T); 657932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 658932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 659932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 660932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (EltTys.size() != Record.size()-1) 661d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 662932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = StructType::get(Context, EltTys, Record[0]); 663932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 664932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 665932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N] 666932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, TypeName)) 667d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 668932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 669932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 670932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N] 671932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 672d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 673b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 674932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords >= TypeList.size()) 675d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 676b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 677932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check to see if this was forward referenced, if so fill in the temp. 678932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 679932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Res) { 680932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Res->setName(TypeName); 681932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NumRecords] = 0; 682932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else // Otherwise, create a new struct. 683bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien Res = StructType::create(Context, TypeName); 684932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeName.clear(); 685b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 686932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Type*, 8> EltTys; 687932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1, e = Record.size(); i != e; ++i) { 688932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *T = getTypeByID(Record[i])) 689932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EltTys.push_back(T); 690932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 691932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 692932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 693932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (EltTys.size() != Record.size()-1) 694d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 695932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Res->setBody(EltTys, Record[0]); 696932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Res; 697932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 698932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 699932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: [] 700932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != 1) 701d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 702932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 703932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords >= TypeList.size()) 704d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 705b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 706932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check to see if this was forward referenced, if so fill in the temp. 707932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 708932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Res) { 709932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Res->setName(TypeName); 710932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NumRecords] = 0; 711932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else // Otherwise, create a new struct with no body. 712bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien Res = StructType::create(Context, TypeName); 713932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeName.clear(); 714932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Res; 715932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 716b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines } 717932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 718932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 719d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 720932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByID(Record[1]))) 721932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = ArrayType::get(ResultTy, Record[0]); 722932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 723d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 724932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 725932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 726932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 727d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 728932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByID(Record[1]))) 729932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = VectorType::get(ResultTy, Record[0]); 730932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 731d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 732932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 733932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 734932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 735932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords >= TypeList.size()) 736d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 737932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(ResultTy && "Didn't read a type?"); 738932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(TypeList[NumRecords] == 0 && "Already read type?"); 739932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NumRecords++] = ResultTy; 740932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 741932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 742932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 743932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// FIXME: Remove in LLVM 3.1 744d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseOldTypeTable() { 745be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (Stream.EnterSubBlock(TYPE_BLOCK_ID_OLD_3_0)) 746d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 747932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 748932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!TypeList.empty()) 749d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 750b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 751b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 752932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // While horrible, we have no good ordering of types in the bc file. Just 753932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // iteratively parse types out of the bc file in multiple passes until we get 754932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // them all. Do this by saving a cursor for the start of the type block. 755932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BitstreamCursor StartOfTypeBlockCursor(Stream); 756b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 757932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumTypesRead = 0; 758b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 759932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 760932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesRestartScan: 761932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextTypeID = 0; 762932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool ReadAnyTypes = false; 763b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 764932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this type table. 765932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 766932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 767932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 768932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID != TypeList.size()) 769d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 770b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 771932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we haven't read all of the types yet, iterate again. 772932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumTypesRead != TypeList.size()) { 773932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we didn't successfully read any types in this pass, then we must 774932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // have an unhandled forward reference. 775932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!ReadAnyTypes) 776d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 777b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 778932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream = StartOfTypeBlockCursor; 779932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines goto RestartScan; 780932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 781b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 782932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 783d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 784d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 785932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 786b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 787932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 788932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 789932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 790932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 791d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 792932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 793932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 794b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 795932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 796932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 797932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 798932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 799b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 800932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 801932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 802932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ResultTy = 0; 803d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 804d724d097437f40a5689464429f948ec41e4a2415Stephen Hines default: return Error(InvalidTYPETable); 805932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 806932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // TYPE_CODE_NUMENTRY contains a count of the number of types in the 807932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // type list. This allows us to reserve space. 808932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 809d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 810932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList.resize(Record[0]); 811932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 812932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VOID: // VOID 813932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getVoidTy(Context); 814932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 815932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FLOAT: // FLOAT 816932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFloatTy(Context); 817932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 818932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_DOUBLE: // DOUBLE 819932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getDoubleTy(Context); 820932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 821932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_FP80: // X86_FP80 822932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_FP80Ty(Context); 823932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 824932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FP128: // FP128 825932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFP128Ty(Context); 826932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 827932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 828932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getPPC_FP128Ty(Context); 829932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 830932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_LABEL: // LABEL 831932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getLabelTy(Context); 832932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 833932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_METADATA: // METADATA 834932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getMetadataTy(Context); 835932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 836932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_MMX: // X86_MMX 837932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_MMXTy(Context); 838932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 839932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 840932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 841d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 842932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = IntegerType::get(Context, Record[0]); 843932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 844932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_OPAQUE: // OPAQUE 845932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID < TypeList.size() && TypeList[NextTypeID] == 0) 846bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien ResultTy = StructType::create(Context, ""); 847932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 848be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien case TYPE_CODE_STRUCT_OLD_3_0: {// STRUCT_OLD 849932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID >= TypeList.size()) break; 850932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we already read it, don't reprocess. 851932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TypeList[NextTypeID] && 852932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines !cast<StructType>(TypeList[NextTypeID])->isOpaque()) 853932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 854932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 855932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Set a type. 856932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TypeList[NextTypeID] == 0) 857bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien TypeList[NextTypeID] = StructType::create(Context, ""); 858932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 859932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Type*> EltTys; 860932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1, e = Record.size(); i != e; ++i) { 861932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *Elt = getTypeByIDOrNull(Record[i])) 862932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EltTys.push_back(Elt); 863932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 864932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 865932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 866932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 867932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (EltTys.size() != Record.size()-1) 868932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; // Not all elements are ready. 869b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 870932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<StructType>(TypeList[NextTypeID])->setBody(EltTys, Record[0]); 871932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = TypeList[NextTypeID]; 872932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NextTypeID] = 0; 873932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 874932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 875932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 876932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // [pointee type, address space] 877932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 878d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 879932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AddressSpace = 0; 880932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() == 2) 881932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AddressSpace = Record[1]; 882932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[0]))) 883932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = PointerType::get(ResultTy, AddressSpace); 884932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 885932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 8863e88bf7dfe2af63827099a7d5be0173cf4c74f4dStephen Hines case bitc::TYPE_CODE_FUNCTION_OLD: { 887932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME: attrid is dead, remove it in LLVM 3.0 888932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FUNCTION: [vararg, attrid, retty, paramty x N] 889932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 890d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 891932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Type*> ArgTys; 892932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 3, e = Record.size(); i != e; ++i) { 893932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *Elt = getTypeByIDOrNull(Record[i])) 894932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArgTys.push_back(Elt); 895932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 896932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 897932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 898932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ArgTys.size()+3 != Record.size()) 899932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; // Something was null. 900932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[2]))) 901932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 902932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 903932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 904932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 905932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 906d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 907932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[1]))) 908932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = ArrayType::get(ResultTy, Record[0]); 909932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 910932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 911932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 912d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 913932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[1]))) 914932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = VectorType::get(ResultTy, Record[0]); 915932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 916932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 917b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 918932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID >= TypeList.size()) 919d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 920b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 921932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ResultTy && TypeList[NextTypeID] == 0) { 922932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++NumTypesRead; 923932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ReadAnyTypes = true; 924b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 925932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NextTypeID] = ResultTy; 926932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 927b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 928932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++NextTypeID; 929932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 930932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 931932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 932932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 933d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseOldTypeSymbolTable() { 934be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (Stream.EnterSubBlock(TYPE_SYMTAB_BLOCK_ID_OLD_3_0)) 935d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 936932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 937932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 938932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 939932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this type table. 940932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string TypeName; 941932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 942932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 943932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 944932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 945d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 946d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 947932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 948932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 949932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 950932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 951932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 952932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 953d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 954932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 955932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 956932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 957932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 958932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 959932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 960932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 961932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 962932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 963932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 964d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 965932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: unknown type. 966932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 967932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TST_CODE_ENTRY: // TST_ENTRY: [typeid, namechar x N] 968932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 1, TypeName)) 969d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 970932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned TypeID = Record[0]; 971932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TypeID >= TypeList.size()) 972d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 973932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 974932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Only apply the type name to a struct type with no name. 975932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (StructType *STy = dyn_cast<StructType>(TypeList[TypeID])) 976bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien if (!STy->isLiteral() && !STy->hasName()) 977932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines STy->setName(TypeName); 978932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeName.clear(); 979932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 980932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 981932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 982932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 983932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 984d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseValueSymbolTable() { 985932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) 986d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 987932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 988932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 989932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 990932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this value table. 991932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<128> ValueName; 992932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 993932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 994932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 995932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 996d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 997d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 998932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 999932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 1000932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 1001932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 1002932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1003d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1004932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1005932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1006932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1007932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 1008932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 1009932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1010932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1011932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1012932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1013932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1014d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 1015932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: unknown type. 1016932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1017932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N] 1018932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 1, ValueName)) 1019d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1020932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ValueID = Record[0]; 1021932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ValueID >= ValueList.size()) 1022d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1023932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = ValueList[ValueID]; 1024932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1025932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V->setName(StringRef(ValueName.data(), ValueName.size())); 1026932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueName.clear(); 1027932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1028932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1029932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VST_CODE_BBENTRY: { 1030932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 1, ValueName)) 1031d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1032932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *BB = getBasicBlock(Record[0]); 1033932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BB == 0) 1034d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1035932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1036932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BB->setName(StringRef(ValueName.data(), ValueName.size())); 1037932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueName.clear(); 1038932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1039932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1040932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1041932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1042932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1043932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1044d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseMetadata() { 1045932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextMDValueNo = MDValueList.size(); 1046932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1047932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) 1048d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1049932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1050932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1051932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1052932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records. 1053932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 1054932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 1055932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 1056932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 1057d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1058d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1059932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1060932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1061932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 1062932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 1063932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 1064932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1065d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1066932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1067932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1068932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1069932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 1070932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 1071932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1072932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1073932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1074932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool IsFunctionLocal = false; 1075932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1076932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1077d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Code = Stream.readRecord(Code, Record); 1078932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Code) { 1079932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: ignore. 1080932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1081932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_NAME: { 1082932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read named of the named metadata. 1083932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NameLength = Record.size(); 1084932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<8> Name; 1085932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Name.resize(NameLength); 1086932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != NameLength; ++i) 1087932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Name[i] = Record[i]; 1088932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1089932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Code = Stream.ReadCode(); 1090932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1091932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // METADATA_NAME is always followed by METADATA_NAMED_NODE. 1092d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned NextBitCode = Stream.readRecord(Code, Record); 1093932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextBitCode == METADATA_NAMED_NODE_2_7) { 1094932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 1095932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (NextBitCode != bitc::METADATA_NAMED_NODE) { 1096932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(!"Invalid Named Metadata record."); (void)NextBitCode; 1097932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1098932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1099932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read named metadata elements. 1100932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1101932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NamedMDNode *NMD = TheModule->getOrInsertNamedMetadata(Name); 1102932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) { 1103932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDNode *MD = dyn_cast<MDNode>(MDValueList.getValueFwdRef(Record[i])); 1104932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (MD == 0) 1105d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1106932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NMD->addOperand(MD); 1107932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1108932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1109932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (LLVM2_7MetadataDetected) { 1110932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.AssignValue(0, NextMDValueNo++); 1111932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1112932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1113932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1114932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case METADATA_FN_NODE_2_7: 1115932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_FN_NODE: 1116932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IsFunctionLocal = true; 1117932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // fall-through 1118932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case METADATA_NODE_2_7: 1119932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_NODE: { 1120932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == METADATA_FN_NODE_2_7 || 1121932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Code == METADATA_NODE_2_7) { 1122932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 1123932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1124932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1125932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() % 2 == 1) 1126d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1127932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1128932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1129932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 8> Elts; 1130932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; i += 2) { 1131932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[i]); 1132d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 1133d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1134932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Ty->isMetadataTy()) 1135932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); 1136932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (!Ty->isVoidTy()) 1137932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty)); 1138932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1139932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(NULL); 1140932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1141932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = MDNode::getWhenValsUnresolved(Context, Elts, IsFunctionLocal); 1142932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IsFunctionLocal = false; 1143932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.AssignValue(V, NextMDValueNo++); 1144932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1145932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1146932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_STRING: { 1147932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned MDStringLength = Record.size(); 1148932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<8> String; 1149932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines String.resize(MDStringLength); 1150932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != MDStringLength; ++i) 1151932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines String[i] = Record[i]; 1152932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = MDString::get(Context, 1153932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StringRef(String.data(), String.size())); 1154932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.AssignValue(V, NextMDValueNo++); 1155932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1156932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1157932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_KIND: { 1158932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned RecordLength = Record.size(); 1159932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty() || RecordLength < 2) 1160d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1161932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<8> Name; 1162932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Name.resize(RecordLength-1); 1163932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Kind = Record[0]; 1164932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1; i != RecordLength; ++i) 1165932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Name[i-1] = Record[i]; 1166b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1167932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NewKind = TheModule->getMDKindID(Name.str()); 1168932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) 1169d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(ConflictingMETADATA_KINDRecords); 1170932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1171932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1172932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1173932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1174932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1175932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1176d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// decodeSignRotatedValue - Decode a signed value stored with the sign bit in 1177932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// the LSB for dense VBR encoding. 1178d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesuint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) { 1179932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((V & 1) == 0) 1180932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V >> 1; 1181932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (V != 1) 1182932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return -(V >> 1); 1183932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // There is no such thing as -0 with integers. "-0" really means MININT. 1184932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return 1ULL << 63; 1185932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1186932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1187932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ResolveGlobalAndAliasInits - Resolve all of the initializers for global 1188932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// values and aliases that we can. 1189d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ResolveGlobalAndAliasInits() { 1190932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist; 1191932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist; 1192932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1193932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInitWorklist.swap(GlobalInits); 1194932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInitWorklist.swap(AliasInits); 1195932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1196932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!GlobalInitWorklist.empty()) { 1197932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ValID = GlobalInitWorklist.back().second; 1198932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ValID >= ValueList.size()) { 1199932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Not ready to resolve this yet, it requires something later in the file. 1200932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInits.push_back(GlobalInitWorklist.back()); 1201932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1202932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 1203932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInitWorklist.back().first->setInitializer(C); 1204932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1205d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(ExpectedConstant); 1206932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1207932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInitWorklist.pop_back(); 1208932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1209932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1210932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!AliasInitWorklist.empty()) { 1211932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ValID = AliasInitWorklist.back().second; 1212932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ValID >= ValueList.size()) { 1213932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInits.push_back(AliasInitWorklist.back()); 1214932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1215932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 1216932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInitWorklist.back().first->setAliasee(C); 1217932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1218d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(ExpectedConstant); 1219932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1220932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInitWorklist.pop_back(); 1221932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1222d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1223932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1224932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1225d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesstatic APInt ReadWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) { 1226d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SmallVector<uint64_t, 8> Words(Vals.size()); 1227d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::transform(Vals.begin(), Vals.end(), Words.begin(), 1228d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitcodeReader::decodeSignRotatedValue); 1229d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1230d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return APInt(TypeBits, Words); 1231d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 1232d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1233d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseConstants() { 1234932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) 1235d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1236932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1237932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1238932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1239932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this value table. 1240932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *CurTy = Type::getInt32Ty(Context); 1241932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextCstNo = ValueList.size(); 1242932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 1243d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 1244d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1245d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 1246d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 1247d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 1248d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1249d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 1250d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (NextCstNo != ValueList.size()) 1251d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidConstantReference); 1252d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1253d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Once all the constants have been read, go through and resolve forward 1254d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // references. 1255d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ValueList.ResolveConstantForwardRefs(); 1256d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1257d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 1258d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 1259932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1260932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1261932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1262932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1263932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1264932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = 0; 1265d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned BitCode = Stream.readRecord(Entry.ID, Record); 1266932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (BitCode) { 1267932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: unknown constant 1268932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_UNDEF: // UNDEF 1269932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); 1270932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1271932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] 1272932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1273d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1274932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[0] >= TypeList.size()) 1275d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1276932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurTy = TypeList[Record[0]]; 1277932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; // Skip the ValueList manipulation. 1278932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_NULL: // NULL 1279932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = Constant::getNullValue(CurTy); 1280932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1281932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_INTEGER: // INTEGER: [intval] 1282932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!CurTy->isIntegerTy() || Record.empty()) 1283d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1284d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0])); 1285932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1286932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval] 1287932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!CurTy->isIntegerTy() || Record.empty()) 1288d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1289932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1290d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt VInt = ReadWideAPInt(Record, 1291d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines cast<IntegerType>(CurTy)->getBitWidth()); 1292d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantInt::get(Context, VInt); 1293d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1294932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1295932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1296932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] 1297932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1298d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1299d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (CurTy->isHalfTy()) 1300d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf, 1301d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(16, (uint16_t)Record[0]))); 1302d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else if (CurTy->isFloatTy()) 1303d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEsingle, 1304d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(32, (uint32_t)Record[0]))); 1305932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurTy->isDoubleTy()) 1306d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEdouble, 1307d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(64, Record[0]))); 1308932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurTy->isX86_FP80Ty()) { 1309932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Bits are not stored the same way as a normal i80 APInt, compensate. 1310932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t Rearrange[2]; 1311932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16); 1312932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Rearrange[1] = Record[0] >> 48; 1313d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::x87DoubleExtended, 1314d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(80, Rearrange))); 1315932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (CurTy->isFP128Ty()) 1316d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEquad, 1317d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(128, Record))); 1318932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurTy->isPPC_FP128Ty()) 1319d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::PPCDoubleDouble, 1320d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(128, Record))); 1321932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1322932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); 1323932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1324932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1325932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1326932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] 1327932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1328d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1329932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1330932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1331b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Constant*, 16> Elts; 1332932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1333932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (StructType *STy = dyn_cast<StructType>(CurTy)) { 1334932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1335932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i], 1336932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines STy->getElementType(i))); 1337932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantStruct::get(STy, Elts); 1338932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) { 1339932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = ATy->getElementType(); 1340932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1341932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 1342932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantArray::get(ATy, Elts); 1343932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) { 1344932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = VTy->getElementType(); 1345932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1346932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 1347932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantVector::get(Elts); 1348932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1349932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); 1350932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1351932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1352932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1353932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_STRING: { // STRING: [values] 1354932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1355d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1356932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1357932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArrayType *ATy = cast<ArrayType>(CurTy); 1358932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = ATy->getElementType(); 1359932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1360932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1361932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Constant*> Elts; 1362932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1363932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ConstantInt::get(EltTy, Record[i])); 1364932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantArray::get(ATy, Elts); 1365932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1366932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1367932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CSTRING: { // CSTRING: [values] 1368932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1369d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1370932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1371932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArrayType *ATy = cast<ArrayType>(CurTy); 1372932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = ATy->getElementType(); 1373932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1374932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1375932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Constant*> Elts; 1376932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1377932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ConstantInt::get(EltTy, Record[i])); 1378932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(Constant::getNullValue(EltTy)); 1379932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantArray::get(ATy, Elts); 1380932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1381932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1382932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] 1383d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1384d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1385932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedBinaryOpcode(Record[0], CurTy); 1386932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc < 0) { 1387932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); // Unknown binop. 1388932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1389932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy); 1390932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy); 1391932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Flags = 0; 1392932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() >= 4) { 1393932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc == Instruction::Add || 1394932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Sub || 1395932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Mul || 1396932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Shl) { 1397932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 1398932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Flags |= OverflowingBinaryOperator::NoSignedWrap; 1399932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 1400932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Flags |= OverflowingBinaryOperator::NoUnsignedWrap; 1401932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (Opc == Instruction::SDiv || 1402932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::UDiv || 1403932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::LShr || 1404932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::AShr) { 1405932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[3] & (1 << bitc::PEO_EXACT)) 1406932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Flags |= SDivOperator::IsExact; 1407932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1408932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1409932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::get(Opc, LHS, RHS, Flags); 1410932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1411932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1412932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1413932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] 1414d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1415d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1416932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedCastOpcode(Record[0]); 1417932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc < 0) { 1418932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); // Unknown cast. 1419932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1420932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[1]); 1421d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!OpTy) 1422d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1423932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); 1424932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getCast(Opc, Op, CurTy); 1425932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1426932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1427932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1428932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_INBOUNDS_GEP: 1429932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands] 1430d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() & 1) 1431d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1432932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Constant*, 16> Elts; 1433932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 1434932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ElTy = getTypeByID(Record[i]); 1435d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!ElTy) 1436d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1437932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); 1438932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1439932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BitCode == bitc::CST_CODE_CE_INBOUNDS_GEP) 1440bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien V = ConstantExpr::getInBoundsGetElementPtr(Elts[0], 1441bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien llvm::ArrayRef<llvm::Constant*>(&Elts[1], Elts.size() - 1)); 1442932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1443bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien V = ConstantExpr::getGetElementPtr(Elts[0], 1444bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien llvm::ArrayRef<llvm::Constant*>(&Elts[1], Elts.size() - 1)); 1445932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1446932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1447932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_SELECT: // CE_SELECT: [opval#, opval#, opval#] 1448d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1449d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1450932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0], 1451932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type::getInt1Ty(Context)), 1452932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.getConstantFwdRef(Record[1],CurTy), 1453932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.getConstantFwdRef(Record[2],CurTy)); 1454932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1455932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval] 1456d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1457d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1458932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = 1459932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1460d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (OpTy == 0) 1461d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1462932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1463932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 1464932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getExtractElement(Op0, Op1); 1465932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1466932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1467932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval] 1468932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1469932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || OpTy == 0) 1470d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1471932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 1472932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[1], 1473932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpTy->getElementType()); 1474932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 1475932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getInsertElement(Op0, Op1, Op2); 1476932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1477932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1478932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] 1479932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1480932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || OpTy == 0) 1481d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1482932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 1483932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); 1484932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 1485932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpTy->getNumElements()); 1486932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy); 1487932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 1488932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1489932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1490932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval] 1491932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *RTy = dyn_cast<VectorType>(CurTy); 1492932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = 1493932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1494932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 4 || RTy == 0 || OpTy == 0) 1495d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1496932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1497932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 1498932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 1499932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines RTy->getNumElements()); 1500932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy); 1501932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 1502932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1503932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1504932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] 1505d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 4) 1506d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1507932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 1508d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (OpTy == 0) 1509d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1510932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1511932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 1512932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1513932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy->isFPOrFPVectorTy()) 1514932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getFCmp(Record[3], Op0, Op1); 1515932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1516932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getICmp(Record[3], Op0, Op1); 1517932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1518932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1519932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_INLINEASM: { 1520d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 2) 1521d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1522932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string AsmStr, ConstrStr; 1523932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool HasSideEffects = Record[0] & 1; 1524932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool IsAlignStack = Record[0] >> 1; 1525932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AsmStrSize = Record[1]; 1526932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (2+AsmStrSize >= Record.size()) 1527d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1528932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ConstStrSize = Record[2+AsmStrSize]; 1529932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (3+AsmStrSize+ConstStrSize > Record.size()) 1530d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1531932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1532932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != AsmStrSize; ++i) 1533932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AsmStr += (char)Record[2+i]; 1534932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != ConstStrSize; ++i) 1535932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ConstrStr += (char)Record[3+AsmStrSize+i]; 1536932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *PTy = cast<PointerType>(CurTy); 1537932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), 1538932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AsmStr, ConstrStr, HasSideEffects, IsAlignStack); 1539932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1540932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1541932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_BLOCKADDRESS:{ 1542d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1543d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1544932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *FnTy = getTypeByID(Record[0]); 1545d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (FnTy == 0) 1546d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1547932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *Fn = 1548932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy)); 1549d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Fn == 0) 1550d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1551b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1552932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalVariable *FwdRef = new GlobalVariable(*Fn->getParent(), 1553932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type::getInt8Ty(Context), 1554932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines false, GlobalValue::InternalLinkage, 1555932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 0, ""); 1556932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BlockAddrFwdRefs[Fn].push_back(std::make_pair(Record[2], FwdRef)); 1557932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = FwdRef; 1558932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1559b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines } 1560932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1561932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1562932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.AssignValue(V, NextCstNo); 1563932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++NextCstNo; 1564932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1565932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1566932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextCstNo != ValueList.size()) 1567d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidConstantReference); 1568932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1569932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 1570d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(ExpectedConstant); 1571932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1572932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Once all the constants have been read, go through and resolve forward 1573932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // references. 1574932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.ResolveConstantForwardRefs(); 1575d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1576932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1577932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1578932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// RememberAndSkipFunctionBody - When we see the block for a function body, 1579932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// remember where it is and then skip it. This lets us lazily deserialize the 1580932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// functions. 1581d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::RememberAndSkipFunctionBody() { 1582932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Get the function we are talking about. 1583932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FunctionsWithBodies.empty()) 1584d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InsufficientFunctionProtos); 1585932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1586932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *Fn = FunctionsWithBodies.back(); 1587932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionsWithBodies.pop_back(); 1588932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1589932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Save the current stream state. 1590932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t CurBit = Stream.GetCurrentBitNo(); 1591932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DeferredFunctionInfo[Fn] = CurBit; 1592932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1593932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Skip over the function block for now. 1594932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1595d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1596d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1597932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1598932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1599d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::GlobalCleanup() { 1600d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Patch the initializers for globals and aliases up. 1601d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ResolveGlobalAndAliasInits(); 1602d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!GlobalInits.empty() || !AliasInits.empty()) 1603d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedGlobalInitializerSet); 1604d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1605d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Look for intrinsic functions which need to be upgraded at some point 1606d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); 1607d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines FI != FE; ++FI) { 1608d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Function *NewFn; 1609d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (UpgradeIntrinsicFunction(FI, NewFn)) 1610d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn)); 1611d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 1612d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1613d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Look for global variables which need to be renamed. 1614d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (Module::global_iterator 1615d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines GI = TheModule->global_begin(), GE = TheModule->global_end(); 1616d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines GI != GE; ++GI) 1617d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines UpgradeGlobalVariable(GI); 1618d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Force deallocation of memory for these vectors to favor the client that 1619d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // want lazy deserialization. 1620d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); 1621d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); 1622d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1623d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 1624d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1625d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseModule(bool Resume) { 1626d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Resume) 1627d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.JumpToBit(NextUnreadBit); 1628d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 1629d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1630932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1631932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1632932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::string> SectionTable; 1633932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::string> GCTable; 1634932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1635932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this module. 1636932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!Stream.AtEndOfStream()) { 1637932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 1638932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 1639932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 1640d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1641932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1642932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Patch the initializers for globals and aliases up. 1643932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveGlobalAndAliasInits(); 1644932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!GlobalInits.empty() || !AliasInits.empty()) 1645d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedGlobalInitializerSet); 1646932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FunctionsWithBodies.empty()) 1647d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InsufficientFunctionProtos); 1648932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1649932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Look for intrinsic functions which need to be upgraded at some point 1650932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); 1651932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FI != FE; ++FI) { 1652932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function* NewFn; 1653932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (UpgradeIntrinsicFunction(FI, NewFn)) 1654932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn)); 1655932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1656932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1657932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Look for global variables which need to be renamed. 1658932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Module::global_iterator 1659932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GI = TheModule->global_begin(), GE = TheModule->global_end(); 1660932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GI != GE; ++GI) 1661932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradeGlobalVariable(GI); 1662932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1663932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Force deallocation of memory for these vectors to favor the client that 1664932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // want lazy deserialization. 1665932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); 1666932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); 1667932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Function*>().swap(FunctionsWithBodies); 1668d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1669932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1670932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1671932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 1672932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadSubBlockID()) { 1673932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Skip unknown content. 1674932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1675d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1676932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1677932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BLOCKINFO_BLOCK_ID: 1678932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockInfoBlock()) 1679d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1680932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1681932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::PARAMATTR_BLOCK_ID: 1682d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseAttributeBlock()) 1683d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1684932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1685932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_BLOCK_ID_NEW: 1686d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseTypeTable()) 1687d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1688932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1689be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien case TYPE_BLOCK_ID_OLD_3_0: 1690d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseOldTypeTable()) 1691d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1692932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1693be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien case TYPE_SYMTAB_BLOCK_ID_OLD_3_0: 1694d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseOldTypeSymbolTable()) 1695d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1696932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1697932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VALUE_SYMTAB_BLOCK_ID: 1698d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseValueSymbolTable()) 1699d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1700d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SeenValueSymbolTable = true; 1701932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1702932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CONSTANTS_BLOCK_ID: 1703d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseConstants()) 1704d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1705d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ResolveGlobalAndAliasInits()) 1706d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1707932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1708932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_BLOCK_ID: 1709d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseMetadata()) 1710d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1711932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1712932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNCTION_BLOCK_ID: 1713932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this is the first function body we've seen, reverse the 1714932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FunctionsWithBodies list. 1715d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!SeenFirstFunctionBody) { 1716932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end()); 1717d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = GlobalCleanup()) 1718d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1719d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SeenFirstFunctionBody = true; 1720932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1721932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1722d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = RememberAndSkipFunctionBody()) 1723d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1724d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // For streaming bitcode, suspend parsing when we reach the function 1725d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // bodies. Subsequent materialization calls will resume it when 1726d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // necessary. For streaming, the function bodies must be at the end of 1727d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // the bitcode. If the bitcode file is old, the symbol table will be 1728d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // at the end instead and will not have been seen yet. In this case, 1729d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // just finish the parse now. 1730d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (LazyStreamer && SeenValueSymbolTable) { 1731d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines NextUnreadBit = Stream.GetCurrentBitNo(); 1732d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1733d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 1734d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 1735932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1736932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1737932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1738932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1739932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1740932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 1741932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 1742932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1743932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1744932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1745932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1746d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 1747932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: break; // Default behavior, ignore unknown content. 1748b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines case bitc::MODULE_CODE_VERSION: { // VERSION: [version#] 1749932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 1750d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1751932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Only version #0 is supported so far. 1752932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[0] != 0) 1753d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 1754932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1755b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines } 1756932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 1757932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1758932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1759d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1760932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule->setTargetTriple(S); 1761932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1762932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1763932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] 1764932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1765932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1766d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1767932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule->setDataLayout(S); 1768932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1769932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1770932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] 1771932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1772932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1773d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1774932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule->setModuleInlineAsm(S); 1775932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1776932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1777932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N] 1778932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1779932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1780d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1781b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // ANDROID: Ignore value, since we never used it anyways. 1782b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // TheModule->addLibrary(S); 1783932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1784932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1785932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] 1786932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1787932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1788d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1789932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SectionTable.push_back(S); 1790932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1791932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1792932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N] 1793932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1794932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1795d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1796932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GCTable.push_back(S); 1797932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1798932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1799932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // GLOBALVAR: [pointer type, isconst, initid, 1800932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // linkage, alignment, section, visibility, threadlocal, 1801932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // unnamed_addr] 1802932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_GLOBALVAR: { 1803932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 6) 1804d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1805932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 1806d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 1807d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1808932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty->isPointerTy()) 1809d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 1810932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); 1811932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Ty = cast<PointerType>(Ty)->getElementType(); 1812932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1813932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool isConstant = Record[1]; 1814932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]); 1815932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Alignment = (1 << Record[4]) >> 1; 1816932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string Section; 1817932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[5]) { 1818932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[5]-1 >= SectionTable.size()) 1819d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 1820932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Section = SectionTable[Record[5]-1]; 1821932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1822932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; 1823932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 6) 1824932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Visibility = GetDecodedVisibility(Record[6]); 18258b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao 18268b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal; 1827932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 7) 18288b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao TLM = GetDecodedThreadLocalMode(Record[7]); 1829932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1830932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool UnnamedAddr = false; 1831932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 8) 1832932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UnnamedAddr = Record[8]; 1833932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1834932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalVariable *NewGV = 1835932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines new GlobalVariable(*TheModule, Ty, isConstant, Linkage, 0, "", 0, 18368b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao TLM, AddressSpace); 1837932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setAlignment(Alignment); 1838932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Section.empty()) 1839932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setSection(Section); 1840932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setVisibility(Visibility); 1841932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setUnnamedAddr(UnnamedAddr); 1842932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1843932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(NewGV); 1844932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1845932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Remember which value to use for the global initializer. 1846932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (unsigned InitID = Record[2]) 1847932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInits.push_back(std::make_pair(NewGV, InitID-1)); 1848932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1849932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1850932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FUNCTION: [type, callingconv, isproto, linkage, paramattr, 1851932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // alignment, section, visibility, gc, unnamed_addr] 1852932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_FUNCTION: { 1853932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 8) 1854d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1855932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 1856d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 1857d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1858932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty->isPointerTy()) 1859d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 1860932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionType *FTy = 1861932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType()); 1862932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy) 1863d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 1864932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1865932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, 1866932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines "", TheModule); 1867932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1868932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setCallingConv(static_cast<CallingConv::ID>(Record[1])); 1869932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool isProto = Record[2]; 1870932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setLinkage(GetDecodedLinkage(Record[3])); 1871932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setAttributes(getAttributes(Record[4])); 1872932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1873932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setAlignment((1 << Record[5]) >> 1); 1874932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[6]) { 1875932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[6]-1 >= SectionTable.size()) 1876d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 1877932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setSection(SectionTable[Record[6]-1]); 1878932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1879932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setVisibility(GetDecodedVisibility(Record[7])); 1880932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 8 && Record[8]) { 1881932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[8]-1 > GCTable.size()) 1882d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 1883932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setGC(GCTable[Record[8]-1].c_str()); 1884932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1885932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool UnnamedAddr = false; 1886932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 9) 1887932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UnnamedAddr = Record[9]; 1888932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setUnnamedAddr(UnnamedAddr); 1889932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(Func); 1890932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1891932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this is a function with a body, remember the prototype we are 1892932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // creating now, so that we can match up the body with them later. 1893d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isProto) { 1894932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionsWithBodies.push_back(Func); 1895d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (LazyStreamer) DeferredFunctionInfo[Func] = 0; 1896d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 1897932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1898932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1899932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // ALIAS: [alias type, aliasee val#, linkage] 1900932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // ALIAS: [alias type, aliasee val#, linkage, visibility] 1901932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_ALIAS: { 1902932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 1903d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1904932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 1905d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 1906d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1907932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty->isPointerTy()) 1908d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 1909932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1910932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]), 1911932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines "", 0, TheModule); 1912932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Old bitcode files didn't have visibility field. 1913932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 3) 1914932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGA->setVisibility(GetDecodedVisibility(Record[3])); 1915932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(NewGA); 1916932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInits.push_back(std::make_pair(NewGA, Record[1])); 1917932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1918932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1919932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// MODULE_CODE_PURGEVALS: [numvals] 1920932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_PURGEVALS: 1921932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Trim down the value list to the specified size. 1922932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1 || Record[0] > ValueList.size()) 1923d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1924932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.shrinkTo(Record[0]); 1925932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1926932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1927932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1928932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1929932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1930d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(BitcodeStreamInvalidSize); 1931932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1932932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1933d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseBitcodeInto(Module *M) { 1934932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule = 0; 1935932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1936d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = InitStream()) 1937d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1938932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1939932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Sniff for the signature. 1940932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.Read(8) != 'B' || 1941932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(8) != 'C' || 1942932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0x0 || 1943932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xC || 1944932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xE || 1945932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xD) 1946d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 1947932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1948932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We expect a number of well-defined blocks, though we don't necessarily 1949932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // need to understand them all. 1950d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 1951d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.AtEndOfStream()) 1952d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1953d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1954d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = 1955d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs); 1956932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1957d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 1958d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 1959d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1960d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 1961d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1962932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1963d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: 1964d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.ID) { 1965d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::BLOCKINFO_BLOCK_ID: 1966d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.ReadBlockInfoBlock()) 1967d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1968d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 1969d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::MODULE_BLOCK_ID: 1970d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Reject multiple MODULE_BLOCK's in a single bitstream. 1971d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (TheModule) 1972d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidMultipleBlocks); 1973d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines TheModule = M; 1974d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseModule(false)) 1975d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1976d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (LazyStreamer) 1977d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1978d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 1979d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines default: 1980d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.SkipBlock()) 1981d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1982d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 1983d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 1984d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 1985d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 1986d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // There should be no records in the top-level of blocks. 1987d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1988d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The ranlib in Xcode 4 will align archive members by appending newlines 1989d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // to the end of them. If this file size is a multiple of 4 but not 8, we 1990d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // have to read and ignore these final 4 bytes :-( 1991d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.getAbbrevIDWidth() == 2 && Entry.ID == 2 && 1992932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a && 1993b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines Stream.AtEndOfStream()) 1994d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1995932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1996d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1997932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1998932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1999932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2000932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2001d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseModuleTriple(std::string &Triple) { 2002932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 2003d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2004932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2005932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 2006932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2007932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this module. 2008d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2009d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 2010932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2011d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2012d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 2013d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2014d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2015d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2016d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2017d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2018d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 2019d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 2020932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2021932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2022932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 2023d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 2024932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: break; // Default behavior, ignore unknown content. 2025932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_VERSION: // VERSION: [version#] 2026932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 2027d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2028932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Only version #0 is supported so far. 2029932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[0] != 0) 2030d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2031932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2032932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 2033932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 2034932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 2035d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2036932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Triple = S; 2037932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2038932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2039932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2040932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 2041932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2042932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2043d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(BitcodeStreamInvalidSize); 2044932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2045932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2046d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseTriple(std::string &Triple) { 2047d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = InitStream()) 2048d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2049932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2050932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Sniff for the signature. 2051932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.Read(8) != 'B' || 2052932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(8) != 'C' || 2053932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0x0 || 2054932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xC || 2055932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xE || 2056932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xD) 2057d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 2058932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2059932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We expect a number of well-defined blocks, though we don't necessarily 2060932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // need to understand them all. 2061d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2062d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advance(); 2063932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2064d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2065d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2066d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2067d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2068d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2069932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2070d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: 2071d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Entry.ID == bitc::MODULE_BLOCK_ID) 2072d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return ParseModuleTriple(Triple); 2073932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2074d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Ignore other sub-blocks. 2075d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Stream.SkipBlock()) 2076d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2077d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 2078d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2079d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2080d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.skipRecord(Entry.ID); 2081d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 2082932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2083932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2084932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2085932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2086932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ParseMetadataAttachment - Parse metadata attachments. 2087d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseMetadataAttachment() { 2088932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) 2089d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2090932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2091932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 2092d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2093d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 2094d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2095d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2096d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 2097d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2098d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2099d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2100d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2101d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2102d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 2103932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2104932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2105d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2106932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a metadata attachment record. 2107932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 2108d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 2109932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: ignore. 2110932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2111932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case METADATA_ATTACHMENT_2_7: 2112932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 2113932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_ATTACHMENT: { 2114932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned RecordLength = Record.size(); 2115932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty() || (RecordLength - 1) % 2 == 1) 2116d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2117932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Instruction *Inst = InstructionList[Record[0]]; 2118932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1; i != RecordLength; i = i+2) { 2119932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Kind = Record[i]; 2120932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DenseMap<unsigned, unsigned>::iterator I = 2121932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDKindMap.find(Kind); 2122932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I == MDKindMap.end()) 2123d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 2124932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Node = MDValueList.getValueFwdRef(Record[i+1]); 2125932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Inst->setMetadata(I->second, cast<MDNode>(Node)); 2126932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2127932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2128932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2129932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2130932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2131932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2132932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2133932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ParseFunctionBody - Lazily parse the specified function body block. 2134d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseFunctionBody(Function *F) { 2135932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) 2136d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2137932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2138932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.clear(); 2139932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ModuleValueListSize = ValueList.size(); 2140932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ModuleMDValueListSize = MDValueList.size(); 2141932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2142932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Add all the function arguments to the value table. 2143932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) 2144932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(I); 2145932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2146932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextValueNo = ValueList.size(); 2147932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *CurBB = 0; 2148932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned CurBBNo = 0; 2149932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2150932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DebugLoc LastLoc; 2151b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2152932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records. 2153932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 2154932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 2155932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 2156932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 2157932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 2158d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2159932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2160932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2161932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2162932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 2163932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadSubBlockID()) { 2164932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Skip unknown content. 2165932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 2166d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2167932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2168932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CONSTANTS_BLOCK_ID: 2169d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseConstants()) 2170d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2171932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NextValueNo = ValueList.size(); 2172932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2173932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VALUE_SYMTAB_BLOCK_ID: 2174d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseValueSymbolTable()) 2175d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2176932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2177932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_ATTACHMENT_ID: 2178d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseMetadataAttachment()) 2179d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2180932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2181932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_BLOCK_ID: 2182d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseMetadata()) 2183d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2184932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2185932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2186932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2187932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2188932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2189932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 2190932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 2191932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2192932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2193932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2194932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 2195932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 2196932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Instruction *I = 0; 2197d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned BitCode = Stream.readRecord(Code, Record); 2198932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (BitCode) { 2199932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: reject 2200d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 2201932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks] 2202932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1 || Record[0] == 0) 2203d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2204932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create all the basic blocks for the function. 2205932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionBBs.resize(Record[0]); 2206932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) 2207932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionBBs[i] = BasicBlock::Create(Context, "", F); 2208932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurBB = FunctionBBs[0]; 2209932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2210b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2211932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN 2212932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // This record indicates that the last instruction is at the same 2213932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // location as the previous instruction with a location. 2214932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; 2215b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2216932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Get the last instruction emitted. 2217932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CurBB && !CurBB->empty()) 2218932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &CurBB->back(); 2219932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurBBNo && FunctionBBs[CurBBNo-1] && 2220932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines !FunctionBBs[CurBBNo-1]->empty()) 2221932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &FunctionBBs[CurBBNo-1]->back(); 2222b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2223d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (I == 0) 2224d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2225932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->setDebugLoc(LastLoc); 2226932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; 2227932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2228b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2229932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_DEBUG_LOC_2_7: 2230932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 2231932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia] 2232932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; // Get the last instruction emitted. 2233932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CurBB && !CurBB->empty()) 2234932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &CurBB->back(); 2235932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurBBNo && FunctionBBs[CurBBNo-1] && 2236932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines !FunctionBBs[CurBBNo-1]->empty()) 2237932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &FunctionBBs[CurBBNo-1]->back(); 2238932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I == 0 || Record.size() < 4) 2239d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2240b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2241932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Line = Record[0], Col = Record[1]; 2242932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ScopeID = Record[2], IAID = Record[3]; 2243b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2244932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDNode *Scope = 0, *IA = 0; 2245932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ScopeID) Scope = cast<MDNode>(MDValueList.getValueFwdRef(ScopeID-1)); 2246932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (IAID) IA = cast<MDNode>(MDValueList.getValueFwdRef(IAID-1)); 2247932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LastLoc = DebugLoc::get(Line, Col, Scope, IA); 2248932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->setDebugLoc(LastLoc); 2249932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; 2250932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2251932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2252932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2253932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode] 2254932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2255932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *LHS, *RHS; 2256932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 2257932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, LHS->getType(), RHS) || 2258932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+1 > Record.size()) 2259d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2260932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2261932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); 2262d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Opc == -1) 2263d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2264932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); 2265932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2266932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpNum < Record.size()) { 2267932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc == Instruction::Add || 2268932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Sub || 2269932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Mul || 2270932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Shl) { 2271932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 2272932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<BinaryOperator>(I)->setHasNoSignedWrap(true); 2273932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 2274932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true); 2275932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (Opc == Instruction::SDiv || 2276932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::UDiv || 2277932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::LShr || 2278932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::AShr) { 2279932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[OpNum] & (1 << bitc::PEO_EXACT)) 2280932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<BinaryOperator>(I)->setIsExact(true); 2281932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2282932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2283932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2284932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2285932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc] 2286932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2287932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2288932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2289932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) 2290d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2291932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2292932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ResTy = getTypeByID(Record[OpNum]); 2293932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedCastOpcode(Record[OpNum+1]); 2294932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc == -1 || ResTy == 0) 2295d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2296932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy); 2297932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2298932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2299932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2300932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INBOUNDS_GEP: 2301932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands] 2302932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2303932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *BasePtr; 2304932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) 2305d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2306932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2307932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 16> GEPIdx; 2308932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (OpNum != Record.size()) { 2309932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2310932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2311d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2312932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GEPIdx.push_back(Op); 2313932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2314932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2315bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien I = GetElementPtrInst::Create(BasePtr, GEPIdx); 2316932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2317932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP) 2318932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<GetElementPtrInst>(I)->setIsInBounds(true); 2319932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2320932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2321932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2322932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_EXTRACTVAL: { 2323932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // EXTRACTVAL: [opty, opval, n x indices] 2324932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2325932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Agg; 2326932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2327d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2328932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2329932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<unsigned, 4> EXTRACTVALIdx; 2330932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned RecSize = Record.size(); 2331932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum != RecSize; ++OpNum) { 2332932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t Index = Record[OpNum]; 2333932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((unsigned)Index != Index) 2334d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 2335932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EXTRACTVALIdx.push_back((unsigned)Index); 2336932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2337932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2338932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ExtractValueInst::Create(Agg, EXTRACTVALIdx); 2339932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2340932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2341932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2342932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2343932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INSERTVAL: { 2344932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // INSERTVAL: [opty, opval, opty, opval, n x indices] 2345932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2346932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Agg; 2347932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2348d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2349932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Val; 2350932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Val)) 2351d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2352932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2353932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<unsigned, 4> INSERTVALIdx; 2354932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned RecSize = Record.size(); 2355932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum != RecSize; ++OpNum) { 2356932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t Index = Record[OpNum]; 2357932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((unsigned)Index != Index) 2358d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 2359932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines INSERTVALIdx.push_back((unsigned)Index); 2360932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2361932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2362932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = InsertValueInst::Create(Agg, Val, INSERTVALIdx); 2363932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2364932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2365932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2366932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2367932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval] 2368932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // obsolete form of select 2369932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // handles select i1 ... in old bitcode 2370932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2371932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *TrueVal, *FalseVal, *Cond; 2372932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 2373932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 2374932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Type::getInt1Ty(Context), Cond)) 2375d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 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_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred] 2383932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // new form of select 2384932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // handles select i1 or select [N x i1] 2385932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2386932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *TrueVal, *FalseVal, *Cond; 2387932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 2388932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 2389932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValueTypePair(Record, OpNum, NextValueNo, Cond)) 2390d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2391932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2392932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // select condition can be either i1 or [N x i1] 2393932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (VectorType* vector_type = 2394932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast<VectorType>(Cond->getType())) { 2395932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // expect <n x i1> 2396932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (vector_type->getElementType() != Type::getInt1Ty(Context)) 2397d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 2398932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2399932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // expect i1 2400932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Cond->getType() != Type::getInt1Ty(Context)) 2401d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 2402932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2403932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2404932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = SelectInst::Create(Cond, TrueVal, FalseVal); 2405932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2406932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2407932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2408932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2409932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval] 2410932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2411932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Vec, *Idx; 2412932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 2413932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 2414d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2415932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ExtractElementInst::Create(Vec, Idx); 2416932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2417932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2418932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2419932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2420932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval] 2421932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2422932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Vec, *Elt, *Idx; 2423932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 2424932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, 2425932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<VectorType>(Vec->getType())->getElementType(), Elt) || 2426932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 2427d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2428932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = InsertElementInst::Create(Vec, Elt, Idx); 2429932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2430932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2431932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2432932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2433932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval] 2434932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2435932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Vec1, *Vec2, *Mask; 2436932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) || 2437932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Vec1->getType(), Vec2)) 2438d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2439932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2440932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) 2441d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2442932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new ShuffleVectorInst(Vec1, Vec2, Mask); 2443932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2444932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2445932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2446932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2447932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred] 2448932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Old form of ICmp/FCmp returning bool 2449932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were 2450932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // both legal on vectors but had different behaviour. 2451932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred] 2452932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FCmp/ICmp returning bool or vector of bool 2453932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2454932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2455932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *LHS, *RHS; 2456932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 2457932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, LHS->getType(), RHS) || 2458932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+1 != Record.size()) 2459d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2460932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2461932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (LHS->getType()->isFPOrFPVectorTy()) 2462932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); 2463932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 2464932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS); 2465932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2466932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2467932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2468932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2469932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_GETRESULT_2_7: { 2470932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != 2) { 2471d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2472932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2473932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2474932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2475932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValueTypePair(Record, OpNum, NextValueNo, Op); 2476932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Index = Record[1]; 2477932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ExtractValueInst::Create(Op, Index); 2478932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2479932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2480932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2481932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2482932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>] 2483932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines { 2484932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 2485932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Size == 0) { 2486932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ReturnInst::Create(Context); 2487932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2488932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2489932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2490932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2491932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2492932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op = NULL; 2493932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2494d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2495932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpNum != Record.size()) 2496d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2497932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2498932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ReturnInst::Create(Context, Op); 2499932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2500932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2501932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2502932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] 2503932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != 1 && Record.size() != 3) 2504d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2505932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *TrueDest = getBasicBlock(Record[0]); 2506932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TrueDest == 0) 2507d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2508932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2509932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() == 1) { 2510932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = BranchInst::Create(TrueDest); 2511932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2512932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2513932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else { 2514932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *FalseDest = getBasicBlock(Record[1]); 2515932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Cond = getFnValueByID(Record[2], Type::getInt1Ty(Context)); 2516932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FalseDest == 0 || Cond == 0) 2517d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2518932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = BranchInst::Create(TrueDest, FalseDest, Cond); 2519932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2520932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2521932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2522932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2523932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...] 2524932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || (Record.size() & 1) == 0) 2525d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2526932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 2527932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Cond = getFnValueByID(Record[1], OpTy); 2528932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *Default = getBasicBlock(Record[2]); 2529932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy == 0 || Cond == 0 || Default == 0) 2530d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2531932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumCases = (Record.size()-3)/2; 2532932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); 2533932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(SI); 2534932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = NumCases; i != e; ++i) { 2535932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ConstantInt *CaseVal = 2536932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy)); 2537932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); 2538932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CaseVal == 0 || DestBB == 0) { 2539932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete SI; 2540d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2541932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2542932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SI->addCase(CaseVal, DestBB); 2543932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2544932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = SI; 2545932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2546932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2547932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] 2548932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 2549d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2550932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 2551932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Address = getFnValueByID(Record[1], OpTy); 2552932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy == 0 || Address == 0) 2553d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2554932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumDests = Record.size()-2; 2555932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); 2556932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(IBI); 2557932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = NumDests; i != e; ++i) { 2558932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) { 2559932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IBI->addDestination(DestBB); 2560932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2561932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete IBI; 2562d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2563932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2564932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2565932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = IBI; 2566932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2567932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2568b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2569932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INVOKE: { 2570932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] 2571d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 4) 2572d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2573b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines AttributeSet PAL = getAttributes(Record[0]); 2574932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned CCInfo = Record[1]; 2575932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *NormalBB = getBasicBlock(Record[2]); 2576932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *UnwindBB = getBasicBlock(Record[3]); 2577932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2578932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 4; 2579932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Callee; 2580932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 2581d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2582932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2583932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); 2584932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionType *FTy = !CalleeTy ? 0 : 2585932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast<FunctionType>(CalleeTy->getElementType()); 2586932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2587932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check that the right number of fixed parameters are here. 2588932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FTy == 0 || NormalBB == 0 || UnwindBB == 0 || 2589932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.size() < OpNum+FTy->getNumParams()) 2590d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2591932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2592932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 16> Ops; 2593932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 2594932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Ops.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 2595d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Ops.back() == 0) 2596d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2597932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2598932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2599932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy->isVarArg()) { 2600932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != OpNum) 2601d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2602932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2603932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read type/value pairs for varargs params. 2604932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (OpNum != Record.size()) { 2605932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2606932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2607d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2608932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Ops.push_back(Op); 2609932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2610932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2611932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2612932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops); 2613932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2614932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<InvokeInst>(I)->setCallingConv( 2615932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static_cast<CallingConv::ID>(CCInfo)); 2616932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<InvokeInst>(I)->setAttributes(PAL); 2617932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2618932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2619c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao case FUNC_CODE_INST_UNWIND_2_7: { // UNWIND_OLD 2620c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao // 'unwind' instruction has been removed in LLVM 3.1 2621c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao // Replace 'unwind' with 'landingpad' and 'resume'. 2622c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Type *ExnTy = StructType::get(Type::getInt8PtrTy(Context), 2623c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Type::getInt32Ty(Context), NULL); 2624c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Constant *PersFn = 2625c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao F->getParent()-> 2626c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao getOrInsertFunction("__gcc_personality_v0", 2627c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao FunctionType::get(Type::getInt32Ty(Context), true)); 2628c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 2629c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao LandingPadInst *LP = LandingPadInst::Create(ExnTy, PersFn, 1); 2630c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao LP->setCleanup(true); 2631c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 2632c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao CurBB->getInstList().push_back(LP); 2633c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao I = ResumeInst::Create(LP); 2634932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2635932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2636c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao } 2637932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE 2638932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new UnreachableInst(Context); 2639932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2640932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2641932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...] 2642932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1 || ((Record.size()-1)&1)) 2643d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2644932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 2645d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 2646d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2647932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2648932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2); 2649932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(PN); 2650932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2651932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) { 2652932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = getFnValueByID(Record[1+i], Ty); 2653932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *BB = getBasicBlock(Record[2+i]); 2654d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!V || !BB) 2655d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2656932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PN->addIncoming(V, BB); 2657932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2658932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = PN; 2659932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2660932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2661932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2662932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_MALLOC_2_7: { // MALLOC: [instty, op, align] 2663932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Autoupgrade malloc instruction to malloc call. 2664932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME: Remove in LLVM 3.0. 2665932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) { 2666d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2667932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2668932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *Ty = 2669932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<PointerType>(getTypeByID(Record[0])); 2670932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Size = getFnValueByID(Record[1], Type::getInt32Ty(Context)); 2671d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty || !Size) 2672d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2673d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!CurBB) 2674d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidInstructionWithNoBB); 2675932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Int32Ty = IntegerType::getInt32Ty(CurBB->getContext()); 2676932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *AllocSize = ConstantExpr::getSizeOf(Ty->getElementType()); 2677932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, Int32Ty); 2678932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CallInst::CreateMalloc(CurBB, Int32Ty, Ty->getElementType(), 2679932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AllocSize, Size, NULL); 2680932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2681932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2682932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2683932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_FREE_2_7: { // FREE: [op, opty] 2684932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2685932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2686932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2687932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum != Record.size()) { 2688d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2689932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2690d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!CurBB) 2691d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidInstructionWithNoBB); 2692932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CallInst::CreateFree(Op, CurBB); 2693932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2694932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2695932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2696932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2697932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align] 2698932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // For backward compatibility, tolerate a lack of an opty, and use i32. 2699932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Remove this in LLVM 3.0. 2700932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || Record.size() > 4) { 2701d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2702932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2703932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2704932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *Ty = 2705932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<PointerType>(getTypeByID(Record[OpNum++])); 2706932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = Record.size() == 4 ? getTypeByID(Record[OpNum++]) : 2707932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type::getInt32Ty(Context); 2708932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Size = getFnValueByID(Record[OpNum++], OpTy); 2709932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Align = Record[OpNum++]; 2710d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty || !Size) 2711d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2712932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); 2713932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2714932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2715932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2716932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol] 2717932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2718932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2719932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2720932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) 2721d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2722932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2723932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2724932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2725932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2726932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2727932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_STORE: { // STORE2:[ptrty, ptr, val, align, vol] 2728932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2729932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Val, *Ptr; 2730932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 2731932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, 2732932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<PointerType>(Ptr->getType())->getElementType(), Val) || 2733932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) 2734d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2735932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2736932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2737932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2738932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2739932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2740932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_STORE_2_7: { 2741932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2742932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Val, *Ptr; 2743932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Val) || 2744932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, 2745932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType::getUnqual(Val->getType()), Ptr)|| 2746932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) { 2747d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2748932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2749932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2750932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2751932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2752932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2753932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_CALL_2_7: 2754932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 2755932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CALL: { 2756932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] 2757932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 2758d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2759932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2760b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines AttributeSet PAL = getAttributes(Record[0]); 2761932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned CCInfo = Record[1]; 2762932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2763932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 2; 2764932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Callee; 2765932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 2766d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2767932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2768932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); 2769932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionType *FTy = 0; 2770932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType()); 2771932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy || Record.size() < FTy->getNumParams()+OpNum) 2772d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2773932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2774932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 16> Args; 2775932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read the fixed params. 2776932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 2777932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FTy->getParamType(i)->isLabelTy()) 2778932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Args.push_back(getBasicBlock(Record[OpNum])); 2779932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 2780932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Args.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 2781d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Args.back() == 0) 2782d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2783932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2784932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2785932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read type/value pairs for varargs params. 2786932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy->isVarArg()) { 2787932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpNum != Record.size()) 2788d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2789932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2790932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (OpNum != Record.size()) { 2791932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2792932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2793d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2794932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Args.push_back(Op); 2795932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2796932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2797932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2798932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CallInst::Create(Callee, Args); 2799932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2800932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<CallInst>(I)->setCallingConv( 2801932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static_cast<CallingConv::ID>(CCInfo>>1)); 2802932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<CallInst>(I)->setTailCall(CCInfo & 1); 2803932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<CallInst>(I)->setAttributes(PAL); 2804932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2805932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2806932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] 2807932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 2808d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2809932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 2810932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op = getFnValueByID(Record[1], OpTy); 2811932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ResTy = getTypeByID(Record[2]); 2812932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!OpTy || !Op || !ResTy) 2813d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2814932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new VAArgInst(Op, ResTy); 2815932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2816932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2817932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2818932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2819932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2820932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Add instruction to end of current BB. If there is no current BB, reject 2821932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // this file. 2822932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CurBB == 0) { 2823932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete I; 2824d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidInstructionWithNoBB); 2825932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2826932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurBB->getInstList().push_back(I); 2827932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2828932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this was a terminator instruction, move to the next block. 2829932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (isa<TerminatorInst>(I)) { 2830932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++CurBBNo; 2831932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0; 2832932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2833932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2834932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Non-void values get registered in the value table for future use. 2835932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I && !I->getType()->isVoidTy()) 2836932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.AssignValue(I, NextValueNo++); 2837932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2838932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2839932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check the function list for unresolved values. 2840932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Argument *A = dyn_cast<Argument>(ValueList.back())) { 2841932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (A->getParent() == 0) { 2842932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We found at least one unresolved value. Nuke them all to avoid leaks. 2843932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){ 2844932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((A = dyn_cast<Argument>(ValueList[i])) && A->getParent() == 0) { 2845932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines A->replaceAllUsesWith(UndefValue::get(A->getType())); 2846932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete A; 2847932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2848932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2849d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(NeverResolvedValueFoundInFunction); 2850932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2851932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2852932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2853932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME: Check for unresolved forward-declared metadata references 2854932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // and clean up leaks. 2855932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2856932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // See if anything took the address of blocks in this function. If so, 2857932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // resolve them now. 2858932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DenseMap<Function*, std::vector<BlockAddrRefTy> >::iterator BAFRI = 2859932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BlockAddrFwdRefs.find(F); 2860932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BAFRI != BlockAddrFwdRefs.end()) { 2861932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<BlockAddrRefTy> &RefList = BAFRI->second; 2862932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = RefList.size(); i != e; ++i) { 2863932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned BlockIdx = RefList[i].first; 2864932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BlockIdx >= FunctionBBs.size()) 2865d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 2866b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2867932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalVariable *FwdRef = RefList[i].second; 2868932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx])); 2869932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FwdRef->eraseFromParent(); 2870932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2871b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2872932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BlockAddrFwdRefs.erase(BAFRI); 2873932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2874932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2875932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NewMDValueListSize = MDValueList.size(); 2876932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Trim the value list down to the size it was before we parsed this function. 2877932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.shrinkTo(ModuleValueListSize); 2878932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.shrinkTo(ModuleMDValueListSize); 2879932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2880932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (LLVM2_7MetadataDetected) { 2881932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.resize(NewMDValueListSize); 2882932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2883932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2884932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<BasicBlock*>().swap(FunctionBBs); 2885d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2886932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2887932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2888932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 2889932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// GVMaterializer implementation 2890932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 2891932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2892932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2893932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::isMaterializable(const GlobalValue *GV) const { 2894932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (const Function *F = dyn_cast<Function>(GV)) { 2895932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return F->isDeclaration() && 2896932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DeferredFunctionInfo.count(const_cast<Function*>(F)); 2897932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2898932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 2899932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2900932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2901d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::Materialize(GlobalValue *GV) { 2902932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *F = dyn_cast<Function>(GV); 2903932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If it's not a function or is already material, ignore the request. 2904d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!F || !F->isMaterializable()) 2905d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2906932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2907932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F); 2908932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!"); 2909932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2910932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Move the bit stream to the saved position of the deferred function body. 2911932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.JumpToBit(DFII->second); 2912932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2913d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseFunctionBody(F)) 2914d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2915932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2916932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Upgrade any old intrinsic calls in the function. 2917932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(), 2918932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines E = UpgradedIntrinsics.end(); I != E; ++I) { 2919932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I->first != I->second) { 2920932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Value::use_iterator UI = I->first->use_begin(), 2921932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UE = I->first->use_end(); UI != UE; ) { 2922932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 2923932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradeIntrinsicCall(CI, I->second); 2924932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2925932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2926932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2927932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2928d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2929932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2930932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2931932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::isDematerializable(const GlobalValue *GV) const { 2932932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines const Function *F = dyn_cast<Function>(GV); 2933932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!F || F->isDeclaration()) 2934932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 2935932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return DeferredFunctionInfo.count(const_cast<Function*>(F)); 2936932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2937932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2938932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReader::Dematerialize(GlobalValue *GV) { 2939932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *F = dyn_cast<Function>(GV); 2940932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this function isn't dematerializable, this is a noop. 2941932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!F || !isDematerializable(F)) 2942932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 2943932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2944932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(DeferredFunctionInfo.count(F) && "No info to read function later?"); 2945932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2946932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Just forget the function body, we can remat it later. 2947932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines F->deleteBody(); 2948932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2949932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2950932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2951d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::MaterializeModule(Module *M) { 2952932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(M == TheModule && 2953932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines "Can only Materialize the Module this BitcodeReader is attached to."); 2954932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Iterate over the module, deserializing any functions that are still on 2955932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // disk. 2956932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Module::iterator F = TheModule->begin(), E = TheModule->end(); 2957d724d097437f40a5689464429f948ec41e4a2415Stephen Hines F != E; ++F) { 2958d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (F->isMaterializable()) { 2959d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = Materialize(F)) 2960d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2961d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 2962d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 2963932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2964932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Upgrade any intrinsic calls that slipped through (should not happen!) and 2965932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // delete the old functions to clean up. We can't do this unless the entire 2966932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // module is materialized because there could always be another function body 2967932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // with calls to the old function. 2968932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (std::vector<std::pair<Function*, Function*> >::iterator I = 2969932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) { 2970932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I->first != I->second) { 2971932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Value::use_iterator UI = I->first->use_begin(), 2972932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UE = I->first->use_end(); UI != UE; ) { 2973932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 2974932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradeIntrinsicCall(CI, I->second); 2975932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2976932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!I->first->use_empty()) 2977932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->first->replaceAllUsesWith(I->second); 2978932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->first->eraseFromParent(); 2979932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2980932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2981932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics); 2982932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2983932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check debug info intrinsics. 2984932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CheckDebugInfoIntrinsics(TheModule); 2985932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2986d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2987932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2988932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2989d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::InitStream() { 2990d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (LazyStreamer) 2991d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return InitLazyStream(); 2992d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return InitStreamFromBuffer(); 2993d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 2994d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2995d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::InitStreamFromBuffer() { 2996d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *BufPtr = (const unsigned char*)Buffer->getBufferStart(); 2997d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); 2998d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2999d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Buffer->getBufferSize() & 3) { 3000d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isRawBitcode(BufPtr, BufEnd) && !isBitcodeWrapper(BufPtr, BufEnd)) 3001d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 3002d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else 3003d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(BitcodeStreamInvalidSize); 3004d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 3005d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3006d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // If we have a wrapper header, parse it and ignore the non-bc file contents. 3007d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The magic number is 0x0B17C0DE stored in little endian. 3008d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (isBitcodeWrapper(BufPtr, BufEnd)) 3009d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true)) 3010d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeWrapperHeader); 3011d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3012d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamFile.reset(new BitstreamReader(BufPtr, BufEnd)); 3013d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.init(*StreamFile); 3014d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3015d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 3016d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 3017d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3018d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::InitLazyStream() { 3019d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Check and strip off the bitcode wrapper; BitstreamReader expects never to 3020d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // see it. 3021d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamingMemoryObject *Bytes = new StreamingMemoryObject(LazyStreamer); 3022d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamFile.reset(new BitstreamReader(Bytes)); 3023d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.init(*StreamFile); 3024d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3025d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned char buf[16]; 302688f8c52abea50f411c3774c935a6a1e04d17c182Stephen Hines if (Bytes->readBytes(0, 16, buf) == -1) 3027d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(BitcodeStreamInvalidSize); 3028d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3029d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isBitcode(buf, buf + 16)) 3030d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 3031d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3032d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (isBitcodeWrapper(buf, buf + 4)) { 3033d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *bitcodeStart = buf; 3034d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *bitcodeEnd = buf + 16; 3035d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false); 3036d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Bytes->dropLeadingBytes(bitcodeStart - buf); 3037d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Bytes->setKnownObjectSize(bitcodeEnd - bitcodeStart); 3038d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 3039d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 3040d724d097437f40a5689464429f948ec41e4a2415Stephen Hines} 3041d724d097437f40a5689464429f948ec41e4a2415Stephen Hines 3042d724d097437f40a5689464429f948ec41e4a2415Stephen Hinesnamespace { 3043d724d097437f40a5689464429f948ec41e4a2415Stephen Hinesclass BitcodeErrorCategoryType : public _do_message { 3044d724d097437f40a5689464429f948ec41e4a2415Stephen Hines const char *name() const LLVM_OVERRIDE { 3045d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "llvm.bitcode"; 3046d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3047d724d097437f40a5689464429f948ec41e4a2415Stephen Hines std::string message(int IE) const LLVM_OVERRIDE { 3048d724d097437f40a5689464429f948ec41e4a2415Stephen Hines BitcodeReader::ErrorType E = static_cast<BitcodeReader::ErrorType>(IE); 3049d724d097437f40a5689464429f948ec41e4a2415Stephen Hines switch (E) { 3050d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::BitcodeStreamInvalidSize: 3051d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Bitcode stream length should be >= 16 bytes and a multiple of 4"; 3052d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::ConflictingMETADATA_KINDRecords: 3053d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Conflicting METADATA_KIND records"; 3054d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::CouldNotFindFunctionInStream: 3055d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Could not find function in stream"; 3056d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::ExpectedConstant: 3057d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Expected a constant"; 3058d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InsufficientFunctionProtos: 3059d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Insufficient function protos"; 3060d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidBitcodeSignature: 3061d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid bitcode signature"; 3062d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidBitcodeWrapperHeader: 3063d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid bitcode wrapper header"; 3064d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidConstantReference: 3065d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid ronstant reference"; 3066d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidID: 3067d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid ID"; 3068d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidInstructionWithNoBB: 3069d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid instruction with no BB"; 3070d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidRecord: 3071d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid record"; 3072d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidTypeForValue: 3073d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid type for value"; 3074d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidTYPETable: 3075d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid TYPE table"; 3076d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidType: 3077d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid type"; 3078d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::MalformedBlock: 3079d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Malformed block"; 3080d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::MalformedGlobalInitializerSet: 3081d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Malformed global initializer set"; 3082d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidMultipleBlocks: 3083d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid multiple blocks"; 3084d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::NeverResolvedValueFoundInFunction: 3085d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Never resolved value found in function"; 3086d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidValue: 3087d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid value"; 3088d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3089d724d097437f40a5689464429f948ec41e4a2415Stephen Hines llvm_unreachable("Unknown error type!"); 3090d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3091d724d097437f40a5689464429f948ec41e4a2415Stephen Hines}; 3092d724d097437f40a5689464429f948ec41e4a2415Stephen Hines} 3093d724d097437f40a5689464429f948ec41e4a2415Stephen Hines 3094d724d097437f40a5689464429f948ec41e4a2415Stephen Hinesconst error_category &BitcodeReader::BitcodeErrorCategory() { 3095d724d097437f40a5689464429f948ec41e4a2415Stephen Hines static BitcodeErrorCategoryType O; 3096d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return O; 3097d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 3098932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3099932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 3100932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// External interface 3101932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 3102932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3103932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// getLazyBitcodeModule - lazy function-at-a-time loading from a file. 3104932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// 3105932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesModule *llvm_2_7::getLazyBitcodeModule(MemoryBuffer *Buffer, 3106932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVMContext& Context, 3107932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string *ErrMsg) { 3108932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Module *M = new Module(Buffer->getBufferIdentifier(), Context); 3109932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BitcodeReader *R = new BitcodeReader(Buffer, Context); 3110932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines M->setMaterializer(R); 3111d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = R->ParseBitcodeInto(M)) { 3112932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ErrMsg) 3113d724d097437f40a5689464429f948ec41e4a2415Stephen Hines *ErrMsg = EC.message(); 3114932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3115932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete M; // Also deletes R. 3116932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return 0; 3117932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3118932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Have the BitcodeReader dtor delete 'Buffer'. 3119932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines R->setBufferOwned(true); 3120932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return M; 3121932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3122932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3123932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ParseBitcodeFile - Read the specified bitcode file, returning the module. 3124932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// If an error occurs, return null and fill in *ErrMsg if non-null. 3125932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesModule *llvm_2_7::ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext& Context, 3126932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string *ErrMsg){ 3127932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Module *M = llvm_2_7::getLazyBitcodeModule(Buffer, Context, ErrMsg); 3128932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!M) return 0; 3129932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3130932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether 3131932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // there was an error. 3132932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static_cast<BitcodeReader*>(M->getMaterializer())->setBufferOwned(false); 3133932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3134932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read in the entire module, and destroy the BitcodeReader. 3135932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (M->MaterializeAllPermanently(ErrMsg)) { 3136932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete M; 3137932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return 0; 3138932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3139932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3140932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return M; 3141932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3142932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3143932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstd::string llvm_2_7::getBitcodeTargetTriple(MemoryBuffer *Buffer, 3144932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVMContext& Context, 3145932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string *ErrMsg) { 3146932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BitcodeReader *R = new BitcodeReader(Buffer, Context); 3147932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Don't let the BitcodeReader dtor delete 'Buffer'. 3148932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines R->setBufferOwned(false); 3149932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3150932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string Triple(""); 3151d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = R->ParseTriple(Triple)) 3152932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ErrMsg) 3153d724d097437f40a5689464429f948ec41e4a2415Stephen Hines *ErrMsg = EC.message(); 3154932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3155932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete R; 3156932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Triple; 3157932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3158