BitcodeReader.cpp revision f5b49a0ca149b09c8306b86db9f3aca703c4acd5
1932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===- BitcodeReader.cpp - Internal BitcodeReader implementation ----------===// 2932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// 3932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// The LLVM Compiler Infrastructure 4932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// 5932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// This file is distributed under the University of Illinois Open Source 6932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// License. See LICENSE.TXT for details. 7932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// 8932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 9932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// 10932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// This header defines the BitcodeReader class. 11932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// 12932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 13932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 14c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao#include "llvm/Bitcode/ReaderWriter.h" 15d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines#include "BitReader_2_7.h" 165cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines#include "llvm/ADT/STLExtras.h" 17932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/ADT/SmallString.h" 18932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/ADT/SmallVector.h" 19c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray#include "llvm/IR/AutoUpgrade.h" 20b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/Constants.h" 21b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/DerivedTypes.h" 221bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines#include "llvm/IR/DiagnosticPrinter.h" 235cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines#include "llvm/IR/GVMaterializer.h" 24b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/InlineAsm.h" 25b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/IntrinsicInst.h" 261bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines#include "llvm/IR/LLVMContext.h" 27b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/Module.h" 28b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/OperandTraits.h" 29b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/Operator.h" 301bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines#include "llvm/Support/ManagedStatic.h" 31932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/Support/MathExtras.h" 32932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#include "llvm/Support/MemoryBuffer.h" 33c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 34932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesusing namespace llvm; 35932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesusing namespace llvm_2_7; 36932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 37932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define METADATA_NODE_2_7 2 38932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define METADATA_FN_NODE_2_7 3 39932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define METADATA_NAMED_NODE_2_7 5 40932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define METADATA_ATTACHMENT_2_7 7 41c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao#define FUNC_CODE_INST_UNWIND_2_7 14 42932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define FUNC_CODE_INST_MALLOC_2_7 17 43932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define FUNC_CODE_INST_FREE_2_7 18 44932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define FUNC_CODE_INST_STORE_2_7 21 45932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define FUNC_CODE_INST_CALL_2_7 22 46932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define FUNC_CODE_INST_GETRESULT_2_7 25 47932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines#define FUNC_CODE_DEBUG_LOC_2_7 32 48932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 49be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien#define TYPE_BLOCK_ID_OLD_3_0 10 50be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien#define TYPE_SYMTAB_BLOCK_ID_OLD_3_0 13 51be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien#define TYPE_CODE_STRUCT_OLD_3_0 10 52be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien 53be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chiennamespace { 54c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray 55c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray void StripDebugInfoOfFunction(Module* M, const char* name) { 56c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray if (Function* FuncStart = M->getFunction(name)) { 57c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray while (!FuncStart->use_empty()) { 58c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray cast<CallInst>(*FuncStart->use_begin())->eraseFromParent(); 59c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray } 60c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray FuncStart->eraseFromParent(); 61c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray } 62c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray } 63c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray 64be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien /// This function strips all debug info intrinsics, except for llvm.dbg.declare. 65be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien /// If an llvm.dbg.declare intrinsic is invalid, then this function simply 66be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien /// strips that use. 67be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien void CheckDebugInfoIntrinsics(Module *M) { 68c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray StripDebugInfoOfFunction(M, "llvm.dbg.func.start"); 69c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray StripDebugInfoOfFunction(M, "llvm.dbg.stoppoint"); 70c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray StripDebugInfoOfFunction(M, "llvm.dbg.region.start"); 71c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray StripDebugInfoOfFunction(M, "llvm.dbg.region.end"); 72b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 73be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (Function *Declare = M->getFunction("llvm.dbg.declare")) { 74be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (!Declare->use_empty()) { 75c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray DbgDeclareInst *DDI = cast<DbgDeclareInst>(*Declare->use_begin()); 761bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines if (!isa<MDNode>(ValueAsMetadata::get(DDI->getArgOperand(0))) || 771bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines !isa<MDNode>(ValueAsMetadata::get(DDI->getArgOperand(1)))) { 78be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien while (!Declare->use_empty()) { 79c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray CallInst *CI = cast<CallInst>(*Declare->use_begin()); 80be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien CI->eraseFromParent(); 81be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien } 82be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien Declare->eraseFromParent(); 83be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien } 84be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien } 85be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien } 86be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien } 875cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 885cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines//===----------------------------------------------------------------------===// 895cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines// BitcodeReaderValueList Class 905cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines//===----------------------------------------------------------------------===// 915cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 925cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hinesclass BitcodeReaderValueList { 935cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::vector<WeakVH> ValuePtrs; 945cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 955cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// ResolveConstants - As we resolve forward-referenced constants, we add 965cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// information about them to this vector. This allows us to resolve them in 975cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// bulk instead of resolving each reference at a time. See the code in 985cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// ResolveConstantForwardRefs for more information about this. 995cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// 1005cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// The key of this vector is the placeholder constant, the value is the slot 1015cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// number that holds the resolved value. 1025cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines typedef std::vector<std::pair<Constant*, unsigned> > ResolveConstantsTy; 1035cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines ResolveConstantsTy ResolveConstants; 1045cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines LLVMContext &Context; 1055cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hinespublic: 1067e920a716693033edf32a6fedd03798bbfbd85ebChih-Hung Hsieh explicit BitcodeReaderValueList(LLVMContext &C) : Context(C) {} 1075cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines ~BitcodeReaderValueList() { 1085cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines assert(ResolveConstants.empty() && "Constants not resolved?"); 1095cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines } 1105cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 1115cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines // vector compatibility methods 1125cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines unsigned size() const { return ValuePtrs.size(); } 1135cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines void resize(unsigned N) { ValuePtrs.resize(N); } 1145cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines void push_back(Value *V) { 1155cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines ValuePtrs.push_back(V); 1165cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines } 1175cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 1185cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines void clear() { 1195cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines assert(ResolveConstants.empty() && "Constants not resolved?"); 1205cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines ValuePtrs.clear(); 1215cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines } 1225cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 1235cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines Value *operator[](unsigned i) const { 1245cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines assert(i < ValuePtrs.size()); 1255cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines return ValuePtrs[i]; 1265cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines } 1275cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 1285cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines Value *back() const { return ValuePtrs.back(); } 1295cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines void pop_back() { ValuePtrs.pop_back(); } 1305cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines bool empty() const { return ValuePtrs.empty(); } 1315cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines void shrinkTo(unsigned N) { 1325cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines assert(N <= size() && "Invalid shrinkTo request!"); 1335cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines ValuePtrs.resize(N); 1345cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines } 1355cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 1365cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines Constant *getConstantFwdRef(unsigned Idx, Type *Ty); 1375cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines Value *getValueFwdRef(unsigned Idx, Type *Ty); 1385cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 1395cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines void AssignValue(Value *V, unsigned Idx); 1405cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 1415cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// ResolveConstantForwardRefs - Once all constants are read, this method bulk 1425cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// resolves any forward references. 1435cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines void ResolveConstantForwardRefs(); 1445cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines}; 1455cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 1465cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 1475cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines//===----------------------------------------------------------------------===// 1485cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines// BitcodeReaderMDValueList Class 1495cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines//===----------------------------------------------------------------------===// 1505cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 1515cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hinesclass BitcodeReaderMDValueList { 1525cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines unsigned NumFwdRefs; 1535cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines bool AnyFwdRefs; 1545cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::vector<TrackingMDRef> MDValuePtrs; 1555cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 1565cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines LLVMContext &Context; 1575cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hinespublic: 1587e920a716693033edf32a6fedd03798bbfbd85ebChih-Hung Hsieh explicit BitcodeReaderMDValueList(LLVMContext &C) 1595cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines : NumFwdRefs(0), AnyFwdRefs(false), Context(C) {} 1605cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 1615cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines // vector compatibility methods 1625cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines unsigned size() const { return MDValuePtrs.size(); } 1635cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines void resize(unsigned N) { MDValuePtrs.resize(N); } 1645cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines void push_back(Metadata *MD) { MDValuePtrs.emplace_back(MD); } 1655cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines void clear() { MDValuePtrs.clear(); } 1665cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines Metadata *back() const { return MDValuePtrs.back(); } 1675cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines void pop_back() { MDValuePtrs.pop_back(); } 1685cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines bool empty() const { return MDValuePtrs.empty(); } 1695cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 1705cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines Metadata *operator[](unsigned i) const { 1715cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines assert(i < MDValuePtrs.size()); 1725cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines return MDValuePtrs[i]; 1735cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines } 1745cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 1755cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines void shrinkTo(unsigned N) { 1765cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines assert(N <= size() && "Invalid shrinkTo request!"); 1775cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines MDValuePtrs.resize(N); 1785cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines } 1795cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 1805cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines Metadata *getValueFwdRef(unsigned Idx); 1815cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines void AssignValue(Metadata *MD, unsigned Idx); 1825cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines void tryToResolveCycles(); 1835cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines}; 1845cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 1855cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hinesclass BitcodeReader : public GVMaterializer { 1865cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines LLVMContext &Context; 1875cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines DiagnosticHandlerFunction DiagnosticHandler; 1885cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines Module *TheModule; 1895cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::unique_ptr<MemoryBuffer> Buffer; 1905cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::unique_ptr<BitstreamReader> StreamFile; 1915cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines BitstreamCursor Stream; 192f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar std::unique_ptr<DataStreamer> LazyStreamer; 1935cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines uint64_t NextUnreadBit; 1945cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines bool SeenValueSymbolTable; 1955cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 1965cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::vector<Type*> TypeList; 1975cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines BitcodeReaderValueList ValueList; 1985cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines BitcodeReaderMDValueList MDValueList; 1995cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines SmallVector<Instruction *, 64> InstructionList; 2005cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2015cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits; 2025cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::vector<std::pair<GlobalAlias*, unsigned> > AliasInits; 2035cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2045cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// MAttributes - The set of attributes by index. Index zero in the 2055cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// file is for null, and is thus not represented here. As such all indices 2065cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// are off by one. 2075cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::vector<AttributeSet> MAttributes; 2085cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2095cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// \brief The set of attribute groups. 2105cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::map<unsigned, AttributeSet> MAttributeGroups; 2115cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2125cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// FunctionBBs - While parsing a function body, this is a list of the basic 2135cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// blocks for the function. 2145cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::vector<BasicBlock*> FunctionBBs; 2155cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2165cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines // When reading the module header, this list is populated with functions that 2175cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines // have bodies later in the file. 2185cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::vector<Function*> FunctionsWithBodies; 2195cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2205cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines // When intrinsic functions are encountered which require upgrading they are 2215cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines // stored here with their replacement function. 2225cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines typedef std::vector<std::pair<Function*, Function*> > UpgradedIntrinsicMap; 2235cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines UpgradedIntrinsicMap UpgradedIntrinsics; 2245cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2255cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines // Map the bitcode's custom MDKind ID to the Module's MDKind ID. 2265cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines DenseMap<unsigned, unsigned> MDKindMap; 2275cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2285cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines // Several operations happen after the module header has been read, but 2295cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines // before function bodies are processed. This keeps track of whether 2305cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines // we've done this yet. 2315cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines bool SeenFirstFunctionBody; 2325cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2335cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// DeferredFunctionInfo - When function bodies are initially scanned, this 2345cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// map contains info about where to find deferred function body in the 2355cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// stream. 2365cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines DenseMap<Function*, uint64_t> DeferredFunctionInfo; 2375cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2385cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// BlockAddrFwdRefs - These are blockaddr references to basic blocks. These 2395cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// are resolved lazily when functions are loaded. 2405cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines typedef std::pair<unsigned, GlobalVariable*> BlockAddrRefTy; 2415cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines DenseMap<Function*, std::vector<BlockAddrRefTy> > BlockAddrFwdRefs; 2425cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2435cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// LLVM2_7MetadataDetected - True if metadata produced by LLVM 2.7 or 2445cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// earlier was detected, in which case we behave slightly differently, 2455cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// for compatibility. 2465cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// FIXME: Remove in LLVM 3.0. 2475cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines bool LLVM2_7MetadataDetected; 2485cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines static const std::error_category &BitcodeErrorCategory(); 2495cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2505cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hinespublic: 2515cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code Error(BitcodeError E, const Twine &Message); 2525cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code Error(BitcodeError E); 2535cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code Error(const Twine &Message); 2545cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2555cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines explicit BitcodeReader(MemoryBuffer *buffer, LLVMContext &C, 2565cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines DiagnosticHandlerFunction DiagnosticHandler); 2575cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines ~BitcodeReader() { FreeState(); } 2585cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2595cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines void FreeState(); 2605cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2615cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines void releaseBuffer(); 2625cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 263f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar bool isDematerializable(const GlobalValue *GV) const; 2645cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code materialize(GlobalValue *GV) override; 265f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar std::error_code materializeModule() override; 2665cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::vector<StructType *> getIdentifiedStructTypes() const override; 267f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar void dematerialize(GlobalValue *GV); 2685cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2695cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// @brief Main interface to parsing a bitcode buffer. 2705cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// @returns true if an error occurred. 2715cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code ParseBitcodeInto(Module *M); 2725cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2735cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// @brief Cheap mechanism to just extract module triple 2745cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// @returns true if an error occurred. 2755cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines llvm::ErrorOr<std::string> parseTriple(); 2765cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2775cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines static uint64_t decodeSignRotatedValue(uint64_t V); 2785cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2795cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// Materialize any deferred Metadata block. 2805cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code materializeMetadata() override; 2815cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 28298137cca7eebca946b869b010fef2821c9bf4971Pirama Arumuga Nainar void setStripDebugInfo() override; 28398137cca7eebca946b869b010fef2821c9bf4971Pirama Arumuga Nainar 2845cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hinesprivate: 2855cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::vector<StructType *> IdentifiedStructTypes; 2865cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines StructType *createIdentifiedStructType(LLVMContext &Context, StringRef Name); 2875cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines StructType *createIdentifiedStructType(LLVMContext &Context); 2885cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2895cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines Type *getTypeByID(unsigned ID); 2905cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines Type *getTypeByIDOrNull(unsigned ID); 2915cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines Value *getFnValueByID(unsigned ID, Type *Ty) { 2925cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines if (Ty && Ty->isMetadataTy()) 2935cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines return MetadataAsValue::get(Ty->getContext(), getFnMetadataByID(ID)); 2945cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines return ValueList.getValueFwdRef(ID, Ty); 2955cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines } 2965cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines Metadata *getFnMetadataByID(unsigned ID) { 2975cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines return MDValueList.getValueFwdRef(ID); 2985cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines } 2995cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines BasicBlock *getBasicBlock(unsigned ID) const { 3005cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines if (ID >= FunctionBBs.size()) return nullptr; // Invalid ID 3015cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines return FunctionBBs[ID]; 3025cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines } 3035cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines AttributeSet getAttributes(unsigned i) const { 3045cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines if (i-1 < MAttributes.size()) 3055cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines return MAttributes[i-1]; 3065cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines return AttributeSet(); 3075cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines } 3085cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 3095cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// getValueTypePair - Read a value/type pair out of the specified record from 3105cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// slot 'Slot'. Increment Slot past the number of slots used in the record. 3115cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines /// Return true on failure. 3125cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines bool getValueTypePair(SmallVectorImpl<uint64_t> &Record, unsigned &Slot, 3135cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines unsigned InstNum, Value *&ResVal) { 3145cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines if (Slot == Record.size()) return true; 3155cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines unsigned ValNo = (unsigned)Record[Slot++]; 3165cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines if (ValNo < InstNum) { 3175cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines // If this is not a forward reference, just return the value we already 3185cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines // have. 3195cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines ResVal = getFnValueByID(ValNo, nullptr); 3205cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines return ResVal == nullptr; 3215cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines } else if (Slot == Record.size()) { 3225cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines return true; 3235cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines } 3245cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 3255cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines unsigned TypeNo = (unsigned)Record[Slot++]; 3265cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines ResVal = getFnValueByID(ValNo, getTypeByID(TypeNo)); 3275cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines return ResVal == nullptr; 3285cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines } 3295cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines bool getValue(SmallVector<uint64_t, 64> &Record, unsigned &Slot, 3305cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines Type *Ty, Value *&ResVal) { 3315cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines if (Slot == Record.size()) return true; 3325cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines unsigned ValNo = (unsigned)Record[Slot++]; 3335cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines ResVal = getFnValueByID(ValNo, Ty); 3345cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines return ResVal == 0; 3355cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines } 3365cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 3375cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 3385cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code ParseModule(bool Resume); 3395cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code ParseAttributeBlock(); 3405cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code ParseTypeTable(); 3415cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code ParseOldTypeTable(); // FIXME: Remove in LLVM 3.1 3425cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code ParseTypeTableBody(); 3435cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 3445cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code ParseOldTypeSymbolTable(); // FIXME: Remove in LLVM 3.1 3455cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code ParseValueSymbolTable(); 3465cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code ParseConstants(); 3475cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code RememberAndSkipFunctionBody(); 3485cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code ParseFunctionBody(Function *F); 3495cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code GlobalCleanup(); 3505cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code ResolveGlobalAndAliasInits(); 3515cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code ParseMetadata(); 3525cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code ParseMetadataAttachment(); 3535cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines llvm::ErrorOr<std::string> parseModuleTriple(); 3545cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code InitStream(); 3555cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code InitStreamFromBuffer(); 3565cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines std::error_code InitLazyStream(); 3575cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines}; 358be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien} // end anonymous namespace 359be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien 3608a019dd0040bedf5078e4d18e06a244a675b80e8Chih-Hung Hsiehstatic std::error_code Error(const DiagnosticHandlerFunction &DiagnosticHandler, 3611bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines std::error_code EC, const Twine &Message) { 3621bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines BitcodeDiagnosticInfo DI(EC, DS_Error, Message); 3631bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines DiagnosticHandler(DI); 3641bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return EC; 3651bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines} 3661bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 3678a019dd0040bedf5078e4d18e06a244a675b80e8Chih-Hung Hsiehstatic std::error_code Error(const DiagnosticHandlerFunction &DiagnosticHandler, 3681bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines std::error_code EC) { 3691bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error(DiagnosticHandler, EC, EC.message()); 3701bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines} 3711bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 3721bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hinesstd::error_code BitcodeReader::Error(BitcodeError E, const Twine &Message) { 3731bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return ::Error(DiagnosticHandler, make_error_code(E), Message); 3741bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines} 3751bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 3761bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hinesstd::error_code BitcodeReader::Error(const Twine &Message) { 3771bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return ::Error(DiagnosticHandler, 3781bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines make_error_code(BitcodeError::CorruptedBitcode), Message); 3791bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines} 3801bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 3811bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hinesstd::error_code BitcodeReader::Error(BitcodeError E) { 3821bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return ::Error(DiagnosticHandler, make_error_code(E)); 3831bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines} 3841bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 3851bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hinesstatic DiagnosticHandlerFunction getDiagHandler(DiagnosticHandlerFunction F, 3861bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines LLVMContext &C) { 3871bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines if (F) 3881bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return F; 3891bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return [&C](const DiagnosticInfo &DI) { C.diagnose(DI); }; 3901bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines} 3911bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 3921bd9f627fa0affb457507e86b0b6684c695fe726Stephen HinesBitcodeReader::BitcodeReader(MemoryBuffer *buffer, LLVMContext &C, 3931bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines DiagnosticHandlerFunction DiagnosticHandler) 3941bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines : Context(C), DiagnosticHandler(getDiagHandler(DiagnosticHandler, C)), 3951bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines TheModule(nullptr), Buffer(buffer), LazyStreamer(nullptr), 3961bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines NextUnreadBit(0), SeenValueSymbolTable(false), ValueList(C), 3971bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines MDValueList(C), SeenFirstFunctionBody(false), 3981bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines LLVM2_7MetadataDetected(false) {} 3991bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 4001bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 401932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReader::FreeState() { 402579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Buffer = nullptr; 403932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Type*>().swap(TypeList); 404932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.clear(); 405932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.clear(); 406932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 407b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines std::vector<AttributeSet>().swap(MAttributes); 408932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<BasicBlock*>().swap(FunctionBBs); 409932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Function*>().swap(FunctionsWithBodies); 410932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DeferredFunctionInfo.clear(); 411932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDKindMap.clear(); 412932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 413932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 414932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 415932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// Helper functions to implement forward reference resolution, etc. 416932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 417932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 418932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ConvertToString - Convert a string from a record into an std::string, return 419932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// true on failure. 420932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinestemplate<typename StrTy> 4211bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hinesstatic bool ConvertToString(ArrayRef<uint64_t> Record, unsigned Idx, 422932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StrTy &Result) { 423932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx > Record.size()) 424932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return true; 425932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 426932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = Idx, e = Record.size(); i != e; ++i) 427932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Result += (char)Record[i]; 428932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 429932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 430932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 4311bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hinesstatic GlobalValue::LinkageTypes getDecodedLinkage(unsigned Val) { 432932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Val) { 433932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Map unknown/new linkages to external 4341bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case 0: 4351bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return GlobalValue::ExternalLinkage; 4361bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case 1: 4371bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return GlobalValue::WeakAnyLinkage; 4381bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case 2: 4391bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return GlobalValue::AppendingLinkage; 4401bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case 3: 4411bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return GlobalValue::InternalLinkage; 4421bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case 4: 4431bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return GlobalValue::LinkOnceAnyLinkage; 4441bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case 5: 4451bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return GlobalValue::ExternalLinkage; // Obsolete DLLImportLinkage 4461bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case 6: 4471bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return GlobalValue::ExternalLinkage; // Obsolete DLLExportLinkage 4481bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case 7: 4491bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return GlobalValue::ExternalWeakLinkage; 4501bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case 8: 4511bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return GlobalValue::CommonLinkage; 4521bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case 9: 4531bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return GlobalValue::PrivateLinkage; 4541bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case 10: 4551bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return GlobalValue::WeakODRLinkage; 4561bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case 11: 4571bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return GlobalValue::LinkOnceODRLinkage; 4581bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case 12: 4591bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return GlobalValue::AvailableExternallyLinkage; 4601bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case 13: 4611bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return GlobalValue::PrivateLinkage; // Obsolete LinkerPrivateLinkage 4621bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case 14: 4631bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return GlobalValue::ExternalWeakLinkage; // Obsolete LinkerPrivateWeakLinkage 464d724d097437f40a5689464429f948ec41e4a2415Stephen Hines //ANDROID: convert LinkOnceODRAutoHideLinkage -> LinkOnceODRLinkage 4651bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case 15: 4661bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return GlobalValue::LinkOnceODRLinkage; 467932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 468932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 469932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 470932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) { 471932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Val) { 472932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Map unknown visibilities to default. 473932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 0: return GlobalValue::DefaultVisibility; 474932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 1: return GlobalValue::HiddenVisibility; 475932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case 2: return GlobalValue::ProtectedVisibility; 476932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 477932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 478932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 4798b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liaostatic GlobalVariable::ThreadLocalMode GetDecodedThreadLocalMode(unsigned Val) { 4808b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao switch (Val) { 4818b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 0: return GlobalVariable::NotThreadLocal; 4828b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao default: // Map unknown non-zero value to general dynamic. 4838b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 1: return GlobalVariable::GeneralDynamicTLSModel; 4848b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 2: return GlobalVariable::LocalDynamicTLSModel; 4858b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 3: return GlobalVariable::InitialExecTLSModel; 4868b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 4: return GlobalVariable::LocalExecTLSModel; 4878b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao } 4888b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao} 4898b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao 490f5b49a0ca149b09c8306b86db9f3aca703c4acd5Pirama Arumuga Nainarstatic GlobalVariable::UnnamedAddr getDecodedUnnamedAddrType(unsigned Val) { 491f5b49a0ca149b09c8306b86db9f3aca703c4acd5Pirama Arumuga Nainar switch (Val) { 492f5b49a0ca149b09c8306b86db9f3aca703c4acd5Pirama Arumuga Nainar default: // Map unknown to UnnamedAddr::None. 493f5b49a0ca149b09c8306b86db9f3aca703c4acd5Pirama Arumuga Nainar case 0: return GlobalVariable::UnnamedAddr::None; 494f5b49a0ca149b09c8306b86db9f3aca703c4acd5Pirama Arumuga Nainar case 1: return GlobalVariable::UnnamedAddr::Global; 495f5b49a0ca149b09c8306b86db9f3aca703c4acd5Pirama Arumuga Nainar case 2: return GlobalVariable::UnnamedAddr::Local; 496f5b49a0ca149b09c8306b86db9f3aca703c4acd5Pirama Arumuga Nainar } 497f5b49a0ca149b09c8306b86db9f3aca703c4acd5Pirama Arumuga Nainar} 498f5b49a0ca149b09c8306b86db9f3aca703c4acd5Pirama Arumuga Nainar 499932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic int GetDecodedCastOpcode(unsigned Val) { 500932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Val) { 501932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: return -1; 502932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_TRUNC : return Instruction::Trunc; 503932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_ZEXT : return Instruction::ZExt; 504932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_SEXT : return Instruction::SExt; 505932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPTOUI : return Instruction::FPToUI; 506932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPTOSI : return Instruction::FPToSI; 507932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_UITOFP : return Instruction::UIToFP; 508932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_SITOFP : return Instruction::SIToFP; 509932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPTRUNC : return Instruction::FPTrunc; 510932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_FPEXT : return Instruction::FPExt; 511932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_PTRTOINT: return Instruction::PtrToInt; 512932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_INTTOPTR: return Instruction::IntToPtr; 513932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CAST_BITCAST : return Instruction::BitCast; 514932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 515932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 516932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstatic int GetDecodedBinaryOpcode(unsigned Val, Type *Ty) { 517932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Val) { 518932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: return -1; 519932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_ADD: 520932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FAdd : Instruction::Add; 521932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SUB: 522932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FSub : Instruction::Sub; 523932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_MUL: 524932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FMul : Instruction::Mul; 525932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_UDIV: return Instruction::UDiv; 526932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SDIV: 527932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FDiv : Instruction::SDiv; 528932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_UREM: return Instruction::URem; 529932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SREM: 530932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty->isFPOrFPVectorTy() ? Instruction::FRem : Instruction::SRem; 531932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_SHL: return Instruction::Shl; 532932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_LSHR: return Instruction::LShr; 533932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_ASHR: return Instruction::AShr; 534932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_AND: return Instruction::And; 535932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_OR: return Instruction::Or; 536932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BINOP_XOR: return Instruction::Xor; 537932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 538932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 539932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 540932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesnamespace llvm { 541932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesnamespace { 542932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// @brief A class for maintaining the slot number definition 543932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// as a placeholder for the actual definition for forward constants defs. 544932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines class ConstantPlaceHolder : public ConstantExpr { 5451bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines void operator=(const ConstantPlaceHolder &) = delete; 546932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines public: 547932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // allocate space for exactly one operand 548932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines void *operator new(size_t s) { 549932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return User::operator new(s, 1); 550932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 551932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines explicit ConstantPlaceHolder(Type *Ty, LLVMContext& Context) 552932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) { 553932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Op<0>() = UndefValue::get(Type::getInt32Ty(Context)); 554932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 555932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 556932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// @brief Methods to support type inquiry through isa, cast, and dyn_cast. 557932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static bool classof(const Value *V) { 558932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return isa<ConstantExpr>(V) && 559932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1; 560932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 561932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 562932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 563932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// Provide fast operand accessors 5641bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 565932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines }; 566932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 567932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 568932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// FIXME: can we inherit this from ConstantExpr? 569932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinestemplate <> 570932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesstruct OperandTraits<ConstantPlaceHolder> : 571932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines public FixedNumOperandTraits<ConstantPlaceHolder, 1> { 572932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines}; 5731bd9f627fa0affb457507e86b0b6684c695fe726Stephen HinesDEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantPlaceHolder, Value) 574932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 575932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 576932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 577932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) { 578932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx == size()) { 579932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines push_back(V); 580932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 581932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 582932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 583932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 584932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx+1); 585932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 586932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines WeakVH &OldV = ValuePtrs[Idx]; 587579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!OldV) { 588932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV = V; 589932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 590932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 591932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 592932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Handle constants and non-constants (e.g. instrs) differently for 593932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // efficiency. 594932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Constant *PHC = dyn_cast<Constant>(&*OldV)) { 595932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveConstants.push_back(std::make_pair(PHC, Idx)); 596932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV = V; 597932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 598932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If there was a forward reference to this value, replace it. 599932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *PrevVal = OldV; 600932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OldV->replaceAllUsesWith(V); 601932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete PrevVal; 602932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 603932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 604932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 605932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 606932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesConstant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, 607932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty) { 608932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 609932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx + 1); 610932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 611932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Value *V = ValuePtrs[Idx]) { 612932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(Ty == V->getType() && "Type mismatch in constant table!"); 613932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return cast<Constant>(V); 614932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 615932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 616932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create and return a placeholder, which will later be RAUW'd. 617932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *C = new ConstantPlaceHolder(Ty, Context); 618932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValuePtrs[Idx] = C; 619932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return C; 620932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 621932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 622932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesValue *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty) { 623932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 624932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx + 1); 625932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 626932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Value *V = ValuePtrs[Idx]) { 627579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines assert((!Ty || Ty == V->getType()) && "Type mismatch in value table!"); 628932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V; 629932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 630932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 631932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No type specified, must be invalid reference. 632579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!Ty) return nullptr; 633932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 634932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create and return a placeholder, which will later be RAUW'd. 635932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = new Argument(Ty); 636932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValuePtrs[Idx] = V; 637932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V; 638932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 639932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 640932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ResolveConstantForwardRefs - Once all constants are read, this method bulk 641932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// resolves any forward references. The idea behind this is that we sometimes 642932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// get constants (such as large arrays) which reference *many* forward ref 643932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// constants. Replacing each of these causes a lot of thrashing when 644932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// building/reuniquing the constant. Instead of doing this, we look at all the 645932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// uses and rewrite all the place holders at once for any constant that uses 646932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// a placeholder. 647932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesvoid BitcodeReaderValueList::ResolveConstantForwardRefs() { 648932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Sort the values by-pointer so that they are efficient to look up with a 649932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // binary search. 650932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::sort(ResolveConstants.begin(), ResolveConstants.end()); 651932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 652932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Constant*, 64> NewOps; 653932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 654932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!ResolveConstants.empty()) { 655932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *RealVal = operator[](ResolveConstants.back().second); 656932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Placeholder = ResolveConstants.back().first; 657932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveConstants.pop_back(); 658932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 659932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Loop over all users of the placeholder, updating them to reference the 660932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // new value. If they reference more than one placeholder, update them all 661932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // at once. 662932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!Placeholder->use_empty()) { 6631bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines auto UI = Placeholder->user_begin(); 6641bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines User *U = *UI; 665932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 666932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If the using object isn't uniqued, just update the operands. This 667932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // handles instructions and initializers for global variables. 668932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!isa<Constant>(U) || isa<GlobalValue>(U)) { 6691bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines UI.getUse().set(RealVal); 670932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 671932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 672932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 673932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Otherwise, we have a constant that uses the placeholder. Replace that 674932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // constant with a new constant that has *all* placeholder uses updated. 675932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *UserC = cast<Constant>(U); 676932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (User::op_iterator I = UserC->op_begin(), E = UserC->op_end(); 677932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I != E; ++I) { 678932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *NewOp; 679932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!isa<ConstantPlaceHolder>(*I)) { 680932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Not a placeholder reference. 681932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOp = *I; 682932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (*I == Placeholder) { 683932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Common case is that it just references this one placeholder. 684932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOp = RealVal; 685932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 686932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Otherwise, look up the placeholder in ResolveConstants. 687932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveConstantsTy::iterator It = 688932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::lower_bound(ResolveConstants.begin(), ResolveConstants.end(), 689932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::pair<Constant*, unsigned>(cast<Constant>(*I), 690932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 0)); 691932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(It != ResolveConstants.end() && It->first == *I); 692932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOp = operator[](It->second); 693932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 694932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 695932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOps.push_back(cast<Constant>(NewOp)); 696932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 697932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 698932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Make the new constant. 699932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *NewC; 700932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) { 701932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = ConstantArray::get(UserCA->getType(), NewOps); 702932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) { 703932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = ConstantStruct::get(UserCS->getType(), NewOps); 704932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (isa<ConstantVector>(UserC)) { 705932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = ConstantVector::get(NewOps); 706932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 707932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr."); 708932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewC = cast<ConstantExpr>(UserC)->getWithOperands(NewOps); 709932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 710932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 711932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UserC->replaceAllUsesWith(NewC); 712932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UserC->destroyConstant(); 713932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewOps.clear(); 714932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 715932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 716932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Update all ValueHandles, they should be the only users at this point. 717932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Placeholder->replaceAllUsesWith(RealVal); 718932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete Placeholder; 719932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 720932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 721932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 7221bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hinesvoid BitcodeReaderMDValueList::AssignValue(Metadata *MD, unsigned Idx) { 723932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx == size()) { 7241bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines push_back(MD); 725932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 726932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 727932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 728932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 729932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx+1); 730932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 7311bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines TrackingMDRef &OldMD = MDValuePtrs[Idx]; 7321bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines if (!OldMD) { 7331bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines OldMD.reset(MD); 734932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 735932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 736932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 737932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If there was a forward reference to this value, replace it. 7381bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines TempMDTuple PrevMD(cast<MDTuple>(OldMD.get())); 7391bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines PrevMD->replaceAllUsesWith(MD); 7401bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines --NumFwdRefs; 741932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 742932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 7431bd9f627fa0affb457507e86b0b6684c695fe726Stephen HinesMetadata *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { 744932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Idx >= size()) 745932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines resize(Idx + 1); 746932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 7471bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines if (Metadata *MD = MDValuePtrs[Idx]) 7481bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return MD; 749932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 750932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create and return a placeholder, which will later be RAUW'd. 7511bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines AnyFwdRefs = true; 7521bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines ++NumFwdRefs; 7531bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines Metadata *MD = MDNode::getTemporary(Context, None).release(); 7541bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines MDValuePtrs[Idx].reset(MD); 7551bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return MD; 7561bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines} 7571bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 7581bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hinesvoid BitcodeReaderMDValueList::tryToResolveCycles() { 7591bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines if (!AnyFwdRefs) 7601bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines // Nothing to do. 7611bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return; 7621bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 7631bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines if (NumFwdRefs) 7641bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines // Still forward references... can't resolve cycles. 7651bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return; 7661bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 7671bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines // Resolve any cycles. 7681bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines for (auto &MD : MDValuePtrs) { 7691bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines auto *N = dyn_cast_or_null<MDNode>(MD); 7701bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines if (!N) 7711bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines continue; 7721bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 7731bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines assert(!N->isTemporary() && "Unexpected forward reference"); 7741bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines N->resolveCycles(); 7751bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines } 776932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 777932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 778932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesType *BitcodeReader::getTypeByID(unsigned ID) { 779932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // The type table size is always specified correctly. 780932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ID >= TypeList.size()) 78134edb8ad024934c13741550bc825c9b352453ad8Stephen Hines return nullptr; 782b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 783932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *Ty = TypeList[ID]) 784932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return Ty; 785932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 786932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we have a forward reference, the only possible case is when it is to a 787932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // named struct. Just create a placeholder for now. 7881bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return TypeList[ID] = createIdentifiedStructType(Context); 7891bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines} 7901bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 7911bd9f627fa0affb457507e86b0b6684c695fe726Stephen HinesStructType *BitcodeReader::createIdentifiedStructType(LLVMContext &Context, 7921bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines StringRef Name) { 7931bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines auto *Ret = StructType::create(Context, Name); 7941bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines IdentifiedStructTypes.push_back(Ret); 7951bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Ret; 796932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 797932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 7981bd9f627fa0affb457507e86b0b6684c695fe726Stephen HinesStructType *BitcodeReader::createIdentifiedStructType(LLVMContext &Context) { 7991bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines auto *Ret = StructType::create(Context); 8001bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines IdentifiedStructTypes.push_back(Ret); 8011bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Ret; 8021bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines} 8031bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 8041bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 805932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// FIXME: Remove in LLVM 3.1, only used by ParseOldTypeTable. 806932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesType *BitcodeReader::getTypeByIDOrNull(unsigned ID) { 807932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ID >= TypeList.size()) 808932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList.resize(ID+1); 809b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 810932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return TypeList[ID]; 811932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 812932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 813932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 814932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// Functions for parsing blocks from the bitcode file 815932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 816932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 817d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 818d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// \brief This fills an AttrBuilder object with the LLVM attributes that have 819d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// been decoded from the given integer. This function must stay in sync with 820d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// 'encodeLLVMAttributesForBitcode'. 821d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesstatic void decodeLLVMAttributesForBitcode(AttrBuilder &B, 822d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines uint64_t EncodedAttrs) { 823d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // FIXME: Remove in 4.0. 824d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 825d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The alignment is stored as a 16-bit raw value from bits 31--16. We shift 826d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // the bits above 31 down by 11 bits. 827d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16; 828d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines assert((!Alignment || isPowerOf2_32(Alignment)) && 829d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines "Alignment must be a power of two."); 830d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 831d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Alignment) 832d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines B.addAlignmentAttr(Alignment); 833d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines B.addRawValue(((EncodedAttrs & (0xfffffULL << 32)) >> 11) | 834d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines (EncodedAttrs & 0xffff)); 835d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 836d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 837d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseAttributeBlock() { 838932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) 8391bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 840932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 841932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!MAttributes.empty()) 8421bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid multiple blocks"); 843932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 844932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 845932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 846d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SmallVector<AttributeSet, 8> Attrs; 847932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 848932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records. 849932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 850d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 851932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 852d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 853d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 854d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 8551bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 856d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 857d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 858d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 859d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 860d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 861932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 862932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 863932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 864932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 865d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 866932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: ignore. 867932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 868d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::PARAMATTR_CODE_ENTRY_OLD: { // ENTRY: [paramidx0, attr0, ...] 869932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() & 1) 8701bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 871932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 872b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 873d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines AttrBuilder B; 874d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines decodeLLVMAttributesForBitcode(B, Record[i+1]); 875d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.push_back(AttributeSet::get(Context, Record[i], B)); 876932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 877932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 878d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines MAttributes.push_back(AttributeSet::get(Context, Attrs)); 879d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.clear(); 880d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 881d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 882d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [attrgrp0, attrgrp1, ...] 883d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (unsigned i = 0, e = Record.size(); i != e; ++i) 884d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.push_back(MAttributeGroups[Record[i]]); 885932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 886b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines MAttributes.push_back(AttributeSet::get(Context, Attrs)); 887932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Attrs.clear(); 888932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 889932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 890932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 891932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 892932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 893932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 894d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 895d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseTypeTable() { 896932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW)) 8971bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 898b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 899932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return ParseTypeTableBody(); 900932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 901932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 902d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseTypeTableBody() { 903932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!TypeList.empty()) 9041bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid multiple blocks"); 905932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 906932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 907932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumRecords = 0; 908932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 909932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<64> TypeName; 910b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 911932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this type table. 912932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 913d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 914d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 915d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 916d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 917d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 9181bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 919d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 920932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords != TypeList.size()) 9211bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 922d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 923d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 924d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 925d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 926932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 927932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 928932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 929932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 930579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Type *ResultTy = nullptr; 931d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 932d724d097437f40a5689464429f948ec41e4a2415Stephen Hines default: 9331bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid value"); 934932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 935932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // TYPE_CODE_NUMENTRY contains a count of the number of types in the 936932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // type list. This allows us to reserve space. 937932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 9381bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 939932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList.resize(Record[0]); 940932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 941932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VOID: // VOID 942932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getVoidTy(Context); 943932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 944d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::TYPE_CODE_HALF: // HALF 945d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ResultTy = Type::getHalfTy(Context); 946d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 947932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FLOAT: // FLOAT 948932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFloatTy(Context); 949932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 950932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_DOUBLE: // DOUBLE 951932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getDoubleTy(Context); 952932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 953932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_FP80: // X86_FP80 954932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_FP80Ty(Context); 955932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 956932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FP128: // FP128 957932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFP128Ty(Context); 958932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 959932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 960932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getPPC_FP128Ty(Context); 961932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 962932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_LABEL: // LABEL 963932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getLabelTy(Context); 964932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 965932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_METADATA: // METADATA 966932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getMetadataTy(Context); 967932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 968932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_MMX: // X86_MMX 969932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_MMXTy(Context); 970932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 971932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 972932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 9731bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 974932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 975932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = IntegerType::get(Context, Record[0]); 976932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 977932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 978932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // [pointee type, address space] 979932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 9801bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 981932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AddressSpace = 0; 982932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() == 2) 983932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AddressSpace = Record[1]; 984932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = getTypeByID(Record[0]); 985579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!ResultTy) 9861bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid type"); 987932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = PointerType::get(ResultTy, AddressSpace); 988932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 989932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 9903e88bf7dfe2af63827099a7d5be0173cf4c74f4dStephen Hines case bitc::TYPE_CODE_FUNCTION_OLD: { 991b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // FIXME: attrid is dead, remove it in LLVM 4.0 992932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FUNCTION: [vararg, attrid, retty, paramty x N] 993932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 9941bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 995b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Type*, 8> ArgTys; 996932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 3, e = Record.size(); i != e; ++i) { 997932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *T = getTypeByID(Record[i])) 998932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArgTys.push_back(T); 999932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1000932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1001932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1002b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1003932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = getTypeByID(Record[2]); 1004579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!ResultTy || ArgTys.size() < Record.size()-3) 10051bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid type"); 1006932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1007932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 1008932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1009932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1010932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N] 1011932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 10121bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1013b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Type*, 8> EltTys; 1014932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1, e = Record.size(); i != e; ++i) { 1015932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *T = getTypeByID(Record[i])) 1016932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EltTys.push_back(T); 1017932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1018932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1019932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1020932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (EltTys.size() != Record.size()-1) 10211bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid type"); 1022932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = StructType::get(Context, EltTys, Record[0]); 1023932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1024932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1025932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N] 1026932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, TypeName)) 10271bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1028932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1029932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1030932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N] 1031932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 10321bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1033b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1034932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords >= TypeList.size()) 10351bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid TYPE table"); 1036b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1037932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check to see if this was forward referenced, if so fill in the temp. 1038932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 1039932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Res) { 1040932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Res->setName(TypeName); 1041579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines TypeList[NumRecords] = nullptr; 1042932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else // Otherwise, create a new struct. 10431bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines Res = createIdentifiedStructType(Context, TypeName); 1044932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeName.clear(); 1045b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1046932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Type*, 8> EltTys; 1047932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1, e = Record.size(); i != e; ++i) { 1048932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *T = getTypeByID(Record[i])) 1049932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EltTys.push_back(T); 1050932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1051932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1052932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1053932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (EltTys.size() != Record.size()-1) 10541bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1055932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Res->setBody(EltTys, Record[0]); 1056932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Res; 1057932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1058932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1059932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: [] 1060932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != 1) 10611bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1062932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1063932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords >= TypeList.size()) 10641bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid TYPE table"); 1065b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1066932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check to see if this was forward referenced, if so fill in the temp. 1067932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 1068932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Res) { 1069932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Res->setName(TypeName); 1070579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines TypeList[NumRecords] = nullptr; 1071932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else // Otherwise, create a new struct with no body. 10721bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines Res = createIdentifiedStructType(Context, TypeName); 1073932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeName.clear(); 1074932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Res; 1075932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1076b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines } 1077932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 1078932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 10791bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1080932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByID(Record[1]))) 1081932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = ArrayType::get(ResultTy, Record[0]); 1082932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 10831bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid type"); 1084932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1085932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 1086932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 10871bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1088932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByID(Record[1]))) 1089932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = VectorType::get(ResultTy, Record[0]); 1090932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 10911bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid type"); 1092932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1093932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1094932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1095932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumRecords >= TypeList.size()) 10961bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid TYPE table"); 1097932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(ResultTy && "Didn't read a type?"); 1098579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines assert(!TypeList[NumRecords] && "Already read type?"); 1099932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NumRecords++] = ResultTy; 1100932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1101932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1102932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1103932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// FIXME: Remove in LLVM 3.1 1104d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseOldTypeTable() { 1105be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (Stream.EnterSubBlock(TYPE_BLOCK_ID_OLD_3_0)) 11061bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 1107932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1108932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!TypeList.empty()) 11091bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid TYPE table"); 1110b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1111b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1112932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // While horrible, we have no good ordering of types in the bc file. Just 1113932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // iteratively parse types out of the bc file in multiple passes until we get 1114932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // them all. Do this by saving a cursor for the start of the type block. 1115932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BitstreamCursor StartOfTypeBlockCursor(Stream); 1116b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1117932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumTypesRead = 0; 1118b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1119932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1120932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen HinesRestartScan: 1121932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextTypeID = 0; 1122932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool ReadAnyTypes = false; 1123b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1124932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this type table. 1125932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 1126932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 1127932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 1128932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID != TypeList.size()) 11291bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid TYPE table"); 1130b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1131932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we haven't read all of the types yet, iterate again. 1132932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NumTypesRead != TypeList.size()) { 1133932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we didn't successfully read any types in this pass, then we must 1134932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // have an unhandled forward reference. 1135932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!ReadAnyTypes) 11361bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid TYPE table"); 1137b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1138932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream = StartOfTypeBlockCursor; 1139932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines goto RestartScan; 1140932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1141b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1142932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 11431bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid TYPE table"); 1144d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 1145932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1146b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1147932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 1148932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 1149932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 1150932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 11511bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 1152932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1153932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1154b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1155932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 1156932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 1157932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1158932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1159b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1160932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1161932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1162579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Type *ResultTy = nullptr; 1163d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 11641bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines default: return Error("Invalid TYPE table"); 1165932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 1166932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // TYPE_CODE_NUMENTRY contains a count of the number of types in the 1167932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // type list. This allows us to reserve space. 1168932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 11691bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid TYPE table"); 1170932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList.resize(Record[0]); 1171932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1172932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VOID: // VOID 1173932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getVoidTy(Context); 1174932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1175932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FLOAT: // FLOAT 1176932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFloatTy(Context); 1177932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1178932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_DOUBLE: // DOUBLE 1179932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getDoubleTy(Context); 1180932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1181932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_FP80: // X86_FP80 1182932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_FP80Ty(Context); 1183932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1184932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_FP128: // FP128 1185932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getFP128Ty(Context); 1186932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1187932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 1188932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getPPC_FP128Ty(Context); 1189932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1190932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_LABEL: // LABEL 1191932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getLabelTy(Context); 1192932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1193932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_METADATA: // METADATA 1194932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getMetadataTy(Context); 1195932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1196932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_X86_MMX: // X86_MMX 1197932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = Type::getX86_MMXTy(Context); 1198932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1199932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 1200932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 12011bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid TYPE table"); 1202932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = IntegerType::get(Context, Record[0]); 1203932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1204932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_OPAQUE: // OPAQUE 1205932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID < TypeList.size() && TypeList[NextTypeID] == 0) 1206bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien ResultTy = StructType::create(Context, ""); 1207932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1208be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien case TYPE_CODE_STRUCT_OLD_3_0: {// STRUCT_OLD 1209932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID >= TypeList.size()) break; 1210932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If we already read it, don't reprocess. 1211932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TypeList[NextTypeID] && 1212932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines !cast<StructType>(TypeList[NextTypeID])->isOpaque()) 1213932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1214932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1215932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Set a type. 1216932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TypeList[NextTypeID] == 0) 1217bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien TypeList[NextTypeID] = StructType::create(Context, ""); 1218932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1219932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Type*> EltTys; 1220932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1, e = Record.size(); i != e; ++i) { 1221932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *Elt = getTypeByIDOrNull(Record[i])) 1222932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EltTys.push_back(Elt); 1223932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1224932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1225932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1226932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1227932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (EltTys.size() != Record.size()-1) 1228932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; // Not all elements are ready. 1229b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1230932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<StructType>(TypeList[NextTypeID])->setBody(EltTys, Record[0]); 1231932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = TypeList[NextTypeID]; 1232932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NextTypeID] = 0; 1233932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1234932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1235932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 1236932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // [pointee type, address space] 1237932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 12381bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid TYPE table"); 1239932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AddressSpace = 0; 1240932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() == 2) 1241932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AddressSpace = Record[1]; 1242932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[0]))) 1243932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = PointerType::get(ResultTy, AddressSpace); 1244932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1245932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 12463e88bf7dfe2af63827099a7d5be0173cf4c74f4dStephen Hines case bitc::TYPE_CODE_FUNCTION_OLD: { 1247932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME: attrid is dead, remove it in LLVM 3.0 1248932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FUNCTION: [vararg, attrid, retty, paramty x N] 1249932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 12501bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid TYPE table"); 1251932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Type*> ArgTys; 1252932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 3, e = Record.size(); i != e; ++i) { 1253932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Type *Elt = getTypeByIDOrNull(Record[i])) 1254932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArgTys.push_back(Elt); 1255932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1256932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1257932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1258932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ArgTys.size()+3 != Record.size()) 1259932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; // Something was null. 1260932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[2]))) 1261932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 1262932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1263932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1264932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 1265932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 12661bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid TYPE table"); 1267932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[1]))) 1268932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = ArrayType::get(ResultTy, Record[0]); 1269932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1270932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 1271932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 12721bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid TYPE table"); 1273932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((ResultTy = getTypeByIDOrNull(Record[1]))) 1274932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResultTy = VectorType::get(ResultTy, Record[0]); 1275932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1276932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1277b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1278932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextTypeID >= TypeList.size()) 12791bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid TYPE table"); 1280b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1281932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ResultTy && TypeList[NextTypeID] == 0) { 1282932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++NumTypesRead; 1283932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ReadAnyTypes = true; 1284b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1285932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeList[NextTypeID] = ResultTy; 1286932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1287b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1288932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++NextTypeID; 1289932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1290932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1291932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1292932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1293d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseOldTypeSymbolTable() { 1294be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien if (Stream.EnterSubBlock(TYPE_SYMTAB_BLOCK_ID_OLD_3_0)) 12951bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 1296932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1297932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1298932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1299932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this type table. 1300932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string TypeName; 1301932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 1302932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 1303932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 1304932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 13051bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 1306d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 1307932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1308932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1309932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 1310932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 1311932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 1312932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 13131bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 1314932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1315932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1316932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1317932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 1318932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 1319932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1320932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1321932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1322932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1323932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1324d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 1325932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: unknown type. 1326932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1327932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TST_CODE_ENTRY: // TST_ENTRY: [typeid, namechar x N] 1328932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 1, TypeName)) 13291bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1330932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned TypeID = Record[0]; 1331932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (TypeID >= TypeList.size()) 13321bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1333932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1334932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Only apply the type name to a struct type with no name. 1335932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (StructType *STy = dyn_cast<StructType>(TypeList[TypeID])) 1336bc9eb8fa13ee44d7bb46285e4c30da1236aefddfLogan Chien if (!STy->isLiteral() && !STy->hasName()) 1337932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines STy->setName(TypeName); 1338932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TypeName.clear(); 1339932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1340932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1341932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1342932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1343932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1344d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseValueSymbolTable() { 1345932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) 13461bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1347932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1348932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1349932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1350932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this value table. 1351932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<128> ValueName; 1352932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 1353932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 1354932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 1355932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 13561bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 1357d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 1358932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1359932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 1360932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 1361932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 1362932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 13631bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 1364932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1365932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1366932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1367932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 1368932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 1369932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1370932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1371932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1372932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1373932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1374d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 1375932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: unknown type. 1376932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1377932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N] 1378932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 1, ValueName)) 13791bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1380932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ValueID = Record[0]; 1381932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ValueID >= ValueList.size()) 13821bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1383932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = ValueList[ValueID]; 1384932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1385932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V->setName(StringRef(ValueName.data(), ValueName.size())); 1386932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueName.clear(); 1387932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1388932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1389932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VST_CODE_BBENTRY: { 1390932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 1, ValueName)) 13911bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1392932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *BB = getBasicBlock(Record[0]); 1393579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!BB) 13941bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1395932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1396932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BB->setName(StringRef(ValueName.data(), ValueName.size())); 1397932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueName.clear(); 1398932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1399932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1400932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1401932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1402932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1403932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1404d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseMetadata() { 1405932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextMDValueNo = MDValueList.size(); 1406932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1407932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) 14081bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1409932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1410932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1411932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1412932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records. 1413932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 1414932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 1415932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 1416932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 14171bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 1418d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 1419932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1420932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1421932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 1422932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // No known subblocks, always skip them. 1423932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadSubBlockID(); 1424932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 14251bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 1426932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1427932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1428932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1429932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 1430932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 1431932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 1432932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1433932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1434932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool IsFunctionLocal = false; 1435932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1436932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1437d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Code = Stream.readRecord(Code, Record); 1438932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Code) { 1439932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: ignore. 1440932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1441932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_NAME: { 1442932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read named of the named metadata. 1443932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NameLength = Record.size(); 1444932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallString<8> Name; 1445932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Name.resize(NameLength); 1446932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != NameLength; ++i) 1447932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Name[i] = Record[i]; 1448932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1449932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Code = Stream.ReadCode(); 1450932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1451932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // METADATA_NAME is always followed by METADATA_NAMED_NODE. 1452d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned NextBitCode = Stream.readRecord(Code, Record); 1453932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextBitCode == METADATA_NAMED_NODE_2_7) { 1454932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 1455932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (NextBitCode != bitc::METADATA_NAMED_NODE) { 1456932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(!"Invalid Named Metadata record."); (void)NextBitCode; 1457932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1458932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1459932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read named metadata elements. 1460932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1461932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NamedMDNode *NMD = TheModule->getOrInsertNamedMetadata(Name); 1462932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) { 1463579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines MDNode *MD = dyn_cast_or_null<MDNode>(MDValueList.getValueFwdRef(Record[i])); 1464579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!MD) 14651bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1466932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NMD->addOperand(MD); 1467932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1468932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1469932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (LLVM2_7MetadataDetected) { 1470932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.AssignValue(0, NextMDValueNo++); 1471932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1472932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1473932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1474932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case METADATA_FN_NODE_2_7: 14751bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case bitc::METADATA_OLD_FN_NODE: 1476932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IsFunctionLocal = true; 1477932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // fall-through 1478932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case METADATA_NODE_2_7: 14791bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case bitc::METADATA_OLD_NODE: { 1480932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == METADATA_FN_NODE_2_7 || 1481932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Code == METADATA_NODE_2_7) { 1482932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 1483932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1484932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1485932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() % 2 == 1) 14861bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1487932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1488932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 14891bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines SmallVector<Metadata *, 8> Elts; 1490932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; i += 2) { 1491932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[i]); 1492d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 14931bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1494932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Ty->isMetadataTy()) 1495932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); 14961bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines else if (!Ty->isVoidTy()) { 14971bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines auto *MD = 14981bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines ValueAsMetadata::get(ValueList.getValueFwdRef(Record[i + 1], Ty)); 14991bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines assert(isa<ConstantAsMetadata>(MD) && 15001bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines "Expected non-function-local metadata"); 15011bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines Elts.push_back(MD); 15021bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines } else 1503900c6c1f08f7c572125d7d39abe0f0f9eafbfa14Chris Wailes Elts.push_back(nullptr); 1504932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 15051bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines MDValueList.AssignValue(MDNode::get(Context, Elts), NextMDValueNo++); 1506932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1507932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1508f5b49a0ca149b09c8306b86db9f3aca703c4acd5Pirama Arumuga Nainar case bitc::METADATA_STRING_OLD: { 15091bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines std::string String(Record.begin(), Record.end()); 1510f5b49a0ca149b09c8306b86db9f3aca703c4acd5Pirama Arumuga Nainar 1511f5b49a0ca149b09c8306b86db9f3aca703c4acd5Pirama Arumuga Nainar // Test for upgrading !llvm.loop. 1512f5b49a0ca149b09c8306b86db9f3aca703c4acd5Pirama Arumuga Nainar mayBeOldLoopAttachmentTag(String); 1513f5b49a0ca149b09c8306b86db9f3aca703c4acd5Pirama Arumuga Nainar 15141bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines Metadata *MD = MDString::get(Context, String); 15151bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines MDValueList.AssignValue(MD, NextMDValueNo++); 1516932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1517932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1518932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_KIND: { 15191bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines if (Record.size() < 2) 15201bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 15211bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 1522932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Kind = Record[0]; 15231bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines SmallString<8> Name(Record.begin()+1, Record.end()); 1524b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1525932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NewKind = TheModule->getMDKindID(Name.str()); 1526932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) 15271bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Conflicting METADATA_KIND records"); 1528932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1529932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1530932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1531932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1532932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1533932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1534d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// decodeSignRotatedValue - Decode a signed value stored with the sign bit in 1535932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// the LSB for dense VBR encoding. 1536d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesuint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) { 1537932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((V & 1) == 0) 1538932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return V >> 1; 1539932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (V != 1) 1540932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return -(V >> 1); 1541932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // There is no such thing as -0 with integers. "-0" really means MININT. 1542932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return 1ULL << 63; 1543932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1544932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1545a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines// FIXME: Delete this in LLVM 4.0 and just assert that the aliasee is a 1546a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines// GlobalObject. 1547a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hinesstatic GlobalObject & 1548a630078b32eb37a8de91ae09e26babf235d4fc9fStephen HinesgetGlobalObjectInExpr(const DenseMap<GlobalAlias *, Constant *> &Map, 1549a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines Constant &C) { 1550a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines auto *GO = dyn_cast<GlobalObject>(&C); 1551a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines if (GO) 1552a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines return *GO; 1553a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines 1554a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines auto *GA = dyn_cast<GlobalAlias>(&C); 1555a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines if (GA) 1556a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines return getGlobalObjectInExpr(Map, *Map.find(GA)->second); 1557a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines 1558a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines auto &CE = cast<ConstantExpr>(C); 1559a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines assert(CE.getOpcode() == Instruction::BitCast || 1560a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines CE.getOpcode() == Instruction::GetElementPtr || 1561a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines CE.getOpcode() == Instruction::AddrSpaceCast); 1562a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines if (CE.getOpcode() == Instruction::GetElementPtr) 1563a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines assert(cast<GEPOperator>(CE).hasAllZeroIndices()); 1564a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines return getGlobalObjectInExpr(Map, *CE.getOperand(0)); 1565a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines} 1566a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines 1567932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ResolveGlobalAndAliasInits - Resolve all of the initializers for global 1568932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// values and aliases that we can. 1569d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ResolveGlobalAndAliasInits() { 1570932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist; 1571932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist; 1572932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1573932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInitWorklist.swap(GlobalInits); 1574932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInitWorklist.swap(AliasInits); 1575932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1576932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!GlobalInitWorklist.empty()) { 1577932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ValID = GlobalInitWorklist.back().second; 1578932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ValID >= ValueList.size()) { 1579932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Not ready to resolve this yet, it requires something later in the file. 1580932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInits.push_back(GlobalInitWorklist.back()); 1581932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1582579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) 1583932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInitWorklist.back().first->setInitializer(C); 1584932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 15851bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Expected a constant"); 1586932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1587932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInitWorklist.pop_back(); 1588932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1589932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1590a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines // FIXME: Delete this in LLVM 4.0 1591a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines // Older versions of llvm could write an alias pointing to another. We cannot 1592a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines // construct those aliases, so we first collect an alias to aliasee expression 1593a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines // and then compute the actual aliasee. 1594a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines DenseMap<GlobalAlias *, Constant *> AliasInit; 1595a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines 1596932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!AliasInitWorklist.empty()) { 1597932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ValID = AliasInitWorklist.back().second; 1598932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ValID >= ValueList.size()) { 1599932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInits.push_back(AliasInitWorklist.back()); 1600932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1601579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) 1602a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines AliasInit.insert(std::make_pair(AliasInitWorklist.back().first, C)); 1603932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 16041bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Expected a constant"); 1605932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1606932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInitWorklist.pop_back(); 1607932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1608a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines 1609a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines for (auto &Pair : AliasInit) { 1610a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines auto &GO = getGlobalObjectInExpr(AliasInit, *Pair.second); 1611a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines Pair.first->setAliasee(&GO); 1612a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines } 1613a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines 1614d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 1615932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1616932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1617d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesstatic APInt ReadWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) { 1618d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SmallVector<uint64_t, 8> Words(Vals.size()); 1619d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::transform(Vals.begin(), Vals.end(), Words.begin(), 1620d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitcodeReader::decodeSignRotatedValue); 1621d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1622d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return APInt(TypeBits, Words); 1623d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 1624d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1625d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseConstants() { 1626932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) 16271bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1628932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1629932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 1630932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1631932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this value table. 1632932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *CurTy = Type::getInt32Ty(Context); 1633932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextCstNo = ValueList.size(); 1634932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 1635d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 1636d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1637d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 1638d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 1639d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 16401bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 1641d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 1642d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (NextCstNo != ValueList.size()) 16431bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid constant reference"); 1644d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1645d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Once all the constants have been read, go through and resolve forward 1646d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // references. 1647d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ValueList.ResolveConstantForwardRefs(); 1648d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 1649d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 1650d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 1651932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1652932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1653932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1654932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 1655932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 1656579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Value *V = nullptr; 1657d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned BitCode = Stream.readRecord(Entry.ID, Record); 1658932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (BitCode) { 1659932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: unknown constant 1660932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_UNDEF: // UNDEF 1661932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); 1662932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1663932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] 1664932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 16651bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1666932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[0] >= TypeList.size()) 16671bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1668932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurTy = TypeList[Record[0]]; 1669932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; // Skip the ValueList manipulation. 1670932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_NULL: // NULL 1671932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = Constant::getNullValue(CurTy); 1672932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1673932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_INTEGER: // INTEGER: [intval] 1674932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!CurTy->isIntegerTy() || Record.empty()) 16751bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1676d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0])); 1677932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1678932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval] 1679932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!CurTy->isIntegerTy() || Record.empty()) 16801bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1681932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1682d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt VInt = ReadWideAPInt(Record, 1683d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines cast<IntegerType>(CurTy)->getBitWidth()); 1684d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantInt::get(Context, VInt); 1685d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1686932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1687932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1688932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] 1689932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 16901bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1691d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (CurTy->isHalfTy()) 1692d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf, 1693d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(16, (uint16_t)Record[0]))); 1694d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else if (CurTy->isFloatTy()) 1695d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEsingle, 1696d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(32, (uint32_t)Record[0]))); 1697932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurTy->isDoubleTy()) 1698d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEdouble, 1699d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(64, Record[0]))); 1700932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurTy->isX86_FP80Ty()) { 1701932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Bits are not stored the same way as a normal i80 APInt, compensate. 1702932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t Rearrange[2]; 1703932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16); 1704932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Rearrange[1] = Record[0] >> 48; 1705d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::x87DoubleExtended, 1706d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(80, Rearrange))); 1707932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (CurTy->isFP128Ty()) 1708d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEquad, 1709d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(128, Record))); 1710932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurTy->isPPC_FP128Ty()) 1711d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::PPCDoubleDouble, 1712d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(128, Record))); 1713932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1714932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); 1715932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1716932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1717932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1718932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] 1719932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 17201bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1721932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1722932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1723b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Constant*, 16> Elts; 1724932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1725932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (StructType *STy = dyn_cast<StructType>(CurTy)) { 1726932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1727932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i], 1728932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines STy->getElementType(i))); 1729932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantStruct::get(STy, Elts); 1730932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) { 1731932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = ATy->getElementType(); 1732932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1733932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 1734932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantArray::get(ATy, Elts); 1735932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) { 1736932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = VTy->getElementType(); 1737932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1738932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 1739932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantVector::get(Elts); 1740932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1741932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); 1742932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1743932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1744932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1745932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_STRING: { // STRING: [values] 1746932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 17471bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1748932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1749932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArrayType *ATy = cast<ArrayType>(CurTy); 1750932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = ATy->getElementType(); 1751932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1752932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1753932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Constant*> Elts; 1754932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1755932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ConstantInt::get(EltTy, Record[i])); 1756932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantArray::get(ATy, Elts); 1757932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1758932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1759932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CSTRING: { // CSTRING: [values] 1760932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty()) 17611bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1762932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1763932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ArrayType *ATy = cast<ArrayType>(CurTy); 1764932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *EltTy = ATy->getElementType(); 1765932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1766932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 1767932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Constant*> Elts; 1768932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != Size; ++i) 1769932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ConstantInt::get(EltTy, Record[i])); 1770932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(Constant::getNullValue(EltTy)); 1771932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantArray::get(ATy, Elts); 1772932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1773932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1774932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] 1775d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 17761bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1777932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedBinaryOpcode(Record[0], CurTy); 1778932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc < 0) { 1779932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); // Unknown binop. 1780932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1781932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy); 1782932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy); 1783932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Flags = 0; 1784932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() >= 4) { 1785932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc == Instruction::Add || 1786932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Sub || 1787932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Mul || 1788932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Shl) { 1789932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 1790932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Flags |= OverflowingBinaryOperator::NoSignedWrap; 1791932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 1792932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Flags |= OverflowingBinaryOperator::NoUnsignedWrap; 1793932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (Opc == Instruction::SDiv || 1794932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::UDiv || 1795932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::LShr || 1796932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::AShr) { 1797932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[3] & (1 << bitc::PEO_EXACT)) 1798932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Flags |= SDivOperator::IsExact; 1799932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1800932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1801932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::get(Opc, LHS, RHS, Flags); 1802932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1803932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1804932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1805932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] 1806d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 18071bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1808932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedCastOpcode(Record[0]); 1809932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc < 0) { 1810932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = UndefValue::get(CurTy); // Unknown cast. 1811932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 1812932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[1]); 1813d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!OpTy) 18141bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1815932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); 1816932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getCast(Opc, Op, CurTy); 1817932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1818932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1819932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1820932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_INBOUNDS_GEP: 1821932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands] 182298137cca7eebca946b869b010fef2821c9bf4971Pirama Arumuga Nainar Type *PointeeType = nullptr; 1823d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() & 1) 18241bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1825932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Constant*, 16> Elts; 1826932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 1827932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ElTy = getTypeByID(Record[i]); 1828d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!ElTy) 18291bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1830932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); 1831932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 18321bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end()); 183398137cca7eebca946b869b010fef2821c9bf4971Pirama Arumuga Nainar V = ConstantExpr::getGetElementPtr(PointeeType, Elts[0], Indices, 18341bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines BitCode == 18351bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines bitc::CST_CODE_CE_INBOUNDS_GEP); 1836932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1837932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1838932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_SELECT: // CE_SELECT: [opval#, opval#, opval#] 1839d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 18401bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1841932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0], 1842932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type::getInt1Ty(Context)), 1843932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.getConstantFwdRef(Record[1],CurTy), 1844932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.getConstantFwdRef(Record[2],CurTy)); 1845932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1846932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval] 1847d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 18481bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1849932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = 1850932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1851579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!OpTy) 18521bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1853932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1854932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 1855932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getExtractElement(Op0, Op1); 1856932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1857932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1858932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval] 1859932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1860579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (Record.size() < 3 || !OpTy) 18611bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1862932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 1863932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[1], 1864932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpTy->getElementType()); 1865932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 1866932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getInsertElement(Op0, Op1, Op2); 1867932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1868932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1869932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] 1870932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1871579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (Record.size() < 3 || !OpTy) 18721bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1873932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 1874932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); 1875932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 1876932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpTy->getNumElements()); 1877932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy); 1878932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 1879932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1880932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1881932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval] 1882932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *RTy = dyn_cast<VectorType>(CurTy); 1883932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines VectorType *OpTy = 1884932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1885579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (Record.size() < 4 || !RTy || !OpTy) 18861bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1887932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1888932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 1889932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 1890932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines RTy->getNumElements()); 1891932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy); 1892932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 1893932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1894932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1895932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] 1896d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 4) 18971bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1898932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 1899579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!OpTy) 19001bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1901932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1902932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 1903932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1904932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy->isFPOrFPVectorTy()) 1905932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getFCmp(Record[3], Op0, Op1); 1906932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 1907932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = ConstantExpr::getICmp(Record[3], Op0, Op1); 1908932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1909932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 19105cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines case bitc::CST_CODE_INLINEASM: 19115cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines case bitc::CST_CODE_INLINEASM_OLD: { 1912d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 2) 19131bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1914932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string AsmStr, ConstrStr; 1915932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool HasSideEffects = Record[0] & 1; 1916932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool IsAlignStack = Record[0] >> 1; 1917932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AsmStrSize = Record[1]; 1918932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (2+AsmStrSize >= Record.size()) 19191bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1920932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ConstStrSize = Record[2+AsmStrSize]; 1921932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (3+AsmStrSize+ConstStrSize > Record.size()) 19221bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1923932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1924932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != AsmStrSize; ++i) 1925932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AsmStr += (char)Record[2+i]; 1926932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0; i != ConstStrSize; ++i) 1927932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ConstrStr += (char)Record[3+AsmStrSize+i]; 1928932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *PTy = cast<PointerType>(CurTy); 1929932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), 1930932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AsmStr, ConstrStr, HasSideEffects, IsAlignStack); 1931932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1932932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1933932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CST_CODE_BLOCKADDRESS:{ 1934d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 19351bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1936932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *FnTy = getTypeByID(Record[0]); 1937579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!FnTy) 19381bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1939932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *Fn = 1940932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy)); 1941579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!Fn) 19421bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1943b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 1944932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalVariable *FwdRef = new GlobalVariable(*Fn->getParent(), 1945932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type::getInt8Ty(Context), 1946932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines false, GlobalValue::InternalLinkage, 1947932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 0, ""); 1948932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BlockAddrFwdRefs[Fn].push_back(std::make_pair(Record[2], FwdRef)); 1949932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines V = FwdRef; 1950932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 1951b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines } 1952932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1953932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1954932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.AssignValue(V, NextCstNo); 1955932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++NextCstNo; 1956932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 1957932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1958932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (NextCstNo != ValueList.size()) 19591bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid constant reference"); 1960932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1961932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 19621bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Expected a constant"); 1963932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1964932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Once all the constants have been read, go through and resolve forward 1965932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // references. 1966932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.ResolveConstantForwardRefs(); 1967d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 1968932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1969932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 19705cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hinesstd::error_code BitcodeReader::materializeMetadata() { 19715cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines return std::error_code(); 19725cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines} 19735cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 197498137cca7eebca946b869b010fef2821c9bf4971Pirama Arumuga Nainarvoid BitcodeReader::setStripDebugInfo() { } 197598137cca7eebca946b869b010fef2821c9bf4971Pirama Arumuga Nainar 1976932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// RememberAndSkipFunctionBody - When we see the block for a function body, 1977932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// remember where it is and then skip it. This lets us lazily deserialize the 1978932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// functions. 1979d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::RememberAndSkipFunctionBody() { 1980932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Get the function we are talking about. 1981932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FunctionsWithBodies.empty()) 19821bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Insufficient function protos"); 1983932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1984932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *Fn = FunctionsWithBodies.back(); 1985932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionsWithBodies.pop_back(); 1986932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1987932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Save the current stream state. 1988932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t CurBit = Stream.GetCurrentBitNo(); 1989932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DeferredFunctionInfo[Fn] = CurBit; 1990932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1991932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Skip over the function block for now. 1992932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 19931bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 1994d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 1995932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 1996932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 1997d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::GlobalCleanup() { 1998d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Patch the initializers for globals and aliases up. 1999d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ResolveGlobalAndAliasInits(); 2000d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!GlobalInits.empty() || !AliasInits.empty()) 20011bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed global initializer set"); 2002d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2003d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Look for intrinsic functions which need to be upgraded at some point 2004d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); 2005d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines FI != FE; ++FI) { 2006d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Function *NewFn; 2007f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar if (UpgradeIntrinsicFunction(&*FI, NewFn)) 2008f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar UpgradedIntrinsics.push_back(std::make_pair(&*FI, NewFn)); 2009d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 2010d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2011d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Look for global variables which need to be renamed. 2012d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (Module::global_iterator 2013d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines GI = TheModule->global_begin(), GE = TheModule->global_end(); 2014f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar GI != GE; GI++) { 2015f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar GlobalVariable *GV = &*GI; 2016f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar UpgradeGlobalVariable(&*GV); 20171bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines } 20181bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 2019d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Force deallocation of memory for these vectors to favor the client that 2020d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // want lazy deserialization. 2021d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); 2022d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); 2023d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 2024d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 2025d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2026d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseModule(bool Resume) { 2027d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Resume) 2028d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.JumpToBit(NextUnreadBit); 2029d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 20301bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2031932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2032932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 2033932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::string> SectionTable; 2034932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::string> GCTable; 2035932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2036932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this module. 2037932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (!Stream.AtEndOfStream()) { 2038932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 2039932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 2040932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 20411bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 2042932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2043932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Patch the initializers for globals and aliases up. 2044932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ResolveGlobalAndAliasInits(); 2045932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!GlobalInits.empty() || !AliasInits.empty()) 20461bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed global initializer set"); 2047932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FunctionsWithBodies.empty()) 20481bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Insufficient function protos"); 2049932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2050932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Look for intrinsic functions which need to be upgraded at some point 2051932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); 2052932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FI != FE; ++FI) { 2053932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function* NewFn; 2054f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar if (UpgradeIntrinsicFunction(&*FI, NewFn)) 2055f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar UpgradedIntrinsics.push_back(std::make_pair(&*FI, NewFn)); 2056932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2057932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2058932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Look for global variables which need to be renamed. 2059932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Module::global_iterator 2060932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GI = TheModule->global_begin(), GE = TheModule->global_end(); 2061932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GI != GE; ++GI) 2062f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar UpgradeGlobalVariable(&*GI); 2063932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2064932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Force deallocation of memory for these vectors to favor the client that 2065932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // want lazy deserialization. 2066932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); 2067932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); 2068932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<Function*>().swap(FunctionsWithBodies); 2069d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 2070932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2071932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2072932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 2073932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadSubBlockID()) { 2074932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Skip unknown content. 2075932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 20761bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2077932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2078932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::BLOCKINFO_BLOCK_ID: 2079932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockInfoBlock()) 20801bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 2081932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2082932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::PARAMATTR_BLOCK_ID: 2083d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseAttributeBlock()) 2084d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2085932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2086932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::TYPE_BLOCK_ID_NEW: 2087d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseTypeTable()) 2088d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2089932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2090be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien case TYPE_BLOCK_ID_OLD_3_0: 2091d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseOldTypeTable()) 2092d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2093932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2094be81e1078cd32c1c4a2b8f60e16e2c7760c2a353Logan Chien case TYPE_SYMTAB_BLOCK_ID_OLD_3_0: 2095d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseOldTypeSymbolTable()) 2096d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2097932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2098932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VALUE_SYMTAB_BLOCK_ID: 2099d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseValueSymbolTable()) 2100d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2101d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SeenValueSymbolTable = true; 2102932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2103932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CONSTANTS_BLOCK_ID: 2104d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseConstants()) 2105d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2106d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ResolveGlobalAndAliasInits()) 2107d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2108932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2109932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_BLOCK_ID: 2110d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseMetadata()) 2111d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2112932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2113932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNCTION_BLOCK_ID: 2114932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this is the first function body we've seen, reverse the 2115932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FunctionsWithBodies list. 2116d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!SeenFirstFunctionBody) { 2117932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end()); 2118d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = GlobalCleanup()) 2119d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2120d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SeenFirstFunctionBody = true; 2121932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2122932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2123d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = RememberAndSkipFunctionBody()) 2124d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2125d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // For streaming bitcode, suspend parsing when we reach the function 2126d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // bodies. Subsequent materialization calls will resume it when 2127d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // necessary. For streaming, the function bodies must be at the end of 2128d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // the bitcode. If the bitcode file is old, the symbol table will be 2129d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // at the end instead and will not have been seen yet. In this case, 2130d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // just finish the parse now. 2131d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (LazyStreamer && SeenValueSymbolTable) { 2132d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines NextUnreadBit = Stream.GetCurrentBitNo(); 2133d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 2134d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 2135d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 2136932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2137932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2138932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2139932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2140932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2141932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 2142932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 2143932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2144932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2145932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2146932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 2147d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 2148932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: break; // Default behavior, ignore unknown content. 2149b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines case bitc::MODULE_CODE_VERSION: { // VERSION: [version#] 2150932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 21511bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2152932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Only version #0 is supported so far. 2153932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[0] != 0) 21541bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid value"); 2155932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2156b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines } 2157932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 2158932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 2159932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 21601bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2161932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule->setTargetTriple(S); 2162932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2163932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2164932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] 2165932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 2166932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 21671bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2168932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule->setDataLayout(S); 2169932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2170932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2171932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] 2172932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 2173932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 21741bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2175932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines TheModule->setModuleInlineAsm(S); 2176932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2177932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2178932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N] 2179932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 2180932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 21811bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2182b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // ANDROID: Ignore value, since we never used it anyways. 2183b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // TheModule->addLibrary(S); 2184932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2185932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2186932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] 2187932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 2188932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 21891bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2190932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SectionTable.push_back(S); 2191932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2192932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2193932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N] 2194932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 2195932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 21961bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2197932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GCTable.push_back(S); 2198932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2199932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2200932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // GLOBALVAR: [pointer type, isconst, initid, 2201932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // linkage, alignment, section, visibility, threadlocal, 2202932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // unnamed_addr] 2203932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_GLOBALVAR: { 2204932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 6) 22051bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2206932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 2207d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 22081bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2209932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty->isPointerTy()) 22101bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid type for value"); 2211932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); 2212932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Ty = cast<PointerType>(Ty)->getElementType(); 2213932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2214932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool isConstant = Record[1]; 22151bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines uint64_t RawLinkage = Record[3]; 22161bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines GlobalValue::LinkageTypes Linkage = getDecodedLinkage(RawLinkage); 2217932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Alignment = (1 << Record[4]) >> 1; 2218932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string Section; 2219932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[5]) { 2220932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[5]-1 >= SectionTable.size()) 22211bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid ID"); 2222932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Section = SectionTable[Record[5]-1]; 2223932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2224932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; 2225932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 6) 2226932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Visibility = GetDecodedVisibility(Record[6]); 22278b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao 22288b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal; 2229932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 7) 22308b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao TLM = GetDecodedThreadLocalMode(Record[7]); 2231932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2232f5b49a0ca149b09c8306b86db9f3aca703c4acd5Pirama Arumuga Nainar GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::None; 2233932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 8) 2234f5b49a0ca149b09c8306b86db9f3aca703c4acd5Pirama Arumuga Nainar UnnamedAddr = getDecodedUnnamedAddrType(Record[8]); 2235932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2236932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalVariable *NewGV = 22371bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines new GlobalVariable(*TheModule, Ty, isConstant, Linkage, nullptr, "", nullptr, 22388b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao TLM, AddressSpace); 2239932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setAlignment(Alignment); 2240932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Section.empty()) 2241932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setSection(Section); 2242932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setVisibility(Visibility); 2243932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGV->setUnnamedAddr(UnnamedAddr); 2244932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2245932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(NewGV); 2246932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2247932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Remember which value to use for the global initializer. 2248932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (unsigned InitID = Record[2]) 2249932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalInits.push_back(std::make_pair(NewGV, InitID-1)); 2250932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2251932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2252932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FUNCTION: [type, callingconv, isproto, linkage, paramattr, 2253932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // alignment, section, visibility, gc, unnamed_addr] 2254932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_FUNCTION: { 2255932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 8) 22561bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2257932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 2258d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 22591bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2260932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!Ty->isPointerTy()) 22611bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid type for value"); 2262932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionType *FTy = 2263932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType()); 2264932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy) 22651bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid type for value"); 2266932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2267932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, 2268932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines "", TheModule); 2269932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2270932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setCallingConv(static_cast<CallingConv::ID>(Record[1])); 2271932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines bool isProto = Record[2]; 22721bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines uint64_t RawLinkage = Record[3]; 22731bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines Func->setLinkage(getDecodedLinkage(RawLinkage)); 2274932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setAttributes(getAttributes(Record[4])); 2275932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2276932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setAlignment((1 << Record[5]) >> 1); 2277932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[6]) { 2278932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[6]-1 >= SectionTable.size()) 22791bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid ID"); 2280932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setSection(SectionTable[Record[6]-1]); 2281932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2282932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setVisibility(GetDecodedVisibility(Record[7])); 2283932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 8 && Record[8]) { 2284932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[8]-1 > GCTable.size()) 22851bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid ID"); 2286932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setGC(GCTable[Record[8]-1].c_str()); 2287932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2288f5b49a0ca149b09c8306b86db9f3aca703c4acd5Pirama Arumuga Nainar GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::None; 2289932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 9) 2290f5b49a0ca149b09c8306b86db9f3aca703c4acd5Pirama Arumuga Nainar UnnamedAddr = getDecodedUnnamedAddrType(Record[9]); 2291932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Func->setUnnamedAddr(UnnamedAddr); 2292932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(Func); 2293932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2294932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this is a function with a body, remember the prototype we are 2295932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // creating now, so that we can match up the body with them later. 2296d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isProto) { 229734edb8ad024934c13741550bc825c9b352453ad8Stephen Hines Func->setIsMaterializable(true); 2298932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionsWithBodies.push_back(Func); 22991bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines if (LazyStreamer) 23001bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines DeferredFunctionInfo[Func] = 0; 2301d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 2302932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2303932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2304932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // ALIAS: [alias type, aliasee val#, linkage] 2305932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // ALIAS: [alias type, aliasee val#, linkage, visibility] 2306f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar case bitc::MODULE_CODE_ALIAS_OLD: { 2307932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 23081bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2309932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 2310d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 23111bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2312a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines auto *PTy = dyn_cast<PointerType>(Ty); 2313a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines if (!PTy) 23141bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid type for value"); 2315932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 23161bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines auto *NewGA = 2317f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(), 2318f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar getDecodedLinkage(Record[2]), "", TheModule); 2319932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Old bitcode files didn't have visibility field. 2320932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() > 3) 2321932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NewGA->setVisibility(GetDecodedVisibility(Record[3])); 2322932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.push_back(NewGA); 2323932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AliasInits.push_back(std::make_pair(NewGA, Record[1])); 2324932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2325932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2326932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines /// MODULE_CODE_PURGEVALS: [numvals] 2327932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_PURGEVALS: 2328932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Trim down the value list to the specified size. 2329932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1 || Record[0] > ValueList.size()) 23301bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2331932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.shrinkTo(Record[0]); 2332932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2333932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2334932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 2335932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2336932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 23371bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid bitcode signature"); 2338932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2339932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2340d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseBitcodeInto(Module *M) { 2341579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines TheModule = nullptr; 2342932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2343d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = InitStream()) 2344d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2345932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2346932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Sniff for the signature. 2347932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.Read(8) != 'B' || 2348932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(8) != 'C' || 2349932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0x0 || 2350932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xC || 2351932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xE || 2352932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xD) 23531bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid bitcode signature"); 2354932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2355932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We expect a number of well-defined blocks, though we don't necessarily 2356932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // need to understand them all. 2357d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2358d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.AtEndOfStream()) 2359d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 2360d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2361d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = 2362d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs); 2363932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2364d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2365d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 23661bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 2367d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2368d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 2369932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2370d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: 2371d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.ID) { 2372d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::BLOCKINFO_BLOCK_ID: 2373d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.ReadBlockInfoBlock()) 23741bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 2375d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 2376d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::MODULE_BLOCK_ID: 2377d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Reject multiple MODULE_BLOCK's in a single bitstream. 2378d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (TheModule) 23791bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid multiple blocks"); 2380d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines TheModule = M; 2381d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseModule(false)) 2382d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2383d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (LazyStreamer) 2384d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 2385d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 2386d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines default: 2387d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.SkipBlock()) 23881bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2389d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 2390d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 2391d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 2392d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2393d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // There should be no records in the top-level of blocks. 2394d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2395d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The ranlib in Xcode 4 will align archive members by appending newlines 2396d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // to the end of them. If this file size is a multiple of 4 but not 8, we 2397d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // have to read and ignore these final 4 bytes :-( 2398d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.getAbbrevIDWidth() == 2 && Entry.ID == 2 && 2399932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a && 2400b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines Stream.AtEndOfStream()) 2401d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 2402932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 24031bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2404932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2405932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2406932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2407932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2408579361346abc6696c805e3904a18178ebce4e4a3Stephen Hinesllvm::ErrorOr<std::string> BitcodeReader::parseModuleTriple() { 2409932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 24101bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2411932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2412932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 2413932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2414579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines std::string Triple; 2415932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records for this module. 2416d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2417d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 2418932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2419d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2420d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 2421d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 24221bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 2423d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2424579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Triple; 2425d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2426d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 2427d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 2428932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2429932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2430932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 2431d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 2432932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: break; // Default behavior, ignore unknown content. 2433932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_VERSION: // VERSION: [version#] 2434932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1) 24351bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2436932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Only version #0 is supported so far. 2437932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[0] != 0) 24381bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2439932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2440932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 2441932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::string S; 2442932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ConvertToString(Record, 0, S)) 24431bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2444932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Triple = S; 2445932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2446932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2447932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2448932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 2449932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2450932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 24511bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid bitcode signature"); 2452932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2453932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2454579361346abc6696c805e3904a18178ebce4e4a3Stephen Hinesllvm::ErrorOr<std::string> BitcodeReader::parseTriple() { 2455d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = InitStream()) 2456d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2457932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2458932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Sniff for the signature. 2459932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.Read(8) != 'B' || 2460932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(8) != 'C' || 2461932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0x0 || 2462932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xC || 2463932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xE || 2464932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.Read(4) != 0xD) 24651bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid bitcode signature"); 2466932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2467932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We expect a number of well-defined blocks, though we don't necessarily 2468932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // need to understand them all. 2469d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2470d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advance(); 2471932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2472d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2473d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 24741bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 2475d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2476d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 2477932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2478d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: 2479d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Entry.ID == bitc::MODULE_BLOCK_ID) 2480579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return parseModuleTriple(); 2481932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2482d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Ignore other sub-blocks. 2483d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Stream.SkipBlock()) 24841bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 2485d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 2486d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2487d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2488d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.skipRecord(Entry.ID); 2489d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 2490932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2491932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2492932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2493932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2494932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ParseMetadataAttachment - Parse metadata attachments. 2495d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseMetadataAttachment() { 2496932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) 24971bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2498932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2499932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 2500d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2501d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 2502d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2503d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2504d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 2505d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 25061bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 2507d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2508d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 2509d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2510d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 2511932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2512932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2513d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2514932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a metadata attachment record. 2515932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 2516d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 2517932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: ignore. 2518932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2519932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case METADATA_ATTACHMENT_2_7: 2520932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 2521932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_ATTACHMENT: { 2522932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned RecordLength = Record.size(); 2523932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.empty() || (RecordLength - 1) % 2 == 1) 25241bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2525932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Instruction *Inst = InstructionList[Record[0]]; 2526932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 1; i != RecordLength; i = i+2) { 2527932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Kind = Record[i]; 2528932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DenseMap<unsigned, unsigned>::iterator I = 2529932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDKindMap.find(Kind); 2530932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I == MDKindMap.end()) 25311bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid ID"); 25321bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines Metadata *Node = MDValueList.getValueFwdRef(Record[i + 1]); 2533932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Inst->setMetadata(I->second, cast<MDNode>(Node)); 2534932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2535932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2536932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2537932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2538932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2539932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 2540932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2541932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ParseFunctionBody - Lazily parse the specified function body block. 2542d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseFunctionBody(Function *F) { 2543932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) 25441bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2545932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2546932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.clear(); 2547932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ModuleValueListSize = ValueList.size(); 2548932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ModuleMDValueListSize = MDValueList.size(); 2549932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2550932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Add all the function arguments to the value table. 2551932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) 2552f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar ValueList.push_back(&*I); 2553932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2554932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NextValueNo = ValueList.size(); 2555579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines BasicBlock *CurBB = nullptr; 2556932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned CurBBNo = 0; 2557932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2558932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DebugLoc LastLoc; 2559b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2560932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read all the records. 2561932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<uint64_t, 64> Record; 2562932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (1) { 2563932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Code = Stream.ReadCode(); 2564932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::END_BLOCK) { 2565932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.ReadBlockEnd()) 25661bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Malformed block"); 2567932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2568932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2569932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2570932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::ENTER_SUBBLOCK) { 2571932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (Stream.ReadSubBlockID()) { 2572932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Skip unknown content. 2573932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Stream.SkipBlock()) 25741bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2575932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2576932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::CONSTANTS_BLOCK_ID: 2577d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseConstants()) 2578d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2579932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines NextValueNo = ValueList.size(); 2580932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2581932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::VALUE_SYMTAB_BLOCK_ID: 2582d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseValueSymbolTable()) 2583d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2584932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2585932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_ATTACHMENT_ID: 2586d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseMetadataAttachment()) 2587d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2588932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2589932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::METADATA_BLOCK_ID: 2590d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseMetadata()) 2591d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2592932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2593932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2594932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2595932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2596932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2597932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Code == bitc::DEFINE_ABBREV) { 2598932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.ReadAbbrevRecord(); 2599932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2600932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2601932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2602932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read a record. 2603932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.clear(); 2604579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Instruction *I = nullptr; 2605d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned BitCode = Stream.readRecord(Code, Record); 2606932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines switch (BitCode) { 2607932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines default: // Default behavior: reject 26081bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid value"); 2609932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks] 2610932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1 || Record[0] == 0) 26111bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2612932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Create all the basic blocks for the function. 2613932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionBBs.resize(Record[0]); 2614932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) 2615932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FunctionBBs[i] = BasicBlock::Create(Context, "", F); 2616932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurBB = FunctionBBs[0]; 2617932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2618b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2619932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN 2620932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // This record indicates that the last instruction is at the same 2621932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // location as the previous instruction with a location. 2622579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines I = nullptr; 2623b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2624932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Get the last instruction emitted. 2625932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CurBB && !CurBB->empty()) 2626932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &CurBB->back(); 2627932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurBBNo && FunctionBBs[CurBBNo-1] && 2628932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines !FunctionBBs[CurBBNo-1]->empty()) 2629932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &FunctionBBs[CurBBNo-1]->back(); 2630b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2631579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!I) 26321bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2633932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->setDebugLoc(LastLoc); 2634579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines I = nullptr; 2635932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2636b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2637932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_DEBUG_LOC_2_7: 2638932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 2639932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia] 2640579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines I = nullptr; // Get the last instruction emitted. 2641932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CurBB && !CurBB->empty()) 2642932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &CurBB->back(); 2643932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else if (CurBBNo && FunctionBBs[CurBBNo-1] && 2644932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines !FunctionBBs[CurBBNo-1]->empty()) 2645932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = &FunctionBBs[CurBBNo-1]->back(); 2646579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!I || Record.size() < 4) 26471bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2648b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2649932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Line = Record[0], Col = Record[1]; 2650932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned ScopeID = Record[2], IAID = Record[3]; 2651b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2652579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines MDNode *Scope = nullptr, *IA = nullptr; 2653932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (ScopeID) Scope = cast<MDNode>(MDValueList.getValueFwdRef(ScopeID-1)); 2654932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (IAID) IA = cast<MDNode>(MDValueList.getValueFwdRef(IAID-1)); 2655932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LastLoc = DebugLoc::get(Line, Col, Scope, IA); 2656932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->setDebugLoc(LastLoc); 2657579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines I = nullptr; 2658932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines continue; 2659932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2660932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2661932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode] 2662932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2663932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *LHS, *RHS; 2664932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 2665932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, LHS->getType(), RHS) || 2666932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+1 > Record.size()) 26671bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2668932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2669932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); 2670d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Opc == -1) 26711bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2672932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); 2673932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2674932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpNum < Record.size()) { 2675932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Opc == Instruction::Add || 2676932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Sub || 2677932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Mul || 2678932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::Shl) { 2679932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 2680932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<BinaryOperator>(I)->setHasNoSignedWrap(true); 2681932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 2682932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true); 2683932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else if (Opc == Instruction::SDiv || 2684932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::UDiv || 2685932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::LShr || 2686932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Opc == Instruction::AShr) { 2687932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record[OpNum] & (1 << bitc::PEO_EXACT)) 2688932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<BinaryOperator>(I)->setIsExact(true); 2689932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2690932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2691932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2692932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2693932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc] 2694932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2695932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2696932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2697932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) 26981bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2699932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2700932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ResTy = getTypeByID(Record[OpNum]); 2701932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines int Opc = GetDecodedCastOpcode(Record[OpNum+1]); 2702579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (Opc == -1 || !ResTy) 27031bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2704932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy); 2705932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2706932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2707932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 27081bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case bitc::FUNC_CODE_INST_INBOUNDS_GEP_OLD: 27091bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case bitc::FUNC_CODE_INST_GEP_OLD: // GEP: [n x operands] 2710932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands] 2711932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 27125cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 27135cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines Type *Ty; 27145cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines bool InBounds; 27155cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 27165cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines if (BitCode == bitc::FUNC_CODE_INST_GEP) { 27175cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines InBounds = Record[OpNum++]; 27185cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines Ty = getTypeByID(Record[OpNum++]); 27195cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines } else { 27205cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines InBounds = BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP_OLD; 27215cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines Ty = nullptr; 27225cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines } 27235cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2724932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *BasePtr; 2725932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) 27261bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2727932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 27285cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines if (Ty && 27295cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines Ty != 27305cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines cast<SequentialType>(BasePtr->getType()->getScalarType()) 27315cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines ->getElementType()) 27325cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines return Error( 27335cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines "Explicit gep type does not match pointee type of pointer operand"); 27345cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2735932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 16> GEPIdx; 2736932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (OpNum != Record.size()) { 2737932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2738932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 27391bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2740932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GEPIdx.push_back(Op); 2741932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2742932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 27435cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines I = GetElementPtrInst::Create(Ty, BasePtr, GEPIdx); 27445cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 2745932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 27465cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines if (InBounds) 2747932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<GetElementPtrInst>(I)->setIsInBounds(true); 2748932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2749932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2750932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2751932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_EXTRACTVAL: { 2752932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // EXTRACTVAL: [opty, opval, n x indices] 2753932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2754932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Agg; 2755932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 27561bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2757932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2758932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<unsigned, 4> EXTRACTVALIdx; 2759932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned RecSize = Record.size(); 2760932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum != RecSize; ++OpNum) { 2761932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t Index = Record[OpNum]; 2762932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((unsigned)Index != Index) 27631bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid value"); 2764932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines EXTRACTVALIdx.push_back((unsigned)Index); 2765932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2766932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2767932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ExtractValueInst::Create(Agg, EXTRACTVALIdx); 2768932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2769932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2770932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2771932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2772932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INSERTVAL: { 2773932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // INSERTVAL: [opty, opval, opty, opval, n x indices] 2774932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2775932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Agg; 2776932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 27771bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2778932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Val; 2779932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Val)) 27801bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2781932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2782932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<unsigned, 4> INSERTVALIdx; 2783932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned RecSize = Record.size(); 2784932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum != RecSize; ++OpNum) { 2785932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines uint64_t Index = Record[OpNum]; 2786932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if ((unsigned)Index != Index) 27871bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid value"); 2788932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines INSERTVALIdx.push_back((unsigned)Index); 2789932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2790932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2791932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = InsertValueInst::Create(Agg, Val, INSERTVALIdx); 2792932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2793932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2794932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2795932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2796932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval] 2797932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // obsolete form of select 2798932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // handles select i1 ... in old bitcode 2799932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2800932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *TrueVal, *FalseVal, *Cond; 2801932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 2802932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 2803932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Type::getInt1Ty(Context), Cond)) 28041bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2805932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2806932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = SelectInst::Create(Cond, TrueVal, FalseVal); 2807932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2808932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2809932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2810932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2811932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred] 2812932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // new form of select 2813932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // handles select i1 or select [N x i1] 2814932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2815932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *TrueVal, *FalseVal, *Cond; 2816932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 2817932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 2818932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValueTypePair(Record, OpNum, NextValueNo, Cond)) 28191bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2820932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2821932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // select condition can be either i1 or [N x i1] 2822932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (VectorType* vector_type = 2823932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast<VectorType>(Cond->getType())) { 2824932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // expect <n x i1> 2825932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (vector_type->getElementType() != Type::getInt1Ty(Context)) 28261bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid type for value"); 2827932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2828932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // expect i1 2829932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Cond->getType() != Type::getInt1Ty(Context)) 28301bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid type for value"); 2831932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2832932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2833932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = SelectInst::Create(Cond, TrueVal, FalseVal); 2834932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2835932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2836932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2837932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2838932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval] 2839932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2840932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Vec, *Idx; 2841932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 2842932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 28431bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2844932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ExtractElementInst::Create(Vec, Idx); 2845932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2846932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2847932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2848932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2849932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval] 2850932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2851932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Vec, *Elt, *Idx; 2852932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 2853932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, 2854932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<VectorType>(Vec->getType())->getElementType(), Elt) || 2855932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 28561bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2857932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = InsertElementInst::Create(Vec, Elt, Idx); 2858932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2859932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2860932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2861932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2862932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval] 2863932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2864932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Vec1, *Vec2, *Mask; 2865932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) || 2866932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, Vec1->getType(), Vec2)) 28671bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2868932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2869932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) 28701bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2871932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new ShuffleVectorInst(Vec1, Vec2, Mask); 2872932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2873932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2874932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2875932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2876932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred] 2877932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Old form of ICmp/FCmp returning bool 2878932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were 2879932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // both legal on vectors but had different behaviour. 2880932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred] 2881932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FCmp/ICmp returning bool or vector of bool 2882932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2883932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2884932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *LHS, *RHS; 2885932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 2886932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, LHS->getType(), RHS) || 2887932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+1 != Record.size()) 28881bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2889932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2890932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (LHS->getType()->isFPOrFPVectorTy()) 2891932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); 2892932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 2893932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS); 2894932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2895932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2896932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2897932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2898932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_GETRESULT_2_7: { 2899932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != 2) { 29001bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2901932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2902932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2903932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 2904932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValueTypePair(Record, OpNum, NextValueNo, Op); 2905932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Index = Record[1]; 2906932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ExtractValueInst::Create(Op, Index); 2907932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2908932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2909932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2910932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2911932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>] 2912932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines { 2913932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Size = Record.size(); 2914932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Size == 0) { 2915932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ReturnInst::Create(Context); 2916932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2917932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2918932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2919932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2920932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 2921900c6c1f08f7c572125d7d39abe0f0f9eafbfa14Chris Wailes Value *Op = nullptr; 2922932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 29231bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2924932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpNum != Record.size()) 29251bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2926932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2927932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = ReturnInst::Create(Context, Op); 2928932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2929932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2930932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2931932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] 2932932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != 1 && Record.size() != 3) 29331bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2934932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *TrueDest = getBasicBlock(Record[0]); 2935579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!TrueDest) 29361bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2937932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 2938932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() == 1) { 2939932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = BranchInst::Create(TrueDest); 2940932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2941932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2942932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else { 2943932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *FalseDest = getBasicBlock(Record[1]); 2944932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Cond = getFnValueByID(Record[2], Type::getInt1Ty(Context)); 2945579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!FalseDest || !Cond) 29461bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2947932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = BranchInst::Create(TrueDest, FalseDest, Cond); 2948932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 2949932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2950932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2951932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2952932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...] 2953932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || (Record.size() & 1) == 0) 29541bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2955932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 2956932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Cond = getFnValueByID(Record[1], OpTy); 2957932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *Default = getBasicBlock(Record[2]); 2958579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!OpTy || !Cond || !Default) 29591bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2960932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumCases = (Record.size()-3)/2; 2961932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); 2962932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(SI); 2963932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = NumCases; i != e; ++i) { 2964932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ConstantInt *CaseVal = 2965932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy)); 2966932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); 2967579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!CaseVal || !DestBB) { 2968932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete SI; 29691bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2970932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2971932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SI->addCase(CaseVal, DestBB); 2972932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2973932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = SI; 2974932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2975932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2976932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] 2977932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 2) 29781bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2979932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 2980932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Address = getFnValueByID(Record[1], OpTy); 2981579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!OpTy || !Address) 29821bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2983932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NumDests = Record.size()-2; 2984932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); 2985932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(IBI); 2986932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = NumDests; i != e; ++i) { 2987932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) { 2988932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines IBI->addDestination(DestBB); 2989932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 2990932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete IBI; 29911bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 2992932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2993932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2994932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = IBI; 2995932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 2996932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 2997b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 2998932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_INVOKE: { 2999932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] 3000d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 4) 30011bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3002b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines AttributeSet PAL = getAttributes(Record[0]); 3003932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned CCInfo = Record[1]; 3004932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *NormalBB = getBasicBlock(Record[2]); 3005932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *UnwindBB = getBasicBlock(Record[3]); 3006932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3007932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 4; 3008932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Callee; 3009932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 30101bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3011932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3012932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); 3013579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines FunctionType *FTy = !CalleeTy ? nullptr : 3014932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast<FunctionType>(CalleeTy->getElementType()); 3015932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3016932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check that the right number of fixed parameters are here. 3017579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!FTy || !NormalBB || !UnwindBB || 3018932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Record.size() < OpNum+FTy->getNumParams()) 30191bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3020932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3021932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 16> Ops; 3022932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 3023932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Ops.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 3024579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!Ops.back()) 30251bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3026932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3027932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3028932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy->isVarArg()) { 3029932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() != OpNum) 30301bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3031932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 3032932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read type/value pairs for varargs params. 3033932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (OpNum != Record.size()) { 3034932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 3035932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 30361bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3037932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Ops.push_back(Op); 3038932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3039932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3040932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3041932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops); 3042932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 3043932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<InvokeInst>(I)->setCallingConv( 3044932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static_cast<CallingConv::ID>(CCInfo)); 3045932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<InvokeInst>(I)->setAttributes(PAL); 3046932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 3047932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3048c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao case FUNC_CODE_INST_UNWIND_2_7: { // UNWIND_OLD 3049c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao // 'unwind' instruction has been removed in LLVM 3.1 3050c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao // Replace 'unwind' with 'landingpad' and 'resume'. 3051c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Type *ExnTy = StructType::get(Type::getInt8PtrTy(Context), 3052900c6c1f08f7c572125d7d39abe0f0f9eafbfa14Chris Wailes Type::getInt32Ty(Context), nullptr); 3053c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 3054f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar LandingPadInst *LP = LandingPadInst::Create(ExnTy, 1); 3055c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao LP->setCleanup(true); 3056c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 3057c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao CurBB->getInstList().push_back(LP); 3058c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao I = ResumeInst::Create(LP); 3059932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 3060932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 3061c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao } 3062932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE 3063932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new UnreachableInst(Context); 3064932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 3065932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 3066932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...] 3067932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 1 || ((Record.size()-1)&1)) 30681bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3069932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Ty = getTypeByID(Record[0]); 3070d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 30711bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3072932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3073932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2); 3074932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(PN); 3075932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3076932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) { 3077932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *V = getFnValueByID(Record[1+i], Ty); 3078932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BasicBlock *BB = getBasicBlock(Record[2+i]); 3079d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!V || !BB) 30801bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3081932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PN->addIncoming(V, BB); 3082932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3083932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = PN; 3084932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 3085932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3086932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3087932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_MALLOC_2_7: { // MALLOC: [instty, op, align] 3088932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Autoupgrade malloc instruction to malloc call. 3089932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME: Remove in LLVM 3.0. 3090932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) { 30911bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3092932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3093932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *Ty = 3094932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<PointerType>(getTypeByID(Record[0])); 3095932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Size = getFnValueByID(Record[1], Type::getInt32Ty(Context)); 3096d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty || !Size) 30971bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3098d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!CurBB) 30991bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid instruction with no BB"); 3100932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *Int32Ty = IntegerType::getInt32Ty(CurBB->getContext()); 3101932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Constant *AllocSize = ConstantExpr::getSizeOf(Ty->getElementType()); 3102932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, Int32Ty); 3103932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CallInst::CreateMalloc(CurBB, Int32Ty, Ty->getElementType(), 3104900c6c1f08f7c572125d7d39abe0f0f9eafbfa14Chris Wailes AllocSize, Size, nullptr); 3105932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 3106932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 3107932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3108932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_FREE_2_7: { // FREE: [op, opty] 3109932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 3110932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 3111932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 3112932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum != Record.size()) { 31131bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3114932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3115d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!CurBB) 31161bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid instruction with no BB"); 3117932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CallInst::CreateFree(Op, CurBB); 3118932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 3119932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 3120932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3121932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3122932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align] 3123932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // For backward compatibility, tolerate a lack of an opty, and use i32. 3124932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Remove this in LLVM 3.0. 3125932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3 || Record.size() > 4) { 31261bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3127932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3128932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 3129932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *Ty = 3130932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines dyn_cast_or_null<PointerType>(getTypeByID(Record[OpNum++])); 3131932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = Record.size() == 4 ? getTypeByID(Record[OpNum++]) : 3132932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type::getInt32Ty(Context); 3133932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Size = getFnValueByID(Record[OpNum++], OpTy); 3134932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned Align = Record[OpNum++]; 3135d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty || !Size) 31361bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3137932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); 3138932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 3139932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 3140932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3141932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol] 3142932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 3143932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 3144932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 3145932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) 31461bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3147932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3148932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); 3149932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 3150932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 3151932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3152933b5a904f7215c692b41a1c0481f4ea5f4abde1Pirama Arumuga Nainar case bitc::FUNC_CODE_INST_STORE_OLD: { // STORE2:[ptrty, ptr, val, align, vol] 3153932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 3154932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Val, *Ptr; 3155932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 3156932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, 3157932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<PointerType>(Ptr->getType())->getElementType(), Val) || 3158932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) 31591bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3160932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3161932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 3162932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 3163932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 3164932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3165932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_STORE_2_7: { 3166932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 0; 3167932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Val, *Ptr; 3168932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Val) || 3169932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines getValue(Record, OpNum, 3170932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType::getUnqual(Val->getType()), Ptr)|| 3171932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines OpNum+2 != Record.size()) { 31721bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3173932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3174932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 3175932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 3176932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 3177932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3178932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case FUNC_CODE_INST_CALL_2_7: 3179932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines LLVM2_7MetadataDetected = true; 3180932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_CALL: { 3181932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] 3182932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 31831bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3184932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3185b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines AttributeSet PAL = getAttributes(Record[0]); 3186932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned CCInfo = Record[1]; 3187932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3188932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned OpNum = 2; 3189932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Callee; 3190932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 31911bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3192932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3193932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); 3194579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines FunctionType *FTy = nullptr; 3195932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType()); 3196932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy || Record.size() < FTy->getNumParams()+OpNum) 31971bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3198932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3199932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines SmallVector<Value*, 16> Args; 3200932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read the fixed params. 3201932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 3202932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (FTy->getParamType(i)->isLabelTy()) 3203932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Args.push_back(getBasicBlock(Record[OpNum])); 3204932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines else 3205932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Args.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 3206579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!Args.back()) 32071bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3208932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3209932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3210932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read type/value pairs for varargs params. 3211932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!FTy->isVarArg()) { 3212932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (OpNum != Record.size()) 32131bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3214932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } else { 3215932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines while (OpNum != Record.size()) { 3216932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op; 3217932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 32181bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3219932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Args.push_back(Op); 3220932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3221932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3222932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3223932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = CallInst::Create(Callee, Args); 3224932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 3225932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<CallInst>(I)->setCallingConv( 3226932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines static_cast<CallingConv::ID>(CCInfo>>1)); 3227932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<CallInst>(I)->setTailCall(CCInfo & 1); 3228932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines cast<CallInst>(I)->setAttributes(PAL); 3229932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 3230932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3231932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] 3232932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Record.size() < 3) 32331bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3234932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *OpTy = getTypeByID(Record[0]); 3235932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Value *Op = getFnValueByID(Record[1], OpTy); 3236932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Type *ResTy = getTypeByID(Record[2]); 3237932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!OpTy || !Op || !ResTy) 32381bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid record"); 3239932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I = new VAArgInst(Op, ResTy); 3240932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines InstructionList.push_back(I); 3241932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines break; 3242932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3243932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3244932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3245932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Add instruction to end of current BB. If there is no current BB, reject 3246932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // this file. 3247579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!CurBB) { 3248932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete I; 32491bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid instruction with no BB"); 3250932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3251932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CurBB->getInstList().push_back(I); 3252932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3253932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this was a terminator instruction, move to the next block. 3254932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (isa<TerminatorInst>(I)) { 3255932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ++CurBBNo; 32561bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : nullptr; 3257932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3258932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3259932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Non-void values get registered in the value table for future use. 3260932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I && !I->getType()->isVoidTy()) 3261932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.AssignValue(I, NextValueNo++); 3262932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3263932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3264932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check the function list for unresolved values. 3265932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (Argument *A = dyn_cast<Argument>(ValueList.back())) { 3266579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!A->getParent()) { 3267932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // We found at least one unresolved value. Nuke them all to avoid leaks. 3268932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){ 3269579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if ((A = dyn_cast_or_null<Argument>(ValueList[i])) && !A->getParent()) { 3270932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines A->replaceAllUsesWith(UndefValue::get(A->getType())); 3271932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete A; 3272932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3273932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 32741bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Never resolved value found in function"); 3275932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3276932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3277932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3278932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // FIXME: Check for unresolved forward-declared metadata references 3279932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // and clean up leaks. 3280932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3281932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // See if anything took the address of blocks in this function. If so, 3282932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // resolve them now. 3283932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DenseMap<Function*, std::vector<BlockAddrRefTy> >::iterator BAFRI = 3284932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BlockAddrFwdRefs.find(F); 3285932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BAFRI != BlockAddrFwdRefs.end()) { 3286932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<BlockAddrRefTy> &RefList = BAFRI->second; 3287932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (unsigned i = 0, e = RefList.size(); i != e; ++i) { 3288932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned BlockIdx = RefList[i].first; 3289932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (BlockIdx >= FunctionBBs.size()) 32901bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid ID"); 3291b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 3292932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines GlobalVariable *FwdRef = RefList[i].second; 3293932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx])); 3294932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines FwdRef->eraseFromParent(); 3295932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3296b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines 3297932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines BlockAddrFwdRefs.erase(BAFRI); 3298932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3299932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3300932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines unsigned NewMDValueListSize = MDValueList.size(); 3301932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Trim the value list down to the size it was before we parsed this function. 3302932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines ValueList.shrinkTo(ModuleValueListSize); 3303932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.shrinkTo(ModuleMDValueListSize); 3304932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3305932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (LLVM2_7MetadataDetected) { 3306932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines MDValueList.resize(NewMDValueListSize); 3307932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3308932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3309932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<BasicBlock*>().swap(FunctionBBs); 3310d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 3311932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3312932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3313932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 3314932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// GVMaterializer implementation 3315932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 3316932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 33171bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hinesvoid BitcodeReader::releaseBuffer() { Buffer.release(); } 3318932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3319579361346abc6696c805e3904a18178ebce4e4a3Stephen Hinesstd::error_code BitcodeReader::materialize(GlobalValue *GV) { 33205cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines if (std::error_code EC = materializeMetadata()) 33215cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines return EC; 33225cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hines 3323932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *F = dyn_cast<Function>(GV); 3324932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If it's not a function or is already material, ignore the request. 3325d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!F || !F->isMaterializable()) 3326d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 3327932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3328932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F); 3329932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!"); 3330932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3331932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Move the bit stream to the saved position of the deferred function body. 3332932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Stream.JumpToBit(DFII->second); 3333932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3334d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseFunctionBody(F)) 3335d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 333634edb8ad024934c13741550bc825c9b352453ad8Stephen Hines F->setIsMaterializable(false); 3337932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3338932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Upgrade any old intrinsic calls in the function. 3339932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(), 3340932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines E = UpgradedIntrinsics.end(); I != E; ++I) { 3341932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I->first != I->second) { 33421bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines for (auto UI = I->first->user_begin(), UE = I->first->user_end(); 33431bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines UI != UE;) { 3344932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 3345932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradeIntrinsicCall(CI, I->second); 3346932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3347932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3348932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3349932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3350d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 3351932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3352932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3353932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hinesbool BitcodeReader::isDematerializable(const GlobalValue *GV) const { 3354932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines const Function *F = dyn_cast<Function>(GV); 3355932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!F || F->isDeclaration()) 3356932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return false; 3357932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return DeferredFunctionInfo.count(const_cast<Function*>(F)); 3358932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3359932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3360933b5a904f7215c692b41a1c0481f4ea5f4abde1Pirama Arumuga Nainarvoid BitcodeReader::dematerialize(GlobalValue *GV) { 3361932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Function *F = dyn_cast<Function>(GV); 3362932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // If this function isn't dematerializable, this is a noop. 3363932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!F || !isDematerializable(F)) 3364932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return; 3365932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3366932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines assert(DeferredFunctionInfo.count(F) && "No info to read function later?"); 3367932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3368932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Just forget the function body, we can remat it later. 3369932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines F->deleteBody(); 337034edb8ad024934c13741550bc825c9b352453ad8Stephen Hines F->setIsMaterializable(true); 3371932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3372932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3373f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainarstd::error_code BitcodeReader::materializeModule() { 3374932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Iterate over the module, deserializing any functions that are still on 3375932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // disk. 3376932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (Module::iterator F = TheModule->begin(), E = TheModule->end(); 3377d724d097437f40a5689464429f948ec41e4a2415Stephen Hines F != E; ++F) { 3378f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar if (std::error_code EC = materialize(&*F)) 337934edb8ad024934c13741550bc825c9b352453ad8Stephen Hines return EC; 3380d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 338134edb8ad024934c13741550bc825c9b352453ad8Stephen Hines // At this point, if there are any function bodies, the current bit is 338234edb8ad024934c13741550bc825c9b352453ad8Stephen Hines // pointing to the END_BLOCK record after them. Now make sure the rest 338334edb8ad024934c13741550bc825c9b352453ad8Stephen Hines // of the bits in the module have been read. 338434edb8ad024934c13741550bc825c9b352453ad8Stephen Hines if (NextUnreadBit) 338534edb8ad024934c13741550bc825c9b352453ad8Stephen Hines ParseModule(true); 3386932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3387932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Upgrade any intrinsic calls that slipped through (should not happen!) and 3388932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // delete the old functions to clean up. We can't do this unless the entire 3389932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // module is materialized because there could always be another function body 3390932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // with calls to the old function. 3391932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines for (std::vector<std::pair<Function*, Function*> >::iterator I = 3392932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) { 3393932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (I->first != I->second) { 33941bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines for (auto UI = I->first->user_begin(), UE = I->first->user_end(); 33951bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines UI != UE;) { 3396932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 3397932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines UpgradeIntrinsicCall(CI, I->second); 3398932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3399932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines if (!I->first->use_empty()) 3400932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->first->replaceAllUsesWith(I->second); 3401932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines I->first->eraseFromParent(); 3402932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3403932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3404932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics); 3405932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3406932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Check debug info intrinsics. 3407932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines CheckDebugInfoIntrinsics(TheModule); 3408932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3409d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 3410932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3411932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 34121bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hinesstd::vector<StructType *> BitcodeReader::getIdentifiedStructTypes() const { 34131bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return IdentifiedStructTypes; 34141bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines} 34151bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 3416d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::InitStream() { 3417d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (LazyStreamer) 3418d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return InitLazyStream(); 3419d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return InitStreamFromBuffer(); 3420d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 3421d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3422d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::InitStreamFromBuffer() { 3423d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *BufPtr = (const unsigned char*)Buffer->getBufferStart(); 3424d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); 3425d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3426579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (Buffer->getBufferSize() & 3) 34271bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid bitcode signature"); 3428d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3429d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // If we have a wrapper header, parse it and ignore the non-bc file contents. 3430d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The magic number is 0x0B17C0DE stored in little endian. 3431d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (isBitcodeWrapper(BufPtr, BufEnd)) 3432d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true)) 34331bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid bitcode wrapper header"); 3434d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3435d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamFile.reset(new BitstreamReader(BufPtr, BufEnd)); 3436579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Stream.init(&*StreamFile); 3437d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3438d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 3439d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 3440d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3441d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::InitLazyStream() { 3442d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Check and strip off the bitcode wrapper; BitstreamReader expects never to 3443d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // see it. 3444f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar auto OwnedBytes = llvm::make_unique<StreamingMemoryObject>( 3445f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar std::move(LazyStreamer)); 34461bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines StreamingMemoryObject &Bytes = *OwnedBytes; 34471bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines StreamFile = llvm::make_unique<BitstreamReader>(std::move(OwnedBytes)); 3448579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Stream.init(&*StreamFile); 3449d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3450d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned char buf[16]; 34511bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines if (Bytes.readBytes(buf, 16, 0) != 16) 34521bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid bitcode signature"); 3453d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3454d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isBitcode(buf, buf + 16)) 34551bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return Error("Invalid bitcode signature"); 3456d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3457d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (isBitcodeWrapper(buf, buf + 4)) { 3458d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *bitcodeStart = buf; 3459d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *bitcodeEnd = buf + 16; 3460d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false); 34611bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines Bytes.dropLeadingBytes(bitcodeStart - buf); 34621bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines Bytes.setKnownObjectSize(bitcodeEnd - bitcodeStart); 3463d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 3464d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 3465d724d097437f40a5689464429f948ec41e4a2415Stephen Hines} 3466d724d097437f40a5689464429f948ec41e4a2415Stephen Hines 3467d724d097437f40a5689464429f948ec41e4a2415Stephen Hinesnamespace { 34688f5c2a1c1392a6d6bdb5700f73eeadd7b01ea0b7Stephen Hinesclass BitcodeErrorCategoryType : public std::error_category { 34698f5c2a1c1392a6d6bdb5700f73eeadd7b01ea0b7Stephen Hines const char *name() const LLVM_NOEXCEPT override { 3470d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "llvm.bitcode"; 3471d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3472c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray std::string message(int IE) const override { 34731bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines BitcodeError E = static_cast<BitcodeError>(IE); 3474d724d097437f40a5689464429f948ec41e4a2415Stephen Hines switch (E) { 34751bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case BitcodeError::InvalidBitcodeSignature: 3476d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid bitcode signature"; 34771bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines case BitcodeError::CorruptedBitcode: 34781bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return "Corrupted bitcode"; 3479d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3480d724d097437f40a5689464429f948ec41e4a2415Stephen Hines llvm_unreachable("Unknown error type!"); 3481d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3482d724d097437f40a5689464429f948ec41e4a2415Stephen Hines}; 3483d724d097437f40a5689464429f948ec41e4a2415Stephen Hines} 3484d724d097437f40a5689464429f948ec41e4a2415Stephen Hines 34851bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hinesstatic ManagedStatic<BitcodeErrorCategoryType> ErrorCategory; 34861bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 34875cb1f3949c5bdd43c84647920d147a6b8509e256Stephen Hinesconst std::error_category &BitcodeReader::BitcodeErrorCategory() { 34881bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return *ErrorCategory; 3489d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 3490932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3491932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 3492932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines// External interface 3493932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines//===----------------------------------------------------------------------===// 3494932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3495932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// getLazyBitcodeModule - lazy function-at-a-time loading from a file. 3496932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// 34971bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hinesstatic llvm::ErrorOr<llvm::Module *> 34981bd9f627fa0affb457507e86b0b6684c695fe726Stephen HinesgetLazyBitcodeModuleImpl(std::unique_ptr<MemoryBuffer> &&Buffer, 34991bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines LLVMContext &Context, bool WillMaterializeAll, 35008a019dd0040bedf5078e4d18e06a244a675b80e8Chih-Hung Hsieh const DiagnosticHandlerFunction &DiagnosticHandler) { 3501932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines Module *M = new Module(Buffer->getBufferIdentifier(), Context); 35021bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines BitcodeReader *R = 35031bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines new BitcodeReader(Buffer.get(), Context, DiagnosticHandler); 3504932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines M->setMaterializer(R); 3505932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3506579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines auto cleanupOnError = [&](std::error_code EC) { 3507579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines R->releaseBuffer(); // Never take ownership on error. 3508932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete M; // Also deletes R. 3509579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return EC; 3510579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines }; 3511579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines 3512579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (std::error_code EC = R->ParseBitcodeInto(M)) 3513579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return cleanupOnError(EC); 3514579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines 3515579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Buffer.release(); // The BitcodeReader owns it now. 3516932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return M; 3517932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3518932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 35191bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hinesllvm::ErrorOr<Module *> 35201bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hinesllvm_2_7::getLazyBitcodeModule(std::unique_ptr<MemoryBuffer> &&Buffer, 35211bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines LLVMContext &Context, 35228a019dd0040bedf5078e4d18e06a244a675b80e8Chih-Hung Hsieh const DiagnosticHandlerFunction &DiagnosticHandler) { 35231bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines return getLazyBitcodeModuleImpl(std::move(Buffer), Context, false, 35241bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines DiagnosticHandler); 35251bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines} 35261bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines 3527932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// ParseBitcodeFile - Read the specified bitcode file, returning the module. 3528932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines/// If an error occurs, return null and fill in *ErrMsg if non-null. 35291bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hinesllvm::ErrorOr<llvm::Module *> 35301bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hinesllvm_2_7::parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context, 35318a019dd0040bedf5078e4d18e06a244a675b80e8Chih-Hung Hsieh const DiagnosticHandlerFunction &DiagnosticHandler) { 35321bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); 35331bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines ErrorOr<Module *> ModuleOrErr = getLazyBitcodeModuleImpl( 35341bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines std::move(Buf), Context, true, DiagnosticHandler); 3535579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!ModuleOrErr) 3536579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return ModuleOrErr; 3537579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Module *M = ModuleOrErr.get(); 3538932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines // Read in the entire module, and destroy the BitcodeReader. 3539f229c40f0d2da19985e68955aef1a06ce4121e63Pirama Arumuga Nainar if (std::error_code EC = M->materializeAll()) { 3540932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines delete M; 3541579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return EC; 3542932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines } 3543932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 3544932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines return M; 3545932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3546932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines 35471bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hinesstd::string 35481bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hinesllvm_2_7::getBitcodeTargetTriple(MemoryBufferRef Buffer, LLVMContext &Context, 35491bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines DiagnosticHandlerFunction DiagnosticHandler) { 3550579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); 35511bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines auto R = llvm::make_unique<BitcodeReader>(Buf.release(), Context, 35521bd9f627fa0affb457507e86b0b6684c695fe726Stephen Hines DiagnosticHandler); 3553579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines ErrorOr<std::string> Triple = R->parseTriple(); 3554579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (Triple.getError()) 3555579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return ""; 3556579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Triple.get(); 3557932bc6e35bcef7adff05d890a9dcc7212426fb6aStephen Hines} 3558