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 14932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/Bitcode/ReaderWriter.h" 15932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "BitcodeReader.h" 16932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "BitReader_2_7.h" 17932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/Constants.h" 18932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/DerivedTypes.h" 19932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/InlineAsm.h" 20932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/IntrinsicInst.h" 21932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/Module.h" 22932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/Operator.h" 23932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/AutoUpgrade.h" 24932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/ADT/SmallString.h" 25932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/ADT/SmallVector.h" 26932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/Support/MathExtras.h" 27932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/Support/MemoryBuffer.h" 28932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/OperandTraits.h" 29932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesusing namespace llvm; 30932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesusing namespace llvm_2_7; 31932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 32932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define METADATA_NODE_2_7 2 33932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define METADATA_FN_NODE_2_7 3 34932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define METADATA_NAMED_NODE_2_7 5 35932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define METADATA_ATTACHMENT_2_7 7 36932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define FUNC_CODE_INST_MALLOC_2_7 17 37932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define FUNC_CODE_INST_FREE_2_7 18 38932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define FUNC_CODE_INST_STORE_2_7 21 39932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define FUNC_CODE_INST_CALL_2_7 22 40932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define FUNC_CODE_INST_GETRESULT_2_7 25 41932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define FUNC_CODE_DEBUG_LOC_2_7 32 42932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 43932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReader::FreeState() { 44932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BufferOwned) 45932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete Buffer; 46932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Buffer = 0; 47932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Type*>().swap(TypeList); 48932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.clear(); 49932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.clear(); 50932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 51932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<AttrListPtr>().swap(MAttributes); 52932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<BasicBlock*>().swap(FunctionBBs); 53932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Function*>().swap(FunctionsWithBodies); 54932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DeferredFunctionInfo.clear(); 55932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDKindMap.clear(); 56932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 57932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 58932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 59932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// Helper functions to implement forward reference resolution, etc. 60932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 61932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 62932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ConvertToString - Convert a string from a record into an std::string, return 63932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// true on failure. 64932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinestemplate<typename StrTy> 65932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic bool ConvertToString(SmallVector<uint64_t, 64> &Record, unsigned Idx, 66932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StrTy &Result) { 67932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx > Record.size()) 68932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 69932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 70932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = Idx, e = Record.size(); i != e; ++i) 71932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Result += (char)Record[i]; 72932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 73932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 74932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 75932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) { 76932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Val) { 77932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Map unknown/new linkages to external 78932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 0: return GlobalValue::ExternalLinkage; 79932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 1: return GlobalValue::WeakAnyLinkage; 80932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 2: return GlobalValue::AppendingLinkage; 81932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 3: return GlobalValue::InternalLinkage; 82932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 4: return GlobalValue::LinkOnceAnyLinkage; 83932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 5: return GlobalValue::DLLImportLinkage; 84932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 6: return GlobalValue::DLLExportLinkage; 85932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 7: return GlobalValue::ExternalWeakLinkage; 86932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 8: return GlobalValue::CommonLinkage; 87932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 9: return GlobalValue::PrivateLinkage; 88932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 10: return GlobalValue::WeakODRLinkage; 89932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 11: return GlobalValue::LinkOnceODRLinkage; 90932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 12: return GlobalValue::AvailableExternallyLinkage; 91932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 13: return GlobalValue::LinkerPrivateLinkage; 92932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 14: return GlobalValue::LinkerPrivateWeakLinkage; 93932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 15: return GlobalValue::LinkerPrivateWeakDefAutoLinkage; 94932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 95932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 96932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 97932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) { 98932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Val) { 99932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Map unknown visibilities to default. 100932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 0: return GlobalValue::DefaultVisibility; 101932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 1: return GlobalValue::HiddenVisibility; 102932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 2: return GlobalValue::ProtectedVisibility; 103932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 104932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 105932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 106932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic int GetDecodedCastOpcode(unsigned Val) { 107932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Val) { 108932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: return -1; 109932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_TRUNC : return Instruction::Trunc; 110932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_ZEXT : return Instruction::ZExt; 111932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_SEXT : return Instruction::SExt; 112932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPTOUI : return Instruction::FPToUI; 113932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPTOSI : return Instruction::FPToSI; 114932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_UITOFP : return Instruction::UIToFP; 115932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_SITOFP : return Instruction::SIToFP; 116932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPTRUNC : return Instruction::FPTrunc; 117932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPEXT : return Instruction::FPExt; 118932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_PTRTOINT: return Instruction::PtrToInt; 119932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_INTTOPTR: return Instruction::IntToPtr; 120932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_BITCAST : return Instruction::BitCast; 121932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 122932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 123932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic int GetDecodedBinaryOpcode(unsigned Val, Type *Ty) { 124932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Val) { 125932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: return -1; 126932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_ADD: 127932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FAdd : Instruction::Add; 128932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SUB: 129932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FSub : Instruction::Sub; 130932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_MUL: 131932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FMul : Instruction::Mul; 132932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_UDIV: return Instruction::UDiv; 133932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SDIV: 134932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FDiv : Instruction::SDiv; 135932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_UREM: return Instruction::URem; 136932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SREM: 137932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FRem : Instruction::SRem; 138932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SHL: return Instruction::Shl; 139932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_LSHR: return Instruction::LShr; 140932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_ASHR: return Instruction::AShr; 141932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_AND: return Instruction::And; 142932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_OR: return Instruction::Or; 143932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_XOR: return Instruction::Xor; 144932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 145932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 146932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 147932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesnamespace llvm { 148932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesnamespace { 149932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// @brief A class for maintaining the slot number definition 150932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// as a placeholder for the actual definition for forward constants defs. 151932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines class ConstantPlaceHolder : public ConstantExpr { 152932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines void operator=(const ConstantPlaceHolder &); // DO NOT IMPLEMENT 153932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines public: 154932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // allocate space for exactly one operand 155932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines void *operator new(size_t s) { 156932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return User::operator new(s, 1); 157932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 158932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines explicit ConstantPlaceHolder(Type *Ty, LLVMContext& Context) 159932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) { 160932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Op<0>() = UndefValue::get(Type::getInt32Ty(Context)); 161932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 162932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 163932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// @brief Methods to support type inquiry through isa, cast, and dyn_cast. 164932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines //static inline bool classof(const ConstantPlaceHolder *) { return true; } 165932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static bool classof(const Value *V) { 166932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return isa<ConstantExpr>(V) && 167932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1; 168932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 169932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 170932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 171932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// Provide fast operand accessors 172932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines //DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 173932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines }; 174932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 175932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 176932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// FIXME: can we inherit this from ConstantExpr? 177932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinestemplate <> 178932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstruct OperandTraits<ConstantPlaceHolder> : 179932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines public FixedNumOperandTraits<ConstantPlaceHolder, 1> { 180932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines}; 181932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 182932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 183932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 184932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) { 185932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx == size()) { 186932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines push_back(V); 187932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 188932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 189932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 190932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 191932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx+1); 192932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 193932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines WeakVH &OldV = ValuePtrs[Idx]; 194932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OldV == 0) { 195932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV = V; 196932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 197932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 198932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 199932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Handle constants and non-constants (e.g. instrs) differently for 200932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // efficiency. 201932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Constant *PHC = dyn_cast<Constant>(&*OldV)) { 202932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveConstants.push_back(std::make_pair(PHC, Idx)); 203932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV = V; 204932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 205932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If there was a forward reference to this value, replace it. 206932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *PrevVal = OldV; 207932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV->replaceAllUsesWith(V); 208932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete PrevVal; 209932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 210932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 211932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 212932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 213932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesConstant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, 214932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty) { 215932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 216932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx + 1); 217932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 218932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Value *V = ValuePtrs[Idx]) { 219932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(Ty == V->getType() && "Type mismatch in constant table!"); 220932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return cast<Constant>(V); 221932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 222932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 223932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create and return a placeholder, which will later be RAUW'd. 224932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *C = new ConstantPlaceHolder(Ty, Context); 225932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValuePtrs[Idx] = C; 226932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return C; 227932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 228932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 229932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesValue *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty) { 230932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 231932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx + 1); 232932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 233932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Value *V = ValuePtrs[Idx]) { 234932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!"); 235932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V; 236932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 237932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 238932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No type specified, must be invalid reference. 239932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Ty == 0) return 0; 240932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 241932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create and return a placeholder, which will later be RAUW'd. 242932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = new Argument(Ty); 243932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValuePtrs[Idx] = V; 244932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V; 245932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 246932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 247932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ResolveConstantForwardRefs - Once all constants are read, this method bulk 248932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// resolves any forward references. The idea behind this is that we sometimes 249932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// get constants (such as large arrays) which reference *many* forward ref 250932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// constants. Replacing each of these causes a lot of thrashing when 251932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// building/reuniquing the constant. Instead of doing this, we look at all the 252932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// uses and rewrite all the place holders at once for any constant that uses 253932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// a placeholder. 254932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReaderValueList::ResolveConstantForwardRefs() { 255932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Sort the values by-pointer so that they are efficient to look up with a 256932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // binary search. 257932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::sort(ResolveConstants.begin(), ResolveConstants.end()); 258932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 259932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Constant*, 64> NewOps; 260932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 261932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!ResolveConstants.empty()) { 262932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *RealVal = operator[](ResolveConstants.back().second); 263932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Placeholder = ResolveConstants.back().first; 264932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveConstants.pop_back(); 265932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 266932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Loop over all users of the placeholder, updating them to reference the 267932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // new value. If they reference more than one placeholder, update them all 268932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // at once. 269932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!Placeholder->use_empty()) { 270932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value::use_iterator UI = Placeholder->use_begin(); 271932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines User *U = *UI; 272932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 273932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If the using object isn't uniqued, just update the operands. This 274932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // handles instructions and initializers for global variables. 275932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!isa<Constant>(U) || isa<GlobalValue>(U)) { 276932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UI.getUse().set(RealVal); 277932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 278932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 279932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 280932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Otherwise, we have a constant that uses the placeholder. Replace that 281932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // constant with a new constant that has *all* placeholder uses updated. 282932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *UserC = cast<Constant>(U); 283932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (User::op_iterator I = UserC->op_begin(), E = UserC->op_end(); 284932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I != E; ++I) { 285932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *NewOp; 286932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!isa<ConstantPlaceHolder>(*I)) { 287932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Not a placeholder reference. 288932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOp = *I; 289932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (*I == Placeholder) { 290932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Common case is that it just references this one placeholder. 291932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOp = RealVal; 292932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 293932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Otherwise, look up the placeholder in ResolveConstants. 294932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveConstantsTy::iterator It = 295932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::lower_bound(ResolveConstants.begin(), ResolveConstants.end(), 296932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::pair<Constant*, unsigned>(cast<Constant>(*I), 297932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 0)); 298932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(It != ResolveConstants.end() && It->first == *I); 299932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOp = operator[](It->second); 300932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 301932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 302932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOps.push_back(cast<Constant>(NewOp)); 303932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 304932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 305932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Make the new constant. 306932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *NewC; 307932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) { 308932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = ConstantArray::get(UserCA->getType(), NewOps); 309932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) { 310932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = ConstantStruct::get(UserCS->getType(), NewOps); 311932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (isa<ConstantVector>(UserC)) { 312932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = ConstantVector::get(NewOps); 313932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 314932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr."); 315932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = cast<ConstantExpr>(UserC)->getWithOperands(NewOps); 316932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 317932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 318932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UserC->replaceAllUsesWith(NewC); 319932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UserC->destroyConstant(); 320932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOps.clear(); 321932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 322932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 323932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Update all ValueHandles, they should be the only users at this point. 324932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Placeholder->replaceAllUsesWith(RealVal); 325932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete Placeholder; 326932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 327932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 328932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 329932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReaderMDValueList::AssignValue(Value *V, unsigned Idx) { 330932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx == size()) { 331932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines push_back(V); 332932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 333932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 334932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 335932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 336932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx+1); 337932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 338932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines WeakVH &OldV = MDValuePtrs[Idx]; 339932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OldV == 0) { 340932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV = V; 341932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 342932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 343932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 344932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If there was a forward reference to this value, replace it. 345932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDNode *PrevVal = cast<MDNode>(OldV); 346932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV->replaceAllUsesWith(V); 347932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDNode::deleteTemporary(PrevVal); 348932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Deleting PrevVal sets Idx value in MDValuePtrs to null. Set new 349932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // value for Idx. 350932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValuePtrs[Idx] = V; 351932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 352932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 353932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesValue *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { 354932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 355932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx + 1); 356932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 357932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Value *V = MDValuePtrs[Idx]) { 358932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(V->getType()->isMetadataTy() && "Type mismatch in value table!"); 359932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V; 360932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 361932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 362932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create and return a placeholder, which will later be RAUW'd. 363932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = MDNode::getTemporary(Context, ArrayRef<Value*>()); 364932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValuePtrs[Idx] = V; 365932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V; 366932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 367932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 368932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesType *BitcodeReader::getTypeByID(unsigned ID) { 369932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // The type table size is always specified correctly. 370932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ID >= TypeList.size()) 371932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return 0; 372932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 373932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *Ty = TypeList[ID]) 374932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty; 375932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 376932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we have a forward reference, the only possible case is when it is to a 377932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // named struct. Just create a placeholder for now. 378bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien return TypeList[ID] = StructType::create(Context, ""); 379932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 380932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 381932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// FIXME: Remove in LLVM 3.1, only used by ParseOldTypeTable. 382932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesType *BitcodeReader::getTypeByIDOrNull(unsigned ID) { 383932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ID >= TypeList.size()) 384932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList.resize(ID+1); 385932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 386932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return TypeList[ID]; 387932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 388932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 389932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 390932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 391932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// Functions for parsing blocks from the bitcode file 392932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 393932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 394932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseAttributeBlock() { 395932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) 396932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 397932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 398932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!MAttributes.empty()) 399932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Multiple PARAMATTR blocks found!"); 400932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 401932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 402932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 403932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<AttributeWithIndex, 8> Attrs; 404932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 405932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records. 406932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 407932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 408932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 409932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 410932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Error at end of PARAMATTR block"); 411932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 412932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 413932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 414932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 415932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 416932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 417932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 418932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 419932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 420932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 421932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 422932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 423932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 424932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 425932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 426932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 427932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 428932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 429932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadRecord(Code, Record)) { 430932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: ignore. 431932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 432932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [paramidx0, attr0, ...] 433932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() & 1) 434932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid ENTRY record"); 435932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 436932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME : Remove this autoupgrade code in LLVM 3.0. 437932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If Function attributes are using index 0 then transfer them 438932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // to index ~0. Index 0 is used for return value attributes but used to be 439932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // used for function attributes. 440932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Attributes RetAttribute = Attribute::None; 441932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Attributes FnAttribute = Attribute::None; 442932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 443932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME: remove in LLVM 3.0 444932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // The alignment is stored as a 16-bit raw value from bits 31--16. 445932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We shift the bits above 31 down by 11 bits. 446932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 447932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Alignment = (Record[i+1] & (0xffffull << 16)) >> 16; 448932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Alignment && !isPowerOf2_32(Alignment)) 449932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Alignment is not a power of two."); 450932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 451932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Attributes ReconstitutedAttr = Record[i+1] & 0xffff; 452932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Alignment) 453932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ReconstitutedAttr |= Attribute::constructAlignmentFromInt(Alignment); 454932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ReconstitutedAttr |= (Record[i+1] & (0xffffull << 32)) >> 11; 455932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record[i+1] = ReconstitutedAttr; 456932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 457932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[i] == 0) 458932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines RetAttribute = Record[i+1]; 459932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (Record[i] == ~0U) 460932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FnAttribute = Record[i+1]; 461932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 462932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 463932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OldRetAttrs = (Attribute::NoUnwind|Attribute::NoReturn| 464932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Attribute::ReadOnly|Attribute::ReadNone); 465932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 466932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FnAttribute == Attribute::None && RetAttribute != Attribute::None && 467932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines (RetAttribute & OldRetAttrs) != 0) { 468932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FnAttribute == Attribute::None) { // add a slot so they get added. 469932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.push_back(~0U); 470932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.push_back(0); 471932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 472932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 473932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FnAttribute |= RetAttribute & OldRetAttrs; 474932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines RetAttribute &= ~OldRetAttrs; 475932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 476932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 477932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 478932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[i] == 0) { 479932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (RetAttribute != Attribute::None) 480932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Attrs.push_back(AttributeWithIndex::get(0, RetAttribute)); 481932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (Record[i] == ~0U) { 482932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FnAttribute != Attribute::None) 483932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Attrs.push_back(AttributeWithIndex::get(~0U, FnAttribute)); 484932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (Record[i+1] != Attribute::None) 485932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Attrs.push_back(AttributeWithIndex::get(Record[i], Record[i+1])); 486932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 487932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 488932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MAttributes.push_back(AttrListPtr::get(Attrs.begin(), Attrs.end())); 489932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Attrs.clear(); 490932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 491932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 492932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 493932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 494932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 495932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 496932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseTypeTable() { 497932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW)) 498932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 499932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 500932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return ParseTypeTableBody(); 501932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 502932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 503932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseTypeTableBody() { 504932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!TypeList.empty()) 505932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Multiple TYPE_BLOCKs found!"); 506932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 507932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 508932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumRecords = 0; 509932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 510932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<64> TypeName; 511932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 512932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this type table. 513932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 514932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 515932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 516932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords != TypeList.size()) 517932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid type forward reference in TYPE_BLOCK"); 518932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 519932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Error at end of type table block"); 520932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 521932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 522932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 523932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 524932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 525932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 526932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 527932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 528932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 529932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 530932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 531932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 532932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 533932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 534932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 535932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 536932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 537932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 538932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ResultTy = 0; 539932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadRecord(Code, Record)) { 540932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: return Error("unknown type in type table"); 541932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 542932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // TYPE_CODE_NUMENTRY contains a count of the number of types in the 543932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // type list. This allows us to reserve space. 544932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 545932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid TYPE_CODE_NUMENTRY record"); 546932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList.resize(Record[0]); 547932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 548932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VOID: // VOID 549932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getVoidTy(Context); 550932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 551932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FLOAT: // FLOAT 552932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFloatTy(Context); 553932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 554932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_DOUBLE: // DOUBLE 555932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getDoubleTy(Context); 556932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 557932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_FP80: // X86_FP80 558932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_FP80Ty(Context); 559932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 560932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FP128: // FP128 561932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFP128Ty(Context); 562932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 563932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 564932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getPPC_FP128Ty(Context); 565932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 566932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_LABEL: // LABEL 567932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getLabelTy(Context); 568932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 569932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_METADATA: // METADATA 570932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getMetadataTy(Context); 571932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 572932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_MMX: // X86_MMX 573932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_MMXTy(Context); 574932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 575932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 576932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 577932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid Integer type record"); 578932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 579932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = IntegerType::get(Context, Record[0]); 580932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 581932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 582932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // [pointee type, address space] 583932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 584932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid POINTER type record"); 585932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AddressSpace = 0; 586932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() == 2) 587932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AddressSpace = Record[1]; 588932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = getTypeByID(Record[0]); 589932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ResultTy == 0) return Error("invalid element type in pointer type"); 590932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = PointerType::get(ResultTy, AddressSpace); 591932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 592932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 593932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FUNCTION: { 594932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME: attrid is dead, remove it in LLVM 3.0 595932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FUNCTION: [vararg, attrid, retty, paramty x N] 596932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 597932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid FUNCTION type record"); 598932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Type*> ArgTys; 599932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 3, e = Record.size(); i != e; ++i) { 600932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *T = getTypeByID(Record[i])) 601932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArgTys.push_back(T); 602932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 603932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 604932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 605932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 606932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = getTypeByID(Record[2]); 607932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ResultTy == 0 || ArgTys.size() < Record.size()-3) 608932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("invalid type in function type"); 609932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 610932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 611932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 612932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 613932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N] 614932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 615932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid STRUCT type record"); 616932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Type*> EltTys; 617932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1, e = Record.size(); i != e; ++i) { 618932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *T = getTypeByID(Record[i])) 619932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EltTys.push_back(T); 620932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 621932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 622932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 623932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (EltTys.size() != Record.size()-1) 624932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("invalid type in struct type"); 625932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = StructType::get(Context, EltTys, Record[0]); 626932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 627932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 628932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N] 629932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, TypeName)) 630932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid STRUCT_NAME record"); 631932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 632932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 633932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N] 634932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 635932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid STRUCT type record"); 636932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 637932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords >= TypeList.size()) 638932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("invalid TYPE table"); 639932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 640932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check to see if this was forward referenced, if so fill in the temp. 641932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 642932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Res) { 643932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Res->setName(TypeName); 644932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NumRecords] = 0; 645932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else // Otherwise, create a new struct. 646bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien Res = StructType::create(Context, TypeName); 647932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeName.clear(); 648932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 649932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Type*, 8> EltTys; 650932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1, e = Record.size(); i != e; ++i) { 651932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *T = getTypeByID(Record[i])) 652932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EltTys.push_back(T); 653932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 654932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 655932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 656932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (EltTys.size() != Record.size()-1) 657932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("invalid STRUCT type record"); 658932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Res->setBody(EltTys, Record[0]); 659932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Res; 660932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 661932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 662932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: [] 663932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != 1) 664932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid OPAQUE type record"); 665932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 666932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords >= TypeList.size()) 667932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("invalid TYPE table"); 668932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 669932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check to see if this was forward referenced, if so fill in the temp. 670932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 671932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Res) { 672932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Res->setName(TypeName); 673932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NumRecords] = 0; 674932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else // Otherwise, create a new struct with no body. 675bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien Res = StructType::create(Context, TypeName); 676932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeName.clear(); 677932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Res; 678932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 679932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 680932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 681932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 682932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid ARRAY type record"); 683932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByID(Record[1]))) 684932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = ArrayType::get(ResultTy, Record[0]); 685932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 686932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid ARRAY type element"); 687932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 688932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 689932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 690932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid VECTOR type record"); 691932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByID(Record[1]))) 692932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = VectorType::get(ResultTy, Record[0]); 693932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 694932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid ARRAY type element"); 695932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 696932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 697932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 698932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords >= TypeList.size()) 699932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("invalid TYPE table"); 700932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(ResultTy && "Didn't read a type?"); 701932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(TypeList[NumRecords] == 0 && "Already read type?"); 702932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NumRecords++] = ResultTy; 703932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 704932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 705932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 706932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// FIXME: Remove in LLVM 3.1 707932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseOldTypeTable() { 708932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_OLD)) 709932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 710932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 711932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!TypeList.empty()) 712932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Multiple TYPE_BLOCKs found!"); 713932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 714932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 715932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // While horrible, we have no good ordering of types in the bc file. Just 716932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // iteratively parse types out of the bc file in multiple passes until we get 717932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // them all. Do this by saving a cursor for the start of the type block. 718932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BitstreamCursor StartOfTypeBlockCursor(Stream); 719932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 720932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumTypesRead = 0; 721932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 722932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 723932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesRestartScan: 724932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextTypeID = 0; 725932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool ReadAnyTypes = false; 726932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 727932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this type table. 728932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 729932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 730932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 731932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID != TypeList.size()) 732932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid type forward reference in TYPE_BLOCK_ID_OLD"); 733932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 734932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we haven't read all of the types yet, iterate again. 735932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumTypesRead != TypeList.size()) { 736932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we didn't successfully read any types in this pass, then we must 737932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // have an unhandled forward reference. 738932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!ReadAnyTypes) 739932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Obsolete bitcode contains unhandled recursive type"); 740932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 741932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream = StartOfTypeBlockCursor; 742932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines goto RestartScan; 743932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 744932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 745932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 746932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Error at end of type table block"); 747932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 748932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 749932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 750932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 751932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 752932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 753932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 754932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 755932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 756932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 757932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 758932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 759932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 760932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 761932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 762932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 763932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 764932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 765932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ResultTy = 0; 766932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadRecord(Code, Record)) { 767932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: return Error("unknown type in type table"); 768932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 769932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // TYPE_CODE_NUMENTRY contains a count of the number of types in the 770932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // type list. This allows us to reserve space. 771932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 772932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid TYPE_CODE_NUMENTRY record"); 773932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList.resize(Record[0]); 774932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 775932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VOID: // VOID 776932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getVoidTy(Context); 777932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 778932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FLOAT: // FLOAT 779932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFloatTy(Context); 780932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 781932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_DOUBLE: // DOUBLE 782932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getDoubleTy(Context); 783932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 784932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_FP80: // X86_FP80 785932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_FP80Ty(Context); 786932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 787932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FP128: // FP128 788932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFP128Ty(Context); 789932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 790932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 791932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getPPC_FP128Ty(Context); 792932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 793932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_LABEL: // LABEL 794932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getLabelTy(Context); 795932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 796932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_METADATA: // METADATA 797932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getMetadataTy(Context); 798932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 799932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_MMX: // X86_MMX 800932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_MMXTy(Context); 801932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 802932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 803932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 804932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid Integer type record"); 805932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = IntegerType::get(Context, Record[0]); 806932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 807932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_OPAQUE: // OPAQUE 808932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID < TypeList.size() && TypeList[NextTypeID] == 0) 809bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien ResultTy = StructType::create(Context, ""); 810932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 811932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_STRUCT_OLD: {// STRUCT_OLD 812932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID >= TypeList.size()) break; 813932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we already read it, don't reprocess. 814932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TypeList[NextTypeID] && 815932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines !cast<StructType>(TypeList[NextTypeID])->isOpaque()) 816932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 817932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 818932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Set a type. 819932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TypeList[NextTypeID] == 0) 820bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien TypeList[NextTypeID] = StructType::create(Context, ""); 821932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 822932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Type*> EltTys; 823932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1, e = Record.size(); i != e; ++i) { 824932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *Elt = getTypeByIDOrNull(Record[i])) 825932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EltTys.push_back(Elt); 826932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 827932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 828932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 829932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 830932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (EltTys.size() != Record.size()-1) 831932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; // Not all elements are ready. 832932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 833932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<StructType>(TypeList[NextTypeID])->setBody(EltTys, Record[0]); 834932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = TypeList[NextTypeID]; 835932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NextTypeID] = 0; 836932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 837932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 838932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 839932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // [pointee type, address space] 840932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 841932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid POINTER type record"); 842932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AddressSpace = 0; 843932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() == 2) 844932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AddressSpace = Record[1]; 845932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[0]))) 846932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = PointerType::get(ResultTy, AddressSpace); 847932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 848932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 849932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FUNCTION: { 850932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME: attrid is dead, remove it in LLVM 3.0 851932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FUNCTION: [vararg, attrid, retty, paramty x N] 852932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 853932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid FUNCTION type record"); 854932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Type*> ArgTys; 855932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 3, e = Record.size(); i != e; ++i) { 856932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *Elt = getTypeByIDOrNull(Record[i])) 857932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArgTys.push_back(Elt); 858932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 859932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 860932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 861932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ArgTys.size()+3 != Record.size()) 862932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; // Something was null. 863932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[2]))) 864932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 865932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 866932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 867932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 868932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 869932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid ARRAY type record"); 870932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[1]))) 871932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = ArrayType::get(ResultTy, Record[0]); 872932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 873932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 874932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 875932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid VECTOR type record"); 876932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[1]))) 877932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = VectorType::get(ResultTy, Record[0]); 878932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 879932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 880932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 881932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID >= TypeList.size()) 882932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("invalid TYPE table"); 883932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 884932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ResultTy && TypeList[NextTypeID] == 0) { 885932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++NumTypesRead; 886932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ReadAnyTypes = true; 887932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 888932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NextTypeID] = ResultTy; 889932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 890932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 891932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++NextTypeID; 892932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 893932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 894932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 895932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 896932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseOldTypeSymbolTable() { 897932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::TYPE_SYMTAB_BLOCK_ID_OLD)) 898932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 899932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 900932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 901932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 902932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this type table. 903932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string TypeName; 904932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 905932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 906932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 907932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 908932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Error at end of type symbol table block"); 909932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 910932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 911932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 912932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 913932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 914932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 915932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 916932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 917932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 918932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 919932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 920932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 921932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 922932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 923932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 924932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 925932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 926932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 927932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadRecord(Code, Record)) { 928932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: unknown type. 929932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 930932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TST_CODE_ENTRY: // TST_ENTRY: [typeid, namechar x N] 931932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 1, TypeName)) 932932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid TST_ENTRY record"); 933932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned TypeID = Record[0]; 934932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TypeID >= TypeList.size()) 935932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid Type ID in TST_ENTRY record"); 936932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 937932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Only apply the type name to a struct type with no name. 938932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (StructType *STy = dyn_cast<StructType>(TypeList[TypeID])) 939bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien if (!STy->isLiteral() && !STy->hasName()) 940932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines STy->setName(TypeName); 941932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeName.clear(); 942932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 943932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 944932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 945932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 946932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 947932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseValueSymbolTable() { 948932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) 949932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 950932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 951932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 952932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 953932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this value table. 954932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<128> ValueName; 955932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 956932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 957932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 958932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 959932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Error at end of value symbol table block"); 960932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 961932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 962932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 963932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 964932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 965932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 966932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 967932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 968932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 969932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 970932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 971932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 972932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 973932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 974932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 975932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 976932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 977932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadRecord(Code, Record)) { 978932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: unknown type. 979932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 980932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N] 981932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 1, ValueName)) 982932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid VST_ENTRY record"); 983932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ValueID = Record[0]; 984932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ValueID >= ValueList.size()) 985932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid Value ID in VST_ENTRY record"); 986932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = ValueList[ValueID]; 987932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 988932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V->setName(StringRef(ValueName.data(), ValueName.size())); 989932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueName.clear(); 990932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 991932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 992932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VST_CODE_BBENTRY: { 993932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 1, ValueName)) 994932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid VST_BBENTRY record"); 995932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *BB = getBasicBlock(Record[0]); 996932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BB == 0) 997932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid BB ID in VST_BBENTRY record"); 998932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 999932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BB->setName(StringRef(ValueName.data(), ValueName.size())); 1000932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueName.clear(); 1001932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1002932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1003932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1004932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1005932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1006932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1007932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseMetadata() { 1008932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextMDValueNo = MDValueList.size(); 1009932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1010932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) 1011932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 1012932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1013932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1014932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1015932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records. 1016932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 1017932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 1018932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 1019932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 1020932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Error at end of PARAMATTR block"); 1021932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 1022932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1023932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1024932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 1025932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 1026932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 1027932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1028932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 1029932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1030932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1031932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1032932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 1033932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 1034932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1035932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1036932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1037932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool IsFunctionLocal = false; 1038932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1039932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1040932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Code = Stream.ReadRecord(Code, Record); 1041932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Code) { 1042932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: ignore. 1043932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1044932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_NAME: { 1045932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read named of the named metadata. 1046932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NameLength = Record.size(); 1047932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<8> Name; 1048932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Name.resize(NameLength); 1049932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != NameLength; ++i) 1050932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Name[i] = Record[i]; 1051932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1052932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Code = Stream.ReadCode(); 1053932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1054932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // METADATA_NAME is always followed by METADATA_NAMED_NODE. 1055932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextBitCode = Stream.ReadRecord(Code, Record); 1056932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextBitCode == METADATA_NAMED_NODE_2_7) { 1057932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 1058932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (NextBitCode != bitc::METADATA_NAMED_NODE) { 1059932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(!"Invalid Named Metadata record."); (void)NextBitCode; 1060932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1061932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1062932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read named metadata elements. 1063932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1064932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NamedMDNode *NMD = TheModule->getOrInsertNamedMetadata(Name); 1065932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) { 1066932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDNode *MD = dyn_cast<MDNode>(MDValueList.getValueFwdRef(Record[i])); 1067932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (MD == 0) 1068932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed metadata record"); 1069932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NMD->addOperand(MD); 1070932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1071932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1072932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (LLVM2_7MetadataDetected) { 1073932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.AssignValue(0, NextMDValueNo++); 1074932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1075932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1076932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1077932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case METADATA_FN_NODE_2_7: 1078932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_FN_NODE: 1079932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IsFunctionLocal = true; 1080932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // fall-through 1081932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case METADATA_NODE_2_7: 1082932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_NODE: { 1083932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == METADATA_FN_NODE_2_7 || 1084932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Code == METADATA_NODE_2_7) { 1085932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 1086932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1087932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1088932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() % 2 == 1) 1089932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid METADATA_NODE record"); 1090932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1091932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1092932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 8> Elts; 1093932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; i += 2) { 1094932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[i]); 1095932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty) return Error("Invalid METADATA_NODE record"); 1096932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Ty->isMetadataTy()) 1097932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); 1098932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (!Ty->isVoidTy()) 1099932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty)); 1100932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1101932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(NULL); 1102932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1103932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = MDNode::getWhenValsUnresolved(Context, Elts, IsFunctionLocal); 1104932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IsFunctionLocal = false; 1105932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.AssignValue(V, NextMDValueNo++); 1106932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1107932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1108932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_STRING: { 1109932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned MDStringLength = Record.size(); 1110932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<8> String; 1111932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines String.resize(MDStringLength); 1112932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != MDStringLength; ++i) 1113932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines String[i] = Record[i]; 1114932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = MDString::get(Context, 1115932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StringRef(String.data(), String.size())); 1116932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.AssignValue(V, NextMDValueNo++); 1117932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1118932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1119932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_KIND: { 1120932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned RecordLength = Record.size(); 1121932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty() || RecordLength < 2) 1122932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid METADATA_KIND record"); 1123932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<8> Name; 1124932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Name.resize(RecordLength-1); 1125932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Kind = Record[0]; 1126932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1; i != RecordLength; ++i) 1127932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Name[i-1] = Record[i]; 1128932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1129932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NewKind = TheModule->getMDKindID(Name.str()); 1130932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) 1131932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Conflicting METADATA_KIND records"); 1132932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1133932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1134932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1135932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1136932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1137932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1138932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// DecodeSignRotatedValue - Decode a signed value stored with the sign bit in 1139932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// the LSB for dense VBR encoding. 1140932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic uint64_t DecodeSignRotatedValue(uint64_t V) { 1141932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((V & 1) == 0) 1142932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V >> 1; 1143932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (V != 1) 1144932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return -(V >> 1); 1145932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // There is no such thing as -0 with integers. "-0" really means MININT. 1146932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return 1ULL << 63; 1147932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1148932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1149932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ResolveGlobalAndAliasInits - Resolve all of the initializers for global 1150932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// values and aliases that we can. 1151932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ResolveGlobalAndAliasInits() { 1152932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist; 1153932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist; 1154932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1155932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInitWorklist.swap(GlobalInits); 1156932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInitWorklist.swap(AliasInits); 1157932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1158932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!GlobalInitWorklist.empty()) { 1159932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ValID = GlobalInitWorklist.back().second; 1160932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ValID >= ValueList.size()) { 1161932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Not ready to resolve this yet, it requires something later in the file. 1162932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInits.push_back(GlobalInitWorklist.back()); 1163932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1164932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 1165932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInitWorklist.back().first->setInitializer(C); 1166932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1167932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Global variable initializer is not a constant!"); 1168932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1169932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInitWorklist.pop_back(); 1170932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1171932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1172932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!AliasInitWorklist.empty()) { 1173932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ValID = AliasInitWorklist.back().second; 1174932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ValID >= ValueList.size()) { 1175932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInits.push_back(AliasInitWorklist.back()); 1176932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1177932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 1178932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInitWorklist.back().first->setAliasee(C); 1179932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1180932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Alias initializer is not a constant!"); 1181932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1182932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInitWorklist.pop_back(); 1183932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1184932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 1185932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1186932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1187932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseConstants() { 1188932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) 1189932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 1190932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1191932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1192932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1193932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this value table. 1194932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *CurTy = Type::getInt32Ty(Context); 1195932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextCstNo = ValueList.size(); 1196932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 1197932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 1198932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) 1199932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1200932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1201932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 1202932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 1203932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 1204932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1205932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 1206932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1207932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1208932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1209932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 1210932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 1211932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1212932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1213932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1214932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1215932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1216932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = 0; 1217932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned BitCode = Stream.ReadRecord(Code, Record); 1218932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (BitCode) { 1219932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: unknown constant 1220932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_UNDEF: // UNDEF 1221932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); 1222932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1223932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] 1224932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1225932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed CST_SETTYPE record"); 1226932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[0] >= TypeList.size()) 1227932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid Type ID in CST_SETTYPE record"); 1228932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurTy = TypeList[Record[0]]; 1229932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; // Skip the ValueList manipulation. 1230932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_NULL: // NULL 1231932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = Constant::getNullValue(CurTy); 1232932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1233932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_INTEGER: // INTEGER: [intval] 1234932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!CurTy->isIntegerTy() || Record.empty()) 1235932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CST_INTEGER record"); 1236932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantInt::get(CurTy, DecodeSignRotatedValue(Record[0])); 1237932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1238932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval] 1239932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!CurTy->isIntegerTy() || Record.empty()) 1240932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid WIDE_INTEGER record"); 1241932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1242932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumWords = Record.size(); 1243932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 8> Words; 1244932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Words.resize(NumWords); 1245932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != NumWords; ++i) 1246932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Words[i] = DecodeSignRotatedValue(Record[i]); 1247932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantInt::get(Context, 1248932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines APInt(cast<IntegerType>(CurTy)->getBitWidth(), 1249932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Words)); 1250932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1251932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1252932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] 1253932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1254932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid FLOAT record"); 1255932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CurTy->isFloatTy()) 1256932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantFP::get(Context, APFloat(APInt(32, (uint32_t)Record[0]))); 1257932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurTy->isDoubleTy()) 1258932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantFP::get(Context, APFloat(APInt(64, Record[0]))); 1259932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurTy->isX86_FP80Ty()) { 1260932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Bits are not stored the same way as a normal i80 APInt, compensate. 1261932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t Rearrange[2]; 1262932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16); 1263932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Rearrange[1] = Record[0] >> 48; 1264932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantFP::get(Context, APFloat(APInt(80, Rearrange))); 1265932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (CurTy->isFP128Ty()) 1266932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantFP::get(Context, APFloat(APInt(128, Record), true)); 1267932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurTy->isPPC_FP128Ty()) 1268932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantFP::get(Context, APFloat(APInt(128, Record))); 1269932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1270932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); 1271932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1272932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1273932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1274932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] 1275932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1276932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CST_AGGREGATE record"); 1277932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1278932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1279932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Constant*> Elts; 1280932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1281932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (StructType *STy = dyn_cast<StructType>(CurTy)) { 1282932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1283932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i], 1284932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines STy->getElementType(i))); 1285932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantStruct::get(STy, Elts); 1286932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) { 1287932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = ATy->getElementType(); 1288932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1289932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 1290932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantArray::get(ATy, Elts); 1291932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) { 1292932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = VTy->getElementType(); 1293932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1294932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 1295932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantVector::get(Elts); 1296932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1297932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); 1298932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1299932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1300932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1301932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_STRING: { // STRING: [values] 1302932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1303932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CST_AGGREGATE record"); 1304932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1305932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArrayType *ATy = cast<ArrayType>(CurTy); 1306932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = ATy->getElementType(); 1307932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1308932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1309932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Constant*> Elts; 1310932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1311932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ConstantInt::get(EltTy, Record[i])); 1312932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantArray::get(ATy, Elts); 1313932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1314932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1315932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CSTRING: { // CSTRING: [values] 1316932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 1317932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CST_AGGREGATE record"); 1318932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1319932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArrayType *ATy = cast<ArrayType>(CurTy); 1320932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = ATy->getElementType(); 1321932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1322932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1323932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Constant*> Elts; 1324932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1325932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ConstantInt::get(EltTy, Record[i])); 1326932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(Constant::getNullValue(EltTy)); 1327932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantArray::get(ATy, Elts); 1328932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1329932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1330932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] 1331932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) return Error("Invalid CE_BINOP record"); 1332932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedBinaryOpcode(Record[0], CurTy); 1333932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc < 0) { 1334932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); // Unknown binop. 1335932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1336932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy); 1337932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy); 1338932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Flags = 0; 1339932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() >= 4) { 1340932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc == Instruction::Add || 1341932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Sub || 1342932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Mul || 1343932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Shl) { 1344932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 1345932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Flags |= OverflowingBinaryOperator::NoSignedWrap; 1346932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 1347932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Flags |= OverflowingBinaryOperator::NoUnsignedWrap; 1348932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (Opc == Instruction::SDiv || 1349932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::UDiv || 1350932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::LShr || 1351932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::AShr) { 1352932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[3] & (1 << bitc::PEO_EXACT)) 1353932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Flags |= SDivOperator::IsExact; 1354932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1355932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1356932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::get(Opc, LHS, RHS, Flags); 1357932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1358932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1359932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1360932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] 1361932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) return Error("Invalid CE_CAST record"); 1362932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedCastOpcode(Record[0]); 1363932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc < 0) { 1364932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); // Unknown cast. 1365932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1366932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[1]); 1367932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!OpTy) return Error("Invalid CE_CAST record"); 1368932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); 1369932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getCast(Opc, Op, CurTy); 1370932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1371932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1372932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1373932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_INBOUNDS_GEP: 1374932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands] 1375932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() & 1) return Error("Invalid CE_GEP record"); 1376932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Constant*, 16> Elts; 1377932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 1378932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ElTy = getTypeByID(Record[i]); 1379932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!ElTy) return Error("Invalid CE_GEP record"); 1380932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); 1381932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1382932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BitCode == bitc::CST_CODE_CE_INBOUNDS_GEP) 1383bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien V = ConstantExpr::getInBoundsGetElementPtr(Elts[0], 1384bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien llvm::ArrayRef<llvm::Constant*>(&Elts[1], Elts.size() - 1)); 1385932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1386bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien V = ConstantExpr::getGetElementPtr(Elts[0], 1387bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien llvm::ArrayRef<llvm::Constant*>(&Elts[1], Elts.size() - 1)); 1388932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1389932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1390932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_SELECT: // CE_SELECT: [opval#, opval#, opval#] 1391932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) return Error("Invalid CE_SELECT record"); 1392932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0], 1393932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type::getInt1Ty(Context)), 1394932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.getConstantFwdRef(Record[1],CurTy), 1395932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.getConstantFwdRef(Record[2],CurTy)); 1396932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1397932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval] 1398932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) return Error("Invalid CE_EXTRACTELT record"); 1399932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = 1400932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1401932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy == 0) return Error("Invalid CE_EXTRACTELT record"); 1402932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1403932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 1404932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getExtractElement(Op0, Op1); 1405932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1406932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1407932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval] 1408932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1409932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || OpTy == 0) 1410932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CE_INSERTELT record"); 1411932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 1412932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[1], 1413932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpTy->getElementType()); 1414932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 1415932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getInsertElement(Op0, Op1, Op2); 1416932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1417932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1418932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] 1419932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1420932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || OpTy == 0) 1421932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CE_SHUFFLEVEC record"); 1422932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 1423932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); 1424932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 1425932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpTy->getNumElements()); 1426932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy); 1427932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 1428932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1429932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1430932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval] 1431932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *RTy = dyn_cast<VectorType>(CurTy); 1432932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = 1433932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1434932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 4 || RTy == 0 || OpTy == 0) 1435932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CE_SHUFVEC_EX record"); 1436932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1437932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 1438932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 1439932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines RTy->getNumElements()); 1440932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy); 1441932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 1442932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1443932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1444932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] 1445932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 4) return Error("Invalid CE_CMP record"); 1446932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 1447932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy == 0) return Error("Invalid CE_CMP record"); 1448932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1449932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 1450932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1451932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy->isFPOrFPVectorTy()) 1452932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getFCmp(Record[3], Op0, Op1); 1453932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1454932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getICmp(Record[3], Op0, Op1); 1455932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1456932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1457932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_INLINEASM: { 1458932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) return Error("Invalid INLINEASM record"); 1459932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string AsmStr, ConstrStr; 1460932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool HasSideEffects = Record[0] & 1; 1461932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool IsAlignStack = Record[0] >> 1; 1462932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AsmStrSize = Record[1]; 1463932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (2+AsmStrSize >= Record.size()) 1464932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INLINEASM record"); 1465932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ConstStrSize = Record[2+AsmStrSize]; 1466932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (3+AsmStrSize+ConstStrSize > Record.size()) 1467932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INLINEASM record"); 1468932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1469932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != AsmStrSize; ++i) 1470932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AsmStr += (char)Record[2+i]; 1471932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != ConstStrSize; ++i) 1472932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ConstrStr += (char)Record[3+AsmStrSize+i]; 1473932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *PTy = cast<PointerType>(CurTy); 1474932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), 1475932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AsmStr, ConstrStr, HasSideEffects, IsAlignStack); 1476932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1477932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1478932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_BLOCKADDRESS:{ 1479932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) return Error("Invalid CE_BLOCKADDRESS record"); 1480932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *FnTy = getTypeByID(Record[0]); 1481932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FnTy == 0) return Error("Invalid CE_BLOCKADDRESS record"); 1482932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *Fn = 1483932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy)); 1484932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Fn == 0) return Error("Invalid CE_BLOCKADDRESS record"); 1485932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1486932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalVariable *FwdRef = new GlobalVariable(*Fn->getParent(), 1487932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type::getInt8Ty(Context), 1488932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines false, GlobalValue::InternalLinkage, 1489932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 0, ""); 1490932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BlockAddrFwdRefs[Fn].push_back(std::make_pair(Record[2], FwdRef)); 1491932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = FwdRef; 1492932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1493932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1494932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1495932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1496932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.AssignValue(V, NextCstNo); 1497932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++NextCstNo; 1498932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1499932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1500932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextCstNo != ValueList.size()) 1501932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid constant reference!"); 1502932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1503932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 1504932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Error at end of constants block"); 1505932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1506932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Once all the constants have been read, go through and resolve forward 1507932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // references. 1508932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.ResolveConstantForwardRefs(); 1509932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 1510932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1511932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1512932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// RememberAndSkipFunctionBody - When we see the block for a function body, 1513932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// remember where it is and then skip it. This lets us lazily deserialize the 1514932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// functions. 1515932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::RememberAndSkipFunctionBody() { 1516932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Get the function we are talking about. 1517932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FunctionsWithBodies.empty()) 1518932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Insufficient function protos"); 1519932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1520932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *Fn = FunctionsWithBodies.back(); 1521932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionsWithBodies.pop_back(); 1522932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1523932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Save the current stream state. 1524932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t CurBit = Stream.GetCurrentBitNo(); 1525932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DeferredFunctionInfo[Fn] = CurBit; 1526932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1527932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Skip over the function block for now. 1528932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1529932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 1530932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 1531932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1532932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1533932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseModule() { 1534932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 1535932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 1536932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1537932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1538932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::string> SectionTable; 1539932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::string> GCTable; 1540932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1541932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this module. 1542932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!Stream.AtEndOfStream()) { 1543932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 1544932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 1545932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 1546932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Error at end of module block"); 1547932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1548932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Patch the initializers for globals and aliases up. 1549932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveGlobalAndAliasInits(); 1550932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!GlobalInits.empty() || !AliasInits.empty()) 1551932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed global initializer set"); 1552932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FunctionsWithBodies.empty()) 1553932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Too few function bodies found"); 1554932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1555932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Look for intrinsic functions which need to be upgraded at some point 1556932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); 1557932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FI != FE; ++FI) { 1558932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function* NewFn; 1559932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (UpgradeIntrinsicFunction(FI, NewFn)) 1560932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn)); 1561932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1562932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1563932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Look for global variables which need to be renamed. 1564932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Module::global_iterator 1565932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GI = TheModule->global_begin(), GE = TheModule->global_end(); 1566932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GI != GE; ++GI) 1567932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradeGlobalVariable(GI); 1568932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1569932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Force deallocation of memory for these vectors to favor the client that 1570932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // want lazy deserialization. 1571932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); 1572932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); 1573932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Function*>().swap(FunctionsWithBodies); 1574932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 1575932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1576932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1577932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 1578932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadSubBlockID()) { 1579932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Skip unknown content. 1580932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1581932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 1582932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1583932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BLOCKINFO_BLOCK_ID: 1584932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockInfoBlock()) 1585932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed BlockInfoBlock"); 1586932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1587932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::PARAMATTR_BLOCK_ID: 1588932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseAttributeBlock()) 1589932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 1590932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1591932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_BLOCK_ID_NEW: 1592932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseTypeTable()) 1593932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 1594932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1595932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_BLOCK_ID_OLD: 1596932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseOldTypeTable()) 1597932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 1598932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1599932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_SYMTAB_BLOCK_ID_OLD: 1600932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseOldTypeSymbolTable()) 1601932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 1602932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1603932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VALUE_SYMTAB_BLOCK_ID: 1604932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseValueSymbolTable()) 1605932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 1606932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1607932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CONSTANTS_BLOCK_ID: 1608932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseConstants() || ResolveGlobalAndAliasInits()) 1609932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 1610932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1611932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_BLOCK_ID: 1612932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseMetadata()) 1613932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 1614932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1615932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNCTION_BLOCK_ID: 1616932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this is the first function body we've seen, reverse the 1617932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FunctionsWithBodies list. 1618932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!HasReversedFunctionsWithBodies) { 1619932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end()); 1620932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines HasReversedFunctionsWithBodies = true; 1621932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1622932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1623932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (RememberAndSkipFunctionBody()) 1624932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 1625932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1626932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1627932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1628932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1629932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1630932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 1631932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 1632932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1633932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1634932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1635932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1636932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadRecord(Code, Record)) { 1637932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: break; // Default behavior, ignore unknown content. 1638932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_VERSION: // VERSION: [version#] 1639932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 1640932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed MODULE_CODE_VERSION"); 1641932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Only version #0 is supported so far. 1642932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[0] != 0) 1643932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Unknown bitstream version!"); 1644932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1645932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 1646932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1647932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1648932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_CODE_TRIPLE record"); 1649932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule->setTargetTriple(S); 1650932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1651932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1652932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] 1653932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1654932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1655932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_CODE_DATALAYOUT record"); 1656932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule->setDataLayout(S); 1657932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1658932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1659932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] 1660932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1661932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1662932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_CODE_ASM record"); 1663932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule->setModuleInlineAsm(S); 1664932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1665932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1666932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N] 1667932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1668932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1669932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_CODE_DEPLIB record"); 1670932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule->addLibrary(S); 1671932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1672932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1673932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] 1674932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1675932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1676932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_CODE_SECTIONNAME record"); 1677932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SectionTable.push_back(S); 1678932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1679932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1680932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N] 1681932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1682932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1683932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_CODE_GCNAME record"); 1684932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GCTable.push_back(S); 1685932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1686932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1687932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // GLOBALVAR: [pointer type, isconst, initid, 1688932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // linkage, alignment, section, visibility, threadlocal, 1689932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // unnamed_addr] 1690932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_GLOBALVAR: { 1691932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 6) 1692932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_CODE_GLOBALVAR record"); 1693932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 1694932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty) return Error("Invalid MODULE_CODE_GLOBALVAR record"); 1695932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty->isPointerTy()) 1696932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Global not a pointer type!"); 1697932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); 1698932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Ty = cast<PointerType>(Ty)->getElementType(); 1699932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1700932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool isConstant = Record[1]; 1701932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]); 1702932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Alignment = (1 << Record[4]) >> 1; 1703932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string Section; 1704932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[5]) { 1705932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[5]-1 >= SectionTable.size()) 1706932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid section ID"); 1707932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Section = SectionTable[Record[5]-1]; 1708932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1709932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; 1710932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 6) 1711932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Visibility = GetDecodedVisibility(Record[6]); 1712932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool isThreadLocal = false; 1713932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 7) 1714932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines isThreadLocal = Record[7]; 1715932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1716932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool UnnamedAddr = false; 1717932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 8) 1718932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UnnamedAddr = Record[8]; 1719932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1720932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalVariable *NewGV = 1721932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines new GlobalVariable(*TheModule, Ty, isConstant, Linkage, 0, "", 0, 1722932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines isThreadLocal, AddressSpace); 1723932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setAlignment(Alignment); 1724932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Section.empty()) 1725932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setSection(Section); 1726932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setVisibility(Visibility); 1727932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setThreadLocal(isThreadLocal); 1728932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setUnnamedAddr(UnnamedAddr); 1729932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1730932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(NewGV); 1731932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1732932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Remember which value to use for the global initializer. 1733932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (unsigned InitID = Record[2]) 1734932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInits.push_back(std::make_pair(NewGV, InitID-1)); 1735932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1736932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1737932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FUNCTION: [type, callingconv, isproto, linkage, paramattr, 1738932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // alignment, section, visibility, gc, unnamed_addr] 1739932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_FUNCTION: { 1740932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 8) 1741932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_CODE_FUNCTION record"); 1742932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 1743932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty) return Error("Invalid MODULE_CODE_FUNCTION record"); 1744932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty->isPointerTy()) 1745932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Function not a pointer type!"); 1746932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionType *FTy = 1747932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType()); 1748932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy) 1749932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Function not a pointer to function type!"); 1750932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1751932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, 1752932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines "", TheModule); 1753932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1754932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setCallingConv(static_cast<CallingConv::ID>(Record[1])); 1755932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool isProto = Record[2]; 1756932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setLinkage(GetDecodedLinkage(Record[3])); 1757932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setAttributes(getAttributes(Record[4])); 1758932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1759932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setAlignment((1 << Record[5]) >> 1); 1760932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[6]) { 1761932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[6]-1 >= SectionTable.size()) 1762932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid section ID"); 1763932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setSection(SectionTable[Record[6]-1]); 1764932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1765932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setVisibility(GetDecodedVisibility(Record[7])); 1766932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 8 && Record[8]) { 1767932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[8]-1 > GCTable.size()) 1768932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid GC ID"); 1769932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setGC(GCTable[Record[8]-1].c_str()); 1770932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1771932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool UnnamedAddr = false; 1772932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 9) 1773932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UnnamedAddr = Record[9]; 1774932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setUnnamedAddr(UnnamedAddr); 1775932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(Func); 1776932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1777932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this is a function with a body, remember the prototype we are 1778932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // creating now, so that we can match up the body with them later. 1779932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!isProto) 1780932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionsWithBodies.push_back(Func); 1781932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1782932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1783932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // ALIAS: [alias type, aliasee val#, linkage] 1784932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // ALIAS: [alias type, aliasee val#, linkage, visibility] 1785932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_ALIAS: { 1786932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 1787932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_ALIAS record"); 1788932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 1789932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty) return Error("Invalid MODULE_ALIAS record"); 1790932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty->isPointerTy()) 1791932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Function not a pointer type!"); 1792932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1793932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]), 1794932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines "", 0, TheModule); 1795932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Old bitcode files didn't have visibility field. 1796932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 3) 1797932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGA->setVisibility(GetDecodedVisibility(Record[3])); 1798932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(NewGA); 1799932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInits.push_back(std::make_pair(NewGA, Record[1])); 1800932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1801932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1802932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// MODULE_CODE_PURGEVALS: [numvals] 1803932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_PURGEVALS: 1804932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Trim down the value list to the specified size. 1805932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1 || Record[0] > ValueList.size()) 1806932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_PURGEVALS record"); 1807932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.shrinkTo(Record[0]); 1808932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1809932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1810932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1811932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1812932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1813932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Premature end of bitstream"); 1814932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1815932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1816932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseBitcodeInto(Module *M) { 1817932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule = 0; 1818932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1819932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned char *BufPtr = (unsigned char *)Buffer->getBufferStart(); 1820932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); 1821932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1822932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Buffer->getBufferSize() & 3) { 1823932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!isRawBitcode(BufPtr, BufEnd) && !isBitcodeWrapper(BufPtr, BufEnd)) 1824932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid bitcode signature"); 1825932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1826932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Bitcode stream should be a multiple of 4 bytes in length"); 1827932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1828932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1829932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we have a wrapper header, parse it and ignore the non-bc file contents. 1830932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // The magic number is 0x0B17C0DE stored in little endian. 1831932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (isBitcodeWrapper(BufPtr, BufEnd)) 1832932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (SkipBitcodeWrapperHeader(BufPtr, BufEnd)) 1833932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid bitcode wrapper header"); 1834932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1835932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StreamFile.init(BufPtr, BufEnd); 1836932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.init(StreamFile); 1837932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1838932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Sniff for the signature. 1839932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.Read(8) != 'B' || 1840932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(8) != 'C' || 1841932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0x0 || 1842932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xC || 1843932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xE || 1844932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xD) 1845932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid bitcode signature"); 1846932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1847932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We expect a number of well-defined blocks, though we don't necessarily 1848932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // need to understand them all. 1849932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!Stream.AtEndOfStream()) { 1850932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 1851932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1852932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code != bitc::ENTER_SUBBLOCK) { 1853932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1854932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // The ranlib in xcode 4 will align archive members by appending newlines to the 1855932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // end of them. If this file size is a multiple of 4 but not 8, we have to read and 1856932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // ignore these final 4 bytes :-( 1857932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.GetAbbrevIDWidth() == 2 && Code == 2 && 1858932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a && 1859932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.AtEndOfStream()) 1860932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 1861932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1862932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid record at top-level"); 1863932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1864932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1865932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned BlockID = Stream.ReadSubBlockID(); 1866932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1867932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We only know the MODULE subblock ID. 1868932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (BlockID) { 1869932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BLOCKINFO_BLOCK_ID: 1870932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockInfoBlock()) 1871932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed BlockInfoBlock"); 1872932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1873932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_BLOCK_ID: 1874932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Reject multiple MODULE_BLOCK's in a single bitstream. 1875932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TheModule) 1876932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Multiple MODULE_BLOCKs in same stream"); 1877932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule = M; 1878932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseModule()) 1879932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 1880932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1881932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: 1882932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1883932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 1884932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1885932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1886932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1887932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1888932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 1889932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1890932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1891932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseModuleTriple(std::string &Triple) { 1892932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 1893932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 1894932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1895932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1896932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1897932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this module. 1898932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!Stream.AtEndOfStream()) { 1899932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 1900932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 1901932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 1902932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Error at end of module block"); 1903932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1904932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 1905932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1906932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1907932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 1908932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadSubBlockID()) { 1909932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Skip unknown content. 1910932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1911932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 1912932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1913932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1914932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1915932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1916932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1917932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 1918932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 1919932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1920932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1921932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1922932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1923932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadRecord(Code, Record)) { 1924932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: break; // Default behavior, ignore unknown content. 1925932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_VERSION: // VERSION: [version#] 1926932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 1927932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed MODULE_CODE_VERSION"); 1928932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Only version #0 is supported so far. 1929932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[0] != 0) 1930932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Unknown bitstream version!"); 1931932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1932932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 1933932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 1934932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 1935932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MODULE_CODE_TRIPLE record"); 1936932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Triple = S; 1937932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1938932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1939932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1940932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1941932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1942932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1943932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Premature end of bitstream"); 1944932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1945932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1946932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseTriple(std::string &Triple) { 1947932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Buffer->getBufferSize() & 3) 1948932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Bitcode stream should be a multiple of 4 bytes in length"); 1949932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1950932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned char *BufPtr = (unsigned char *)Buffer->getBufferStart(); 1951932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); 1952932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1953932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we have a wrapper header, parse it and ignore the non-bc file contents. 1954932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // The magic number is 0x0B17C0DE stored in little endian. 1955932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (isBitcodeWrapper(BufPtr, BufEnd)) 1956932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (SkipBitcodeWrapperHeader(BufPtr, BufEnd)) 1957932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid bitcode wrapper header"); 1958932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1959932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StreamFile.init(BufPtr, BufEnd); 1960932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.init(StreamFile); 1961932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1962932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Sniff for the signature. 1963932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.Read(8) != 'B' || 1964932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(8) != 'C' || 1965932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0x0 || 1966932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xC || 1967932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xE || 1968932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xD) 1969932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid bitcode signature"); 1970932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1971932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We expect a number of well-defined blocks, though we don't necessarily 1972932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // need to understand them all. 1973932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!Stream.AtEndOfStream()) { 1974932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 1975932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1976932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code != bitc::ENTER_SUBBLOCK) 1977932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid record at top-level"); 1978932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1979932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned BlockID = Stream.ReadSubBlockID(); 1980932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1981932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We only know the MODULE subblock ID. 1982932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (BlockID) { 1983932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_BLOCK_ID: 1984932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseModuleTriple(Triple)) 1985932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 1986932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1987932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: 1988932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 1989932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 1990932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1991932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1992932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1993932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1994932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 1995932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1996932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1997932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ParseMetadataAttachment - Parse metadata attachments. 1998932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseMetadataAttachment() { 1999932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) 2000932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 2001932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2002932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 2003932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while(1) { 2004932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 2005932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 2006932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 2007932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Error at end of PARAMATTR block"); 2008932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2009932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2010932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 2011932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 2012932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2013932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2014932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a metadata attachment record. 2015932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 2016932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadRecord(Code, Record)) { 2017932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: ignore. 2018932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2019932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case METADATA_ATTACHMENT_2_7: 2020932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 2021932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_ATTACHMENT: { 2022932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned RecordLength = Record.size(); 2023932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty() || (RecordLength - 1) % 2 == 1) 2024932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error ("Invalid METADATA_ATTACHMENT reader!"); 2025932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Instruction *Inst = InstructionList[Record[0]]; 2026932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1; i != RecordLength; i = i+2) { 2027932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Kind = Record[i]; 2028932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DenseMap<unsigned, unsigned>::iterator I = 2029932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDKindMap.find(Kind); 2030932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I == MDKindMap.end()) 2031932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid metadata kind ID"); 2032932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Node = MDValueList.getValueFwdRef(Record[i+1]); 2033932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Inst->setMetadata(I->second, cast<MDNode>(Node)); 2034932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2035932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2036932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2037932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2038932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2039932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 2040932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2041932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2042932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ParseFunctionBody - Lazily parse the specified function body block. 2043932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::ParseFunctionBody(Function *F) { 2044932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) 2045932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 2046932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2047932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.clear(); 2048932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ModuleValueListSize = ValueList.size(); 2049932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ModuleMDValueListSize = MDValueList.size(); 2050932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2051932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Add all the function arguments to the value table. 2052932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) 2053932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(I); 2054932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2055932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextValueNo = ValueList.size(); 2056932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *CurBB = 0; 2057932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned CurBBNo = 0; 2058932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2059932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DebugLoc LastLoc; 2060932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2061932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records. 2062932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 2063932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 2064932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 2065932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 2066932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 2067932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Error at end of function block"); 2068932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2069932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2070932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2071932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 2072932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadSubBlockID()) { 2073932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Skip unknown content. 2074932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 2075932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Malformed block record"); 2076932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2077932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CONSTANTS_BLOCK_ID: 2078932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseConstants()) return true; 2079932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NextValueNo = ValueList.size(); 2080932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2081932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VALUE_SYMTAB_BLOCK_ID: 2082932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseValueSymbolTable()) return true; 2083932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2084932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_ATTACHMENT_ID: 2085932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseMetadataAttachment()) return true; 2086932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2087932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_BLOCK_ID: 2088932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseMetadata()) return true; 2089932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2090932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2091932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2092932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2093932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2094932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 2095932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 2096932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2097932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2098932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2099932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 2100932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 2101932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Instruction *I = 0; 2102932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned BitCode = Stream.ReadRecord(Code, Record); 2103932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (BitCode) { 2104932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: reject 2105932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Unknown instruction"); 2106932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks] 2107932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1 || Record[0] == 0) 2108932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid DECLAREBLOCKS record"); 2109932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create all the basic blocks for the function. 2110932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionBBs.resize(Record[0]); 2111932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) 2112932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionBBs[i] = BasicBlock::Create(Context, "", F); 2113932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurBB = FunctionBBs[0]; 2114932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2115932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2116932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN 2117932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // This record indicates that the last instruction is at the same 2118932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // location as the previous instruction with a location. 2119932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; 2120932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2121932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Get the last instruction emitted. 2122932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CurBB && !CurBB->empty()) 2123932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &CurBB->back(); 2124932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurBBNo && FunctionBBs[CurBBNo-1] && 2125932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines !FunctionBBs[CurBBNo-1]->empty()) 2126932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &FunctionBBs[CurBBNo-1]->back(); 2127932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2128932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I == 0) return Error("Invalid DEBUG_LOC_AGAIN record"); 2129932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->setDebugLoc(LastLoc); 2130932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; 2131932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2132932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2133932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_DEBUG_LOC_2_7: 2134932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 2135932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia] 2136932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; // Get the last instruction emitted. 2137932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CurBB && !CurBB->empty()) 2138932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &CurBB->back(); 2139932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurBBNo && FunctionBBs[CurBBNo-1] && 2140932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines !FunctionBBs[CurBBNo-1]->empty()) 2141932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &FunctionBBs[CurBBNo-1]->back(); 2142932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I == 0 || Record.size() < 4) 2143932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid FUNC_CODE_DEBUG_LOC record"); 2144932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2145932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Line = Record[0], Col = Record[1]; 2146932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ScopeID = Record[2], IAID = Record[3]; 2147932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2148932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDNode *Scope = 0, *IA = 0; 2149932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ScopeID) Scope = cast<MDNode>(MDValueList.getValueFwdRef(ScopeID-1)); 2150932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (IAID) IA = cast<MDNode>(MDValueList.getValueFwdRef(IAID-1)); 2151932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LastLoc = DebugLoc::get(Line, Col, Scope, IA); 2152932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->setDebugLoc(LastLoc); 2153932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = 0; 2154932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2155932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2156932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2157932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode] 2158932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2159932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *LHS, *RHS; 2160932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 2161932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, LHS->getType(), RHS) || 2162932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+1 > Record.size()) 2163932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid BINOP record"); 2164932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2165932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); 2166932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc == -1) return Error("Invalid BINOP record"); 2167932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); 2168932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2169932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpNum < Record.size()) { 2170932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc == Instruction::Add || 2171932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Sub || 2172932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Mul || 2173932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Shl) { 2174932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 2175932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<BinaryOperator>(I)->setHasNoSignedWrap(true); 2176932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 2177932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true); 2178932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (Opc == Instruction::SDiv || 2179932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::UDiv || 2180932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::LShr || 2181932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::AShr) { 2182932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[OpNum] & (1 << bitc::PEO_EXACT)) 2183932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<BinaryOperator>(I)->setIsExact(true); 2184932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2185932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2186932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2187932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2188932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc] 2189932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2190932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2191932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2192932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) 2193932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CAST record"); 2194932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2195932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ResTy = getTypeByID(Record[OpNum]); 2196932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedCastOpcode(Record[OpNum+1]); 2197932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc == -1 || ResTy == 0) 2198932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CAST record"); 2199932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy); 2200932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2201932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2202932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2203932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INBOUNDS_GEP: 2204932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands] 2205932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2206932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *BasePtr; 2207932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) 2208932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid GEP record"); 2209932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2210932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 16> GEPIdx; 2211932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (OpNum != Record.size()) { 2212932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2213932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2214932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid GEP record"); 2215932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GEPIdx.push_back(Op); 2216932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2217932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2218bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien I = GetElementPtrInst::Create(BasePtr, GEPIdx); 2219932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2220932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP) 2221932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<GetElementPtrInst>(I)->setIsInBounds(true); 2222932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2223932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2224932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2225932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_EXTRACTVAL: { 2226932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // EXTRACTVAL: [opty, opval, n x indices] 2227932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2228932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Agg; 2229932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2230932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid EXTRACTVAL record"); 2231932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2232932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<unsigned, 4> EXTRACTVALIdx; 2233932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned RecSize = Record.size(); 2234932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum != RecSize; ++OpNum) { 2235932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t Index = Record[OpNum]; 2236932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((unsigned)Index != Index) 2237932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid EXTRACTVAL index"); 2238932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EXTRACTVALIdx.push_back((unsigned)Index); 2239932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2240932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2241932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ExtractValueInst::Create(Agg, EXTRACTVALIdx); 2242932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2243932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2244932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2245932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2246932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INSERTVAL: { 2247932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // INSERTVAL: [opty, opval, opty, opval, n x indices] 2248932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2249932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Agg; 2250932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2251932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INSERTVAL record"); 2252932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Val; 2253932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Val)) 2254932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INSERTVAL record"); 2255932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2256932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<unsigned, 4> INSERTVALIdx; 2257932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned RecSize = Record.size(); 2258932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum != RecSize; ++OpNum) { 2259932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t Index = Record[OpNum]; 2260932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((unsigned)Index != Index) 2261932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INSERTVAL index"); 2262932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines INSERTVALIdx.push_back((unsigned)Index); 2263932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2264932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2265932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = InsertValueInst::Create(Agg, Val, INSERTVALIdx); 2266932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2267932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2268932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2269932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2270932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval] 2271932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // obsolete form of select 2272932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // handles select i1 ... in old bitcode 2273932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2274932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *TrueVal, *FalseVal, *Cond; 2275932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 2276932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 2277932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Type::getInt1Ty(Context), Cond)) 2278932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid SELECT record"); 2279932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2280932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = SelectInst::Create(Cond, TrueVal, FalseVal); 2281932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2282932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2283932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2284932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2285932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred] 2286932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // new form of select 2287932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // handles select i1 or select [N x i1] 2288932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2289932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *TrueVal, *FalseVal, *Cond; 2290932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 2291932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 2292932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValueTypePair(Record, OpNum, NextValueNo, Cond)) 2293932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid SELECT record"); 2294932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2295932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // select condition can be either i1 or [N x i1] 2296932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (VectorType* vector_type = 2297932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast<VectorType>(Cond->getType())) { 2298932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // expect <n x i1> 2299932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (vector_type->getElementType() != Type::getInt1Ty(Context)) 2300932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid SELECT condition type"); 2301932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2302932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // expect i1 2303932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Cond->getType() != Type::getInt1Ty(Context)) 2304932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid SELECT condition type"); 2305932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2306932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2307932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = SelectInst::Create(Cond, TrueVal, FalseVal); 2308932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2309932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2310932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2311932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2312932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval] 2313932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2314932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Vec, *Idx; 2315932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 2316932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 2317932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid EXTRACTELT record"); 2318932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ExtractElementInst::Create(Vec, Idx); 2319932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2320932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2321932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2322932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2323932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval] 2324932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2325932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Vec, *Elt, *Idx; 2326932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 2327932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, 2328932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<VectorType>(Vec->getType())->getElementType(), Elt) || 2329932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 2330932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INSERTELT record"); 2331932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = InsertElementInst::Create(Vec, Elt, Idx); 2332932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2333932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2334932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2335932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2336932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval] 2337932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2338932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Vec1, *Vec2, *Mask; 2339932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) || 2340932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Vec1->getType(), Vec2)) 2341932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid SHUFFLEVEC record"); 2342932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2343932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) 2344932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid SHUFFLEVEC record"); 2345932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new ShuffleVectorInst(Vec1, Vec2, Mask); 2346932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2347932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2348932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2349932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2350932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred] 2351932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Old form of ICmp/FCmp returning bool 2352932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were 2353932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // both legal on vectors but had different behaviour. 2354932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred] 2355932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FCmp/ICmp returning bool or vector of bool 2356932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2357932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2358932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *LHS, *RHS; 2359932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 2360932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, LHS->getType(), RHS) || 2361932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+1 != Record.size()) 2362932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CMP record"); 2363932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2364932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (LHS->getType()->isFPOrFPVectorTy()) 2365932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); 2366932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 2367932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS); 2368932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2369932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2370932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2371932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2372932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_GETRESULT_2_7: { 2373932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != 2) { 2374932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid GETRESULT record"); 2375932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2376932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2377932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2378932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValueTypePair(Record, OpNum, NextValueNo, Op); 2379932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Index = Record[1]; 2380932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ExtractValueInst::Create(Op, Index); 2381932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2382932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2383932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2384932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2385932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>] 2386932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines { 2387932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 2388932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Size == 0) { 2389932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ReturnInst::Create(Context); 2390932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2391932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2392932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2393932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2394932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2395932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op = NULL; 2396932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2397932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid RET record"); 2398932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpNum != Record.size()) 2399932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid RET record"); 2400932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2401932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ReturnInst::Create(Context, Op); 2402932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2403932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2404932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2405932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] 2406932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != 1 && Record.size() != 3) 2407932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid BR record"); 2408932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *TrueDest = getBasicBlock(Record[0]); 2409932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TrueDest == 0) 2410932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid BR record"); 2411932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2412932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() == 1) { 2413932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = BranchInst::Create(TrueDest); 2414932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2415932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2416932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else { 2417932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *FalseDest = getBasicBlock(Record[1]); 2418932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Cond = getFnValueByID(Record[2], Type::getInt1Ty(Context)); 2419932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FalseDest == 0 || Cond == 0) 2420932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid BR record"); 2421932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = BranchInst::Create(TrueDest, FalseDest, Cond); 2422932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2423932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2424932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2425932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2426932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...] 2427932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || (Record.size() & 1) == 0) 2428932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid SWITCH record"); 2429932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 2430932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Cond = getFnValueByID(Record[1], OpTy); 2431932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *Default = getBasicBlock(Record[2]); 2432932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy == 0 || Cond == 0 || Default == 0) 2433932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid SWITCH record"); 2434932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumCases = (Record.size()-3)/2; 2435932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); 2436932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(SI); 2437932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = NumCases; i != e; ++i) { 2438932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ConstantInt *CaseVal = 2439932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy)); 2440932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); 2441932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CaseVal == 0 || DestBB == 0) { 2442932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete SI; 2443932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid SWITCH record!"); 2444932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2445932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SI->addCase(CaseVal, DestBB); 2446932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2447932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = SI; 2448932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2449932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2450932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] 2451932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 2452932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INDIRECTBR record"); 2453932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 2454932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Address = getFnValueByID(Record[1], OpTy); 2455932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy == 0 || Address == 0) 2456932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INDIRECTBR record"); 2457932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumDests = Record.size()-2; 2458932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); 2459932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(IBI); 2460932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = NumDests; i != e; ++i) { 2461932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) { 2462932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IBI->addDestination(DestBB); 2463932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2464932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete IBI; 2465932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INDIRECTBR record!"); 2466932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2467932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2468932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = IBI; 2469932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2470932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2471932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2472932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INVOKE: { 2473932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] 2474932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 4) return Error("Invalid INVOKE record"); 2475932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AttrListPtr PAL = getAttributes(Record[0]); 2476932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned CCInfo = Record[1]; 2477932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *NormalBB = getBasicBlock(Record[2]); 2478932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *UnwindBB = getBasicBlock(Record[3]); 2479932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2480932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 4; 2481932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Callee; 2482932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 2483932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INVOKE record"); 2484932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2485932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); 2486932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionType *FTy = !CalleeTy ? 0 : 2487932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast<FunctionType>(CalleeTy->getElementType()); 2488932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2489932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check that the right number of fixed parameters are here. 2490932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FTy == 0 || NormalBB == 0 || UnwindBB == 0 || 2491932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.size() < OpNum+FTy->getNumParams()) 2492932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INVOKE record"); 2493932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2494932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 16> Ops; 2495932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 2496932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Ops.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 2497932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Ops.back() == 0) return Error("Invalid INVOKE record"); 2498932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2499932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2500932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy->isVarArg()) { 2501932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != OpNum) 2502932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INVOKE record"); 2503932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2504932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read type/value pairs for varargs params. 2505932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (OpNum != Record.size()) { 2506932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2507932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2508932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid INVOKE record"); 2509932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Ops.push_back(Op); 2510932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2511932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2512932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2513932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops); 2514932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2515932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<InvokeInst>(I)->setCallingConv( 2516932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static_cast<CallingConv::ID>(CCInfo)); 2517932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<InvokeInst>(I)->setAttributes(PAL); 2518932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2519932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2520932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_UNWIND: // UNWIND 2521932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new UnwindInst(Context); 2522932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2523932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2524932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE 2525932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new UnreachableInst(Context); 2526932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2527932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2528932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...] 2529932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1 || ((Record.size()-1)&1)) 2530932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid PHI record"); 2531932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 2532932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty) return Error("Invalid PHI record"); 2533932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2534932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2); 2535932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(PN); 2536932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2537932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) { 2538932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = getFnValueByID(Record[1+i], Ty); 2539932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *BB = getBasicBlock(Record[2+i]); 2540932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!V || !BB) return Error("Invalid PHI record"); 2541932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PN->addIncoming(V, BB); 2542932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2543932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = PN; 2544932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2545932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2546932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2547932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_MALLOC_2_7: { // MALLOC: [instty, op, align] 2548932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Autoupgrade malloc instruction to malloc call. 2549932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME: Remove in LLVM 3.0. 2550932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) { 2551932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid MALLOC record"); 2552932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2553932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *Ty = 2554932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<PointerType>(getTypeByID(Record[0])); 2555932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Size = getFnValueByID(Record[1], Type::getInt32Ty(Context)); 2556932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty || !Size) return Error("Invalid MALLOC record"); 2557932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!CurBB) return Error("Invalid malloc instruction with no BB"); 2558932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Int32Ty = IntegerType::getInt32Ty(CurBB->getContext()); 2559932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *AllocSize = ConstantExpr::getSizeOf(Ty->getElementType()); 2560932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, Int32Ty); 2561932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CallInst::CreateMalloc(CurBB, Int32Ty, Ty->getElementType(), 2562932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AllocSize, Size, NULL); 2563932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2564932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2565932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2566932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_FREE_2_7: { // FREE: [op, opty] 2567932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2568932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2569932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2570932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum != Record.size()) { 2571932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid FREE record"); 2572932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2573932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!CurBB) return Error("Invalid free instruction with no BB"); 2574932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CallInst::CreateFree(Op, CurBB); 2575932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2576932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2577932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2578932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2579932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align] 2580932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // For backward compatibility, tolerate a lack of an opty, and use i32. 2581932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Remove this in LLVM 3.0. 2582932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || Record.size() > 4) { 2583932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid ALLOCA record"); 2584932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2585932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2586932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *Ty = 2587932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<PointerType>(getTypeByID(Record[OpNum++])); 2588932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = Record.size() == 4 ? getTypeByID(Record[OpNum++]) : 2589932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type::getInt32Ty(Context); 2590932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Size = getFnValueByID(Record[OpNum++], OpTy); 2591932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Align = Record[OpNum++]; 2592932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty || !Size) return Error("Invalid ALLOCA record"); 2593932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); 2594932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2595932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2596932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2597932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol] 2598932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2599932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2600932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2601932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) 2602932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid LOAD record"); 2603932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2604932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2605932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2606932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2607932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2608932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_STORE: { // STORE2:[ptrty, ptr, val, align, vol] 2609932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2610932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Val, *Ptr; 2611932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 2612932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, 2613932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<PointerType>(Ptr->getType())->getElementType(), Val) || 2614932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) 2615932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid STORE record"); 2616932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2617932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2618932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2619932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2620932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2621932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_STORE_2_7: { 2622932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2623932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Val, *Ptr; 2624932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Val) || 2625932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, 2626932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType::getUnqual(Val->getType()), Ptr)|| 2627932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) { 2628932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid STORE record"); 2629932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2630932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2631932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2632932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2633932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2634932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_CALL_2_7: 2635932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 2636932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CALL: { 2637932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] 2638932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 2639932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CALL record"); 2640932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2641932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AttrListPtr PAL = getAttributes(Record[0]); 2642932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned CCInfo = Record[1]; 2643932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2644932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 2; 2645932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Callee; 2646932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 2647932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CALL record"); 2648932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2649932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); 2650932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionType *FTy = 0; 2651932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType()); 2652932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy || Record.size() < FTy->getNumParams()+OpNum) 2653932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CALL record"); 2654932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2655932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 16> Args; 2656932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read the fixed params. 2657932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 2658932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FTy->getParamType(i)->isLabelTy()) 2659932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Args.push_back(getBasicBlock(Record[OpNum])); 2660932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 2661932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Args.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 2662932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Args.back() == 0) return Error("Invalid CALL record"); 2663932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2664932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2665932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read type/value pairs for varargs params. 2666932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy->isVarArg()) { 2667932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpNum != Record.size()) 2668932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CALL record"); 2669932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2670932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (OpNum != Record.size()) { 2671932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2672932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2673932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid CALL record"); 2674932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Args.push_back(Op); 2675932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2676932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2677932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2678932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CallInst::Create(Callee, Args); 2679932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2680932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<CallInst>(I)->setCallingConv( 2681932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static_cast<CallingConv::ID>(CCInfo>>1)); 2682932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<CallInst>(I)->setTailCall(CCInfo & 1); 2683932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<CallInst>(I)->setAttributes(PAL); 2684932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2685932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2686932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] 2687932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 2688932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid VAARG record"); 2689932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 2690932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op = getFnValueByID(Record[1], OpTy); 2691932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ResTy = getTypeByID(Record[2]); 2692932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!OpTy || !Op || !ResTy) 2693932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid VAARG record"); 2694932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new VAArgInst(Op, ResTy); 2695932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2696932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2697932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2698932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2699932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2700932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Add instruction to end of current BB. If there is no current BB, reject 2701932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // this file. 2702932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CurBB == 0) { 2703932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete I; 2704932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid instruction with no BB"); 2705932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2706932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurBB->getInstList().push_back(I); 2707932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2708932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this was a terminator instruction, move to the next block. 2709932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (isa<TerminatorInst>(I)) { 2710932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++CurBBNo; 2711932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0; 2712932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2713932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2714932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Non-void values get registered in the value table for future use. 2715932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I && !I->getType()->isVoidTy()) 2716932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.AssignValue(I, NextValueNo++); 2717932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2718932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2719932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check the function list for unresolved values. 2720932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Argument *A = dyn_cast<Argument>(ValueList.back())) { 2721932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (A->getParent() == 0) { 2722932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We found at least one unresolved value. Nuke them all to avoid leaks. 2723932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){ 2724932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((A = dyn_cast<Argument>(ValueList[i])) && A->getParent() == 0) { 2725932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines A->replaceAllUsesWith(UndefValue::get(A->getType())); 2726932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete A; 2727932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2728932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2729932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Never resolved value found in function!"); 2730932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2731932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2732932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2733932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME: Check for unresolved forward-declared metadata references 2734932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // and clean up leaks. 2735932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2736932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // See if anything took the address of blocks in this function. If so, 2737932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // resolve them now. 2738932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DenseMap<Function*, std::vector<BlockAddrRefTy> >::iterator BAFRI = 2739932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BlockAddrFwdRefs.find(F); 2740932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BAFRI != BlockAddrFwdRefs.end()) { 2741932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<BlockAddrRefTy> &RefList = BAFRI->second; 2742932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = RefList.size(); i != e; ++i) { 2743932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned BlockIdx = RefList[i].first; 2744932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BlockIdx >= FunctionBBs.size()) 2745932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Error("Invalid blockaddress block #"); 2746932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2747932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalVariable *FwdRef = RefList[i].second; 2748932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx])); 2749932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FwdRef->eraseFromParent(); 2750932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2751932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2752932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BlockAddrFwdRefs.erase(BAFRI); 2753932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2754932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2755932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NewMDValueListSize = MDValueList.size(); 2756932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Trim the value list down to the size it was before we parsed this function. 2757932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.shrinkTo(ModuleValueListSize); 2758932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.shrinkTo(ModuleMDValueListSize); 2759932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2760932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (LLVM2_7MetadataDetected) { 2761932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.resize(NewMDValueListSize); 2762932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2763932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2764932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<BasicBlock*>().swap(FunctionBBs); 2765932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 2766932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2767932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2768932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 2769932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// GVMaterializer implementation 2770932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 2771932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2772932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2773932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::isMaterializable(const GlobalValue *GV) const { 2774932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (const Function *F = dyn_cast<Function>(GV)) { 2775932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return F->isDeclaration() && 2776932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DeferredFunctionInfo.count(const_cast<Function*>(F)); 2777932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2778932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 2779932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2780932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2781932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::Materialize(GlobalValue *GV, std::string *ErrInfo) { 2782932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *F = dyn_cast<Function>(GV); 2783932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If it's not a function or is already material, ignore the request. 2784932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!F || !F->isMaterializable()) return false; 2785932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2786932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F); 2787932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!"); 2788932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2789932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Move the bit stream to the saved position of the deferred function body. 2790932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.JumpToBit(DFII->second); 2791932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2792932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ParseFunctionBody(F)) { 2793932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ErrInfo) *ErrInfo = ErrorString; 2794932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 2795932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2796932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2797932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Upgrade any old intrinsic calls in the function. 2798932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(), 2799932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines E = UpgradedIntrinsics.end(); I != E; ++I) { 2800932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I->first != I->second) { 2801932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Value::use_iterator UI = I->first->use_begin(), 2802932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UE = I->first->use_end(); UI != UE; ) { 2803932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 2804932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradeIntrinsicCall(CI, I->second); 2805932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2806932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2807932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2808932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2809932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 2810932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2811932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2812932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::isDematerializable(const GlobalValue *GV) const { 2813932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines const Function *F = dyn_cast<Function>(GV); 2814932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!F || F->isDeclaration()) 2815932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 2816932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return DeferredFunctionInfo.count(const_cast<Function*>(F)); 2817932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2818932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2819932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReader::Dematerialize(GlobalValue *GV) { 2820932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *F = dyn_cast<Function>(GV); 2821932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this function isn't dematerializable, this is a noop. 2822932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!F || !isDematerializable(F)) 2823932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 2824932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2825932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(DeferredFunctionInfo.count(F) && "No info to read function later?"); 2826932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2827932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Just forget the function body, we can remat it later. 2828932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines F->deleteBody(); 2829932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2830932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2831932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2832932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::MaterializeModule(Module *M, std::string *ErrInfo) { 2833932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(M == TheModule && 2834932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines "Can only Materialize the Module this BitcodeReader is attached to."); 2835932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Iterate over the module, deserializing any functions that are still on 2836932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // disk. 2837932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Module::iterator F = TheModule->begin(), E = TheModule->end(); 2838932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines F != E; ++F) 2839932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (F->isMaterializable() && 2840932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Materialize(F, ErrInfo)) 2841932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 2842932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2843932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Upgrade any intrinsic calls that slipped through (should not happen!) and 2844932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // delete the old functions to clean up. We can't do this unless the entire 2845932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // module is materialized because there could always be another function body 2846932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // with calls to the old function. 2847932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (std::vector<std::pair<Function*, Function*> >::iterator I = 2848932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) { 2849932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I->first != I->second) { 2850932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Value::use_iterator UI = I->first->use_begin(), 2851932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UE = I->first->use_end(); UI != UE; ) { 2852932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 2853932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradeIntrinsicCall(CI, I->second); 2854932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2855932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!I->first->use_empty()) 2856932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->first->replaceAllUsesWith(I->second); 2857932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->first->eraseFromParent(); 2858932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2859932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2860932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics); 2861932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2862932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check debug info intrinsics. 2863932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CheckDebugInfoIntrinsics(TheModule); 2864932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2865932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 2866932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2867932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2868932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2869932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 2870932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// External interface 2871932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 2872932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2873932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// getLazyBitcodeModule - lazy function-at-a-time loading from a file. 2874932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// 2875932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesModule *llvm_2_7::getLazyBitcodeModule(MemoryBuffer *Buffer, 2876932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVMContext& Context, 2877932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string *ErrMsg) { 2878932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Module *M = new Module(Buffer->getBufferIdentifier(), Context); 2879932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BitcodeReader *R = new BitcodeReader(Buffer, Context); 2880932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines M->setMaterializer(R); 2881932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (R->ParseBitcodeInto(M)) { 2882932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ErrMsg) 2883932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines *ErrMsg = R->getErrorString(); 2884932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2885932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete M; // Also deletes R. 2886932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return 0; 2887932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2888932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Have the BitcodeReader dtor delete 'Buffer'. 2889932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines R->setBufferOwned(true); 2890932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return M; 2891932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2892932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2893932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ParseBitcodeFile - Read the specified bitcode file, returning the module. 2894932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// If an error occurs, return null and fill in *ErrMsg if non-null. 2895932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesModule *llvm_2_7::ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext& Context, 2896932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string *ErrMsg){ 2897932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Module *M = llvm_2_7::getLazyBitcodeModule(Buffer, Context, ErrMsg); 2898932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!M) return 0; 2899932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2900932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether 2901932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // there was an error. 2902932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static_cast<BitcodeReader*>(M->getMaterializer())->setBufferOwned(false); 2903932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2904932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read in the entire module, and destroy the BitcodeReader. 2905932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (M->MaterializeAllPermanently(ErrMsg)) { 2906932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete M; 2907932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return 0; 2908932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2909932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2910932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return M; 2911932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2912932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2913932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstd::string llvm_2_7::getBitcodeTargetTriple(MemoryBuffer *Buffer, 2914932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVMContext& Context, 2915932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string *ErrMsg) { 2916932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BitcodeReader *R = new BitcodeReader(Buffer, Context); 2917932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Don't let the BitcodeReader dtor delete 'Buffer'. 2918932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines R->setBufferOwned(false); 2919932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2920932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string Triple(""); 2921932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (R->ParseTriple(Triple)) 2922932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ErrMsg) 2923932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines *ErrMsg = R->getErrorString(); 2924932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2925932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete R; 2926932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Triple; 2927932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2928