BitcodeReader.cpp revision 579361346abc6696c805e3904a18178ebce4e4a3
13bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===- BitcodeReader.cpp - Internal BitcodeReader implementation ----------===// 23bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// 33bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// The LLVM Compiler Infrastructure 43bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// 53bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// This file is distributed under the University of Illinois Open Source 63bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// License. See LICENSE.TXT for details. 73bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// 83bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 93bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// 103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// This header defines the BitcodeReader class. 113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// 123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/Bitcode/ReaderWriter.h" 153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "BitcodeReader.h" 16c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien#include "BitReader_3_0.h" 173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/ADT/SmallString.h" 183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/ADT/SmallVector.h" 19c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray#include "llvm/IR/AutoUpgrade.h" 20c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray#include "llvm/IR/CFG.h" 21b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/Constants.h" 22b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/DerivedTypes.h" 23b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/InlineAsm.h" 24b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/IntrinsicInst.h" 25b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/IRBuilder.h" 26b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/Module.h" 27b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/OperandTraits.h" 28b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/Operator.h" 29b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/ADT/SmallPtrSet.h" 303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/Support/MathExtras.h" 313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/Support/MemoryBuffer.h" 323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienusing namespace llvm; 33c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chienusing namespace llvm_3_0; 34c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 35c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao#define FUNC_CODE_INST_UNWIND_2_7 14 36c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao#define eh_exception_2_7 145 37c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao#define eh_selector_2_7 149 38c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 39c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien#define TYPE_BLOCK_ID_OLD_3_0 10 40c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien#define TYPE_SYMTAB_BLOCK_ID_OLD_3_0 13 41c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien#define TYPE_CODE_STRUCT_OLD_3_0 10 42c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 43c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chiennamespace { 44c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien void FindExnAndSelIntrinsics(BasicBlock *BB, CallInst *&Exn, 45c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *&Sel, 46c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien SmallPtrSet<BasicBlock*, 8> &Visited) { 47579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!Visited.insert(BB).second) return; 48c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 49c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (BasicBlock::iterator 50c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien I = BB->begin(), E = BB->end(); I != E; ++I) { 51c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (CallInst *CI = dyn_cast<CallInst>(I)) { 52c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien switch (CI->getCalledFunction()->getIntrinsicID()) { 53c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien default: break; 54c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao case eh_exception_2_7: 55c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien assert(!Exn && "Found more than one eh.exception call!"); 56c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Exn = CI; 57c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien break; 58c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao case eh_selector_2_7: 59c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien assert(!Sel && "Found more than one eh.selector call!"); 60c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Sel = CI; 61c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien break; 62c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 63c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 64c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Exn && Sel) return; 65c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 66c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 67c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 68c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Exn && Sel) return; 69c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 70c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (succ_iterator I = succ_begin(BB), E = succ_end(BB); I != E; ++I) { 71c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien FindExnAndSelIntrinsics(*I, Exn, Sel, Visited); 72c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Exn && Sel) return; 73c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 74c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 75c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 76c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 77c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 78c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// TransferClausesToLandingPadInst - Transfer the exception handling clauses 79c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// from the eh_selector call to the new landingpad instruction. 80c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien void TransferClausesToLandingPadInst(LandingPadInst *LPI, 81c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *EHSel) { 82c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LLVMContext &Context = LPI->getContext(); 83c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien unsigned N = EHSel->getNumArgOperands(); 84c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 85c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (unsigned i = N - 1; i > 1; --i) { 86c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (const ConstantInt *CI = dyn_cast<ConstantInt>(EHSel->getArgOperand(i))){ 87c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien unsigned FilterLength = CI->getZExtValue(); 88c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien unsigned FirstCatch = i + FilterLength + !FilterLength; 89c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien assert(FirstCatch <= N && "Invalid filter length"); 90c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 91c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (FirstCatch < N) 92c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (unsigned j = FirstCatch; j < N; ++j) { 93c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Value *Val = EHSel->getArgOperand(j); 94c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!Val->hasName() || Val->getName() != "llvm.eh.catch.all.value") { 95d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines LPI->addClause(cast<Constant>(EHSel->getArgOperand(j))); 96c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } else { 97c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien GlobalVariable *GV = cast<GlobalVariable>(Val); 98c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LPI->addClause(GV->getInitializer()); 99c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 100c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 101c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 102c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!FilterLength) { 103c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // Cleanup. 104c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LPI->setCleanup(true); 105c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } else { 106c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // Filter. 107c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien SmallVector<Constant *, 4> TyInfo; 108c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien TyInfo.reserve(FilterLength - 1); 109c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (unsigned j = i + 1; j < FirstCatch; ++j) 110c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien TyInfo.push_back(cast<Constant>(EHSel->getArgOperand(j))); 111c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien ArrayType *AType = 112c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien ArrayType::get(!TyInfo.empty() ? TyInfo[0]->getType() : 113c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien PointerType::getUnqual(Type::getInt8Ty(Context)), 114c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien TyInfo.size()); 115c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LPI->addClause(ConstantArray::get(AType, TyInfo)); 116c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 117c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 118c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien N = i; 119c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 120c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 121c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 122c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (N > 2) 123c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (unsigned j = 2; j < N; ++j) { 124c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Value *Val = EHSel->getArgOperand(j); 125c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!Val->hasName() || Val->getName() != "llvm.eh.catch.all.value") { 126d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines LPI->addClause(cast<Constant>(EHSel->getArgOperand(j))); 127c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } else { 128c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien GlobalVariable *GV = cast<GlobalVariable>(Val); 129c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LPI->addClause(GV->getInitializer()); 130c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 131c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 132c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 133c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 134c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 135c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// This function upgrades the old pre-3.0 exception handling system to the new 136c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// one. N.B. This will be removed in 3.1. 137c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien void UpgradeExceptionHandling(Module *M) { 138c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Function *EHException = M->getFunction("llvm.eh.exception"); 139c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Function *EHSelector = M->getFunction("llvm.eh.selector"); 140c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!EHException || !EHSelector) 141c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien return; 142c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 143c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LLVMContext &Context = M->getContext(); 144c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Type *ExnTy = PointerType::getUnqual(Type::getInt8Ty(Context)); 145c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Type *SelTy = Type::getInt32Ty(Context); 146900c6c1f08f7c572125d7d39abe0f0f9eafbfa14Chris Wailes Type *LPadSlotTy = StructType::get(ExnTy, SelTy, nullptr); 147c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 148c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // This map links the invoke instruction with the eh.exception and eh.selector 149c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // calls associated with it. 150c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien DenseMap<InvokeInst*, std::pair<Value*, Value*> > InvokeToIntrinsicsMap; 151c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (Module::iterator 152c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien I = M->begin(), E = M->end(); I != E; ++I) { 153c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Function &F = *I; 154c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 155c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (Function::iterator 156c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien II = F.begin(), IE = F.end(); II != IE; ++II) { 157c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BasicBlock *BB = &*II; 158c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien InvokeInst *Inst = dyn_cast<InvokeInst>(BB->getTerminator()); 159c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!Inst) continue; 160c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BasicBlock *UnwindDest = Inst->getUnwindDest(); 161c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (UnwindDest->isLandingPad()) continue; // Already converted. 162c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 163c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien SmallPtrSet<BasicBlock*, 8> Visited; 164c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *Exn = 0; 165c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *Sel = 0; 166c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien FindExnAndSelIntrinsics(UnwindDest, Exn, Sel, Visited); 167c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien assert(Exn && Sel && "Cannot find eh.exception and eh.selector calls!"); 168c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien InvokeToIntrinsicsMap[Inst] = std::make_pair(Exn, Sel); 169c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 170c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 171c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 172c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // This map stores the slots where the exception object and selector value are 173c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // stored within a function. 174c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien DenseMap<Function*, std::pair<Value*, Value*> > FnToLPadSlotMap; 175c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien SmallPtrSet<Instruction*, 32> DeadInsts; 176c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (DenseMap<InvokeInst*, std::pair<Value*, Value*> >::iterator 177c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien I = InvokeToIntrinsicsMap.begin(), E = InvokeToIntrinsicsMap.end(); 178c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien I != E; ++I) { 179c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien InvokeInst *Invoke = I->first; 180c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BasicBlock *UnwindDest = Invoke->getUnwindDest(); 181c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Function *F = UnwindDest->getParent(); 182c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien std::pair<Value*, Value*> EHIntrinsics = I->second; 183c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *Exn = cast<CallInst>(EHIntrinsics.first); 184c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *Sel = cast<CallInst>(EHIntrinsics.second); 185c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 186c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // Store the exception object and selector value in the entry block. 187c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Value *ExnSlot = 0; 188c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Value *SelSlot = 0; 189c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!FnToLPadSlotMap[F].first) { 190c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BasicBlock *Entry = &F->front(); 191c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien ExnSlot = new AllocaInst(ExnTy, "exn", Entry->getTerminator()); 192c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien SelSlot = new AllocaInst(SelTy, "sel", Entry->getTerminator()); 193c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien FnToLPadSlotMap[F] = std::make_pair(ExnSlot, SelSlot); 194c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } else { 195c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien ExnSlot = FnToLPadSlotMap[F].first; 196c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien SelSlot = FnToLPadSlotMap[F].second; 197c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 198c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 199c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!UnwindDest->getSinglePredecessor()) { 200c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // The unwind destination doesn't have a single predecessor. Create an 201c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // unwind destination which has only one predecessor. 202c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BasicBlock *NewBB = BasicBlock::Create(Context, "new.lpad", 203c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien UnwindDest->getParent()); 204c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BranchInst::Create(UnwindDest, NewBB); 205c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Invoke->setUnwindDest(NewBB); 206c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 207c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // Fix up any PHIs in the original unwind destination block. 208c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (BasicBlock::iterator 209c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien II = UnwindDest->begin(); isa<PHINode>(II); ++II) { 210c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien PHINode *PN = cast<PHINode>(II); 211c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien int Idx = PN->getBasicBlockIndex(Invoke->getParent()); 212c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Idx == -1) continue; 213c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien PN->setIncomingBlock(Idx, NewBB); 214c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 215c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 216c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien UnwindDest = NewBB; 217c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 218c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 219c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien IRBuilder<> Builder(Context); 220c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Builder.SetInsertPoint(UnwindDest, UnwindDest->getFirstInsertionPt()); 221c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 222c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Value *PersFn = Sel->getArgOperand(1); 223c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LandingPadInst *LPI = Builder.CreateLandingPad(LPadSlotTy, PersFn, 0); 224c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Value *LPExn = Builder.CreateExtractValue(LPI, 0); 225c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Value *LPSel = Builder.CreateExtractValue(LPI, 1); 226c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Builder.CreateStore(LPExn, ExnSlot); 227c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Builder.CreateStore(LPSel, SelSlot); 228c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 229c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien TransferClausesToLandingPadInst(LPI, Sel); 230c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 231c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien DeadInsts.insert(Exn); 232c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien DeadInsts.insert(Sel); 233c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 234c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 235c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // Replace the old intrinsic calls with the values from the landingpad 236c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // instruction(s). These values were stored in allocas for us to use here. 237c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (DenseMap<InvokeInst*, std::pair<Value*, Value*> >::iterator 238c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien I = InvokeToIntrinsicsMap.begin(), E = InvokeToIntrinsicsMap.end(); 239c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien I != E; ++I) { 240c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien std::pair<Value*, Value*> EHIntrinsics = I->second; 241c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *Exn = cast<CallInst>(EHIntrinsics.first); 242c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *Sel = cast<CallInst>(EHIntrinsics.second); 243c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BasicBlock *Parent = Exn->getParent(); 244c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 245c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien std::pair<Value*,Value*> ExnSelSlots = FnToLPadSlotMap[Parent->getParent()]; 246c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 247c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien IRBuilder<> Builder(Context); 248c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Builder.SetInsertPoint(Parent, Exn); 249c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LoadInst *LPExn = Builder.CreateLoad(ExnSelSlots.first, "exn.load"); 250c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LoadInst *LPSel = Builder.CreateLoad(ExnSelSlots.second, "sel.load"); 251c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 252c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Exn->replaceAllUsesWith(LPExn); 253c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Sel->replaceAllUsesWith(LPSel); 254c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 255c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 256c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // Remove the dead instructions. 257c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (SmallPtrSet<Instruction*, 32>::iterator 258c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien I = DeadInsts.begin(), E = DeadInsts.end(); I != E; ++I) { 259c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Instruction *Inst = *I; 260c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Inst->eraseFromParent(); 261c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 262c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 263c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // Replace calls to "llvm.eh.resume" with the 'resume' instruction. Load the 264c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // exception and selector values from the stored place. 265c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Function *EHResume = M->getFunction("llvm.eh.resume"); 266c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!EHResume) return; 267c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 268c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien while (!EHResume->use_empty()) { 269c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray CallInst *Resume = cast<CallInst>(*EHResume->use_begin()); 270c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BasicBlock *BB = Resume->getParent(); 271c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 272c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien IRBuilder<> Builder(Context); 273c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Builder.SetInsertPoint(BB, Resume); 274c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 275c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Value *LPadVal = 276c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Builder.CreateInsertValue(UndefValue::get(LPadSlotTy), 277c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Resume->getArgOperand(0), 0, "lpad.val"); 278c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LPadVal = Builder.CreateInsertValue(LPadVal, Resume->getArgOperand(1), 279c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 1, "lpad.val"); 280c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Builder.CreateResume(LPadVal); 281c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 282c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // Remove all instructions after the 'resume.' 283c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BasicBlock::iterator I = Resume; 284c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien while (I != BB->end()) { 285c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Instruction *Inst = &*I++; 286c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Inst->eraseFromParent(); 287c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 288c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 289c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 290c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 291c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 292c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray void StripDebugInfoOfFunction(Module* M, const char* name) { 293c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray if (Function* FuncStart = M->getFunction(name)) { 294c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray while (!FuncStart->use_empty()) { 295c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray cast<CallInst>(*FuncStart->use_begin())->eraseFromParent(); 296c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray } 297c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray FuncStart->eraseFromParent(); 298c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray } 299c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray } 300c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray 301c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// This function strips all debug info intrinsics, except for llvm.dbg.declare. 302c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// If an llvm.dbg.declare intrinsic is invalid, then this function simply 303c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// strips that use. 304c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien void CheckDebugInfoIntrinsics(Module *M) { 305c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray StripDebugInfoOfFunction(M, "llvm.dbg.func.start"); 306c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray StripDebugInfoOfFunction(M, "llvm.dbg.stoppoint"); 307c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray StripDebugInfoOfFunction(M, "llvm.dbg.region.start"); 308c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray StripDebugInfoOfFunction(M, "llvm.dbg.region.end"); 309c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 310c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Function *Declare = M->getFunction("llvm.dbg.declare")) { 311c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!Declare->use_empty()) { 312c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray DbgDeclareInst *DDI = cast<DbgDeclareInst>(*Declare->use_begin()); 313c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!isa<MDNode>(DDI->getArgOperand(0)) || 314c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien !isa<MDNode>(DDI->getArgOperand(1))) { 315c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien while (!Declare->use_empty()) { 316c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray CallInst *CI = cast<CallInst>(*Declare->use_begin()); 317c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CI->eraseFromParent(); 318c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 319c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Declare->eraseFromParent(); 320c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 321c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 322c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 323c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 324c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien} // end anonymous namespace 3253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReader::FreeState() { 327579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Buffer = nullptr; 3283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Type*>().swap(TypeList); 3293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.clear(); 3303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValueList.clear(); 3313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 332b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines std::vector<AttributeSet>().swap(MAttributes); 3333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<BasicBlock*>().swap(FunctionBBs); 3343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Function*>().swap(FunctionsWithBodies); 3353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DeferredFunctionInfo.clear(); 3363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDKindMap.clear(); 3373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 3403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// Helper functions to implement forward reference resolution, etc. 3413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 3423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ConvertToString - Convert a string from a record into an std::string, return 3443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// true on failure. 3453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chientemplate<typename StrTy> 3463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic bool ConvertToString(SmallVector<uint64_t, 64> &Record, unsigned Idx, 3473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien StrTy &Result) { 3483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx > Record.size()) 3493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return true; 3503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = Idx, e = Record.size(); i != e; ++i) 3523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Result += (char)Record[i]; 3533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 3543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) { 3573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 3583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Map unknown/new linkages to external 3593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 0: return GlobalValue::ExternalLinkage; 3603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 1: return GlobalValue::WeakAnyLinkage; 3613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 2: return GlobalValue::AppendingLinkage; 3623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 3: return GlobalValue::InternalLinkage; 3633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 4: return GlobalValue::LinkOnceAnyLinkage; 364c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray case 5: return GlobalValue::ExternalLinkage; // Was DLLImportLinkage; 365c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray case 6: return GlobalValue::ExternalLinkage; // Was DLLExportLinkage; 3663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 7: return GlobalValue::ExternalWeakLinkage; 3673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 8: return GlobalValue::CommonLinkage; 3683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 9: return GlobalValue::PrivateLinkage; 3693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 10: return GlobalValue::WeakODRLinkage; 3703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 11: return GlobalValue::LinkOnceODRLinkage; 3713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 12: return GlobalValue::AvailableExternallyLinkage; 372c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray case 13: return GlobalValue::PrivateLinkage; // Was LinkerPrivateLinkage; 373c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray case 14: return GlobalValue::ExternalWeakLinkage; // Was LinkerPrivateWeakLinkage; 374d724d097437f40a5689464429f948ec41e4a2415Stephen Hines //ANDROID: convert LinkOnceODRAutoHideLinkage -> LinkOnceODRLinkage 375d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case 15: return GlobalValue::LinkOnceODRLinkage; 3763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 3773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) { 3803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 3813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Map unknown visibilities to default. 3823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 0: return GlobalValue::DefaultVisibility; 3833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 1: return GlobalValue::HiddenVisibility; 3843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 2: return GlobalValue::ProtectedVisibility; 3853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 3863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3888b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liaostatic GlobalVariable::ThreadLocalMode GetDecodedThreadLocalMode(unsigned Val) { 3898b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao switch (Val) { 3908b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 0: return GlobalVariable::NotThreadLocal; 3918b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao default: // Map unknown non-zero value to general dynamic. 3928b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 1: return GlobalVariable::GeneralDynamicTLSModel; 3938b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 2: return GlobalVariable::LocalDynamicTLSModel; 3948b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 3: return GlobalVariable::InitialExecTLSModel; 3958b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 4: return GlobalVariable::LocalExecTLSModel; 3968b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao } 3978b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao} 3988b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao 3993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic int GetDecodedCastOpcode(unsigned Val) { 4003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: return -1; 4023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_TRUNC : return Instruction::Trunc; 4033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_ZEXT : return Instruction::ZExt; 4043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_SEXT : return Instruction::SExt; 4053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_FPTOUI : return Instruction::FPToUI; 4063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_FPTOSI : return Instruction::FPToSI; 4073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_UITOFP : return Instruction::UIToFP; 4083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_SITOFP : return Instruction::SIToFP; 4093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_FPTRUNC : return Instruction::FPTrunc; 4103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_FPEXT : return Instruction::FPExt; 4113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_PTRTOINT: return Instruction::PtrToInt; 4123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_INTTOPTR: return Instruction::IntToPtr; 4133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_BITCAST : return Instruction::BitCast; 4143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic int GetDecodedBinaryOpcode(unsigned Val, Type *Ty) { 4173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: return -1; 4193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_ADD: 4203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FAdd : Instruction::Add; 4213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_SUB: 4223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FSub : Instruction::Sub; 4233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_MUL: 4243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FMul : Instruction::Mul; 4253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_UDIV: return Instruction::UDiv; 4263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_SDIV: 4273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FDiv : Instruction::SDiv; 4283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_UREM: return Instruction::URem; 4293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_SREM: 4303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FRem : Instruction::SRem; 4313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_SHL: return Instruction::Shl; 4323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_LSHR: return Instruction::LShr; 4333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_ASHR: return Instruction::AShr; 4343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_AND: return Instruction::And; 4353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_OR: return Instruction::Or; 4363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_XOR: return Instruction::Xor; 4373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 4403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic AtomicRMWInst::BinOp GetDecodedRMWOperation(unsigned Val) { 4413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: return AtomicRMWInst::BAD_BINOP; 4433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_XCHG: return AtomicRMWInst::Xchg; 4443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_ADD: return AtomicRMWInst::Add; 4453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_SUB: return AtomicRMWInst::Sub; 4463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_AND: return AtomicRMWInst::And; 4473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_NAND: return AtomicRMWInst::Nand; 4483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_OR: return AtomicRMWInst::Or; 4493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_XOR: return AtomicRMWInst::Xor; 4503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_MAX: return AtomicRMWInst::Max; 4513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_MIN: return AtomicRMWInst::Min; 4523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_UMAX: return AtomicRMWInst::UMax; 4533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_UMIN: return AtomicRMWInst::UMin; 4543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 4573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic AtomicOrdering GetDecodedOrdering(unsigned Val) { 4583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_NOTATOMIC: return NotAtomic; 4603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_UNORDERED: return Unordered; 4613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_MONOTONIC: return Monotonic; 4623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_ACQUIRE: return Acquire; 4633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_RELEASE: return Release; 4643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_ACQREL: return AcquireRelease; 4653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Map unknown orderings to sequentially-consistent. 4663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_SEQCST: return SequentiallyConsistent; 4673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 4703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic SynchronizationScope GetDecodedSynchScope(unsigned Val) { 4713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::SYNCHSCOPE_SINGLETHREAD: return SingleThread; 4733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Map unknown scopes to cross-thread. 4743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::SYNCHSCOPE_CROSSTHREAD: return CrossThread; 4753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 4783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chiennamespace llvm { 4793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chiennamespace { 4803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// @brief A class for maintaining the slot number definition 4813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// as a placeholder for the actual definition for forward constants defs. 4823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien class ConstantPlaceHolder : public ConstantExpr { 4833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien void operator=(const ConstantPlaceHolder &); // DO NOT IMPLEMENT 4843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien public: 4853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // allocate space for exactly one operand 4863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien void *operator new(size_t s) { 4873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return User::operator new(s, 1); 4883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien explicit ConstantPlaceHolder(Type *Ty, LLVMContext& Context) 4903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) { 4913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Op<0>() = UndefValue::get(Type::getInt32Ty(Context)); 4923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 4943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// @brief Methods to support type inquiry through isa, cast, and dyn_cast. 4953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien //static inline bool classof(const ConstantPlaceHolder *) { return true; } 4963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien static bool classof(const Value *V) { 4973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return isa<ConstantExpr>(V) && 4983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1; 4993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// Provide fast operand accessors 5033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien //DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 5043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien }; 5053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// FIXME: can we inherit this from ConstantExpr? 5083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chientemplate <> 5093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstruct OperandTraits<ConstantPlaceHolder> : 5103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien public FixedNumOperandTraits<ConstantPlaceHolder, 1> { 5113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien}; 5123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) { 5163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx == size()) { 5173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien push_back(V); 5183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 5193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 5223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx+1); 5233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien WeakVH &OldV = ValuePtrs[Idx]; 525579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!OldV) { 5263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV = V; 5273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 5283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Handle constants and non-constants (e.g. instrs) differently for 5313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // efficiency. 5323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Constant *PHC = dyn_cast<Constant>(&*OldV)) { 5333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResolveConstants.push_back(std::make_pair(PHC, Idx)); 5343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV = V; 5353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 5363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If there was a forward reference to this value, replace it. 5373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *PrevVal = OldV; 5383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV->replaceAllUsesWith(V); 5393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete PrevVal; 5403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienConstant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, 5453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty) { 5463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 5473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx + 1); 5483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Value *V = ValuePtrs[Idx]) { 5503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(Ty == V->getType() && "Type mismatch in constant table!"); 5513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return cast<Constant>(V); 5523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Create and return a placeholder, which will later be RAUW'd. 5553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *C = new ConstantPlaceHolder(Ty, Context); 5563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValuePtrs[Idx] = C; 5573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return C; 5583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienValue *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty) { 5613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 5623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx + 1); 5633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Value *V = ValuePtrs[Idx]) { 565579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines assert((!Ty || Ty == V->getType()) && "Type mismatch in value table!"); 5663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V; 5673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No type specified, must be invalid reference. 570579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!Ty) return nullptr; 5713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Create and return a placeholder, which will later be RAUW'd. 5733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = new Argument(Ty); 5743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValuePtrs[Idx] = V; 5753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V; 5763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ResolveConstantForwardRefs - Once all constants are read, this method bulk 5793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// resolves any forward references. The idea behind this is that we sometimes 5803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// get constants (such as large arrays) which reference *many* forward ref 5813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// constants. Replacing each of these causes a lot of thrashing when 5823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// building/reuniquing the constant. Instead of doing this, we look at all the 5833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// uses and rewrite all the place holders at once for any constant that uses 5843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// a placeholder. 5853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReaderValueList::ResolveConstantForwardRefs() { 5863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Sort the values by-pointer so that they are efficient to look up with a 5873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // binary search. 5883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::sort(ResolveConstants.begin(), ResolveConstants.end()); 5893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Constant*, 64> NewOps; 5913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!ResolveConstants.empty()) { 5933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *RealVal = operator[](ResolveConstants.back().second); 5943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Placeholder = ResolveConstants.back().first; 5953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResolveConstants.pop_back(); 5963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Loop over all users of the placeholder, updating them to reference the 5983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // new value. If they reference more than one placeholder, update them all 5993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // at once. 6003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!Placeholder->use_empty()) { 6013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value::use_iterator UI = Placeholder->use_begin(); 602c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray Use &use = *UI; 603c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray User *U = use.getUser(); 6043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If the using object isn't uniqued, just update the operands. This 6063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // handles instructions and initializers for global variables. 6073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!isa<Constant>(U) || isa<GlobalValue>(U)) { 608c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray use.set(RealVal); 6093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 6103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Otherwise, we have a constant that uses the placeholder. Replace that 6133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // constant with a new constant that has *all* placeholder uses updated. 6143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *UserC = cast<Constant>(U); 6153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (User::op_iterator I = UserC->op_begin(), E = UserC->op_end(); 6163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I != E; ++I) { 6173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *NewOp; 6183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!isa<ConstantPlaceHolder>(*I)) { 6193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Not a placeholder reference. 6203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOp = *I; 6213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (*I == Placeholder) { 6223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Common case is that it just references this one placeholder. 6233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOp = RealVal; 6243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 6253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Otherwise, look up the placeholder in ResolveConstants. 6263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResolveConstantsTy::iterator It = 6273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::lower_bound(ResolveConstants.begin(), ResolveConstants.end(), 6283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::pair<Constant*, unsigned>(cast<Constant>(*I), 6293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 0)); 6303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(It != ResolveConstants.end() && It->first == *I); 6313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOp = operator[](It->second); 6323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOps.push_back(cast<Constant>(NewOp)); 6353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Make the new constant. 6383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *NewC; 6393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) { 6403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewC = ConstantArray::get(UserCA->getType(), NewOps); 6413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) { 6423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewC = ConstantStruct::get(UserCS->getType(), NewOps); 6433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (isa<ConstantVector>(UserC)) { 6443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewC = ConstantVector::get(NewOps); 6453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 6463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr."); 6473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewC = cast<ConstantExpr>(UserC)->getWithOperands(NewOps); 6483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UserC->replaceAllUsesWith(NewC); 6513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UserC->destroyConstant(); 6523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOps.clear(); 6533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Update all ValueHandles, they should be the only users at this point. 6563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Placeholder->replaceAllUsesWith(RealVal); 6573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete Placeholder; 6583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 6603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReaderMDValueList::AssignValue(Value *V, unsigned Idx) { 6623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx == size()) { 6633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien push_back(V); 6643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 6653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 6683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx+1); 6693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien WeakVH &OldV = MDValuePtrs[Idx]; 6713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OldV == 0) { 6723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV = V; 6733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 6743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If there was a forward reference to this value, replace it. 6773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDNode *PrevVal = cast<MDNode>(OldV); 6783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV->replaceAllUsesWith(V); 6793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDNode::deleteTemporary(PrevVal); 6803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Deleting PrevVal sets Idx value in MDValuePtrs to null. Set new 6813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // value for Idx. 6823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValuePtrs[Idx] = V; 6833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 6843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienValue *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { 6863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 6873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx + 1); 6883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Value *V = MDValuePtrs[Idx]) { 6903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(V->getType()->isMetadataTy() && "Type mismatch in value table!"); 6913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V; 6923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Create and return a placeholder, which will later be RAUW'd. 6953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = MDNode::getTemporary(Context, ArrayRef<Value*>()); 6963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValuePtrs[Idx] = V; 6973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V; 6983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 6993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienType *BitcodeReader::getTypeByID(unsigned ID) { 7013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // The type table size is always specified correctly. 7023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ID >= TypeList.size()) 7033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return 0; 704c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 7053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *Ty = TypeList[ID]) 7063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty; 7073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If we have a forward reference, the only possible case is when it is to a 7093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // named struct. Just create a placeholder for now. 7103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return TypeList[ID] = StructType::create(Context); 7113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 7123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// FIXME: Remove in LLVM 3.1, only used by ParseOldTypeTable. 7143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienType *BitcodeReader::getTypeByIDOrNull(unsigned ID) { 7153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ID >= TypeList.size()) 7163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList.resize(ID+1); 717c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 7183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return TypeList[ID]; 7193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 7203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 7233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// Functions for parsing blocks from the bitcode file 7243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 7253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 726d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 727d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// \brief This fills an AttrBuilder object with the LLVM attributes that have 728d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// been decoded from the given integer. This function must stay in sync with 729d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// 'encodeLLVMAttributesForBitcode'. 730d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesstatic void decodeLLVMAttributesForBitcode(AttrBuilder &B, 731d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines uint64_t EncodedAttrs) { 732d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // FIXME: Remove in 4.0. 733d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 734d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The alignment is stored as a 16-bit raw value from bits 31--16. We shift 735d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // the bits above 31 down by 11 bits. 736d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16; 737d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines assert((!Alignment || isPowerOf2_32(Alignment)) && 738d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines "Alignment must be a power of two."); 739d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 740d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Alignment) 741d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines B.addAlignmentAttr(Alignment); 742d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines B.addRawValue(((EncodedAttrs & (0xfffffULL << 32)) >> 11) | 743d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines (EncodedAttrs & 0xffff)); 744d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 745d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 746d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseAttributeBlock() { 7473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) 748579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 7493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!MAttributes.empty()) 751579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidMultipleBlocks); 7523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 7543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 755d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SmallVector<AttributeSet, 8> Attrs; 7563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records. 7583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 759d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 7603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 761d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 762d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 763d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 764579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 765d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 766d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 767d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 768d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 769d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 7703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 7713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 7733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 774d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 7753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: ignore. 7763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 777d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::PARAMATTR_CODE_ENTRY_OLD: { // ENTRY: [paramidx0, attr0, ...] 778d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // FIXME: Remove in 4.0. 7793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() & 1) 780579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 7813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 782b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 783d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines AttrBuilder B; 784d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines decodeLLVMAttributesForBitcode(B, Record[i+1]); 785d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.push_back(AttributeSet::get(Context, Record[i], B)); 7863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 7873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 788d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines MAttributes.push_back(AttributeSet::get(Context, Attrs)); 789d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.clear(); 790d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 791d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 792d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [attrgrp0, attrgrp1, ...] 793d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (unsigned i = 0, e = Record.size(); i != e; ++i) 794d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.push_back(MAttributeGroups[Record[i]]); 7953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 796b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines MAttributes.push_back(AttributeSet::get(Context, Attrs)); 7973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Attrs.clear(); 7983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 7993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 8033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 804d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 805d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseTypeTable() { 8063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW)) 807579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 808c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 8093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return ParseTypeTableBody(); 8103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 8113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 812d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseTypeTableBody() { 8133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!TypeList.empty()) 814579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidMultipleBlocks); 8153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 8173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumRecords = 0; 8183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<64> TypeName; 820c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 8213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this type table. 8223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 823d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 824d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 825d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 826d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 827d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 828579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 829d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 8303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumRecords != TypeList.size()) 831579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 832d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 833d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 834d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 835d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 8363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 8393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 840579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Type *ResultTy = nullptr; 841d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 842d724d097437f40a5689464429f948ec41e4a2415Stephen Hines default: 843579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidValue); 8443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 8453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // TYPE_CODE_NUMENTRY contains a count of the number of types in the 8463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // type list. This allows us to reserve space. 8473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 848579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 8493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList.resize(Record[0]); 8503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 8513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_VOID: // VOID 8523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getVoidTy(Context); 8533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 854d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::TYPE_CODE_HALF: // HALF 855d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ResultTy = Type::getHalfTy(Context); 856d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 8573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FLOAT: // FLOAT 8583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getFloatTy(Context); 8593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_DOUBLE: // DOUBLE 8613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getDoubleTy(Context); 8623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_X86_FP80: // X86_FP80 8643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getX86_FP80Ty(Context); 8653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FP128: // FP128 8673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getFP128Ty(Context); 8683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 8703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getPPC_FP128Ty(Context); 8713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_LABEL: // LABEL 8733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getLabelTy(Context); 8743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_METADATA: // METADATA 8763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getMetadataTy(Context); 8773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_X86_MMX: // X86_MMX 8793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getX86_MMXTy(Context); 8803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 8823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 883579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 8843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = IntegerType::get(Context, Record[0]); 8863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 8883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // [pointee type, address space] 8893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 890579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 8913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned AddressSpace = 0; 8923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() == 2) 8933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AddressSpace = Record[1]; 8943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = getTypeByID(Record[0]); 895579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!ResultTy) 896579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidType); 8973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = PointerType::get(ResultTy, AddressSpace); 8983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FUNCTION_OLD: { 901b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // FIXME: attrid is dead, remove it in LLVM 4.0 9023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [vararg, attrid, retty, paramty x N] 9033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 904579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 905b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Type*, 8> ArgTys; 9063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 3, e = Record.size(); i != e; ++i) { 9073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *T = getTypeByID(Record[i])) 9083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArgTys.push_back(T); 9093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 9103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 912c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 9133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = getTypeByID(Record[2]); 914579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!ResultTy || ArgTys.size() < Record.size()-3) 915579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidType); 9163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 9173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 9183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FUNCTION: { 9213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [vararg, retty, paramty x N] 9223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 923579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 924d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SmallVector<Type*, 8> ArgTys; 9253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 2, e = Record.size(); i != e; ++i) { 9263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *T = getTypeByID(Record[i])) 9273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArgTys.push_back(T); 9283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 9293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 931c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 9323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = getTypeByID(Record[1]); 933579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!ResultTy || ArgTys.size() < Record.size()-2) 934579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidType); 9353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 9363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 9373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N] 9403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 941579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 942b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Type*, 8> EltTys; 9433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1, e = Record.size(); i != e; ++i) { 9443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *T = getTypeByID(Record[i])) 9453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien EltTys.push_back(T); 9463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 9473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (EltTys.size() != Record.size()-1) 950579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidType); 9513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = StructType::get(Context, EltTys, Record[0]); 9523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N] 9553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, TypeName)) 956579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 9573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 9583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 9593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N] 9603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 961579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 962c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 9633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumRecords >= TypeList.size()) 964579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTYPETable); 965c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 9663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check to see if this was forward referenced, if so fill in the temp. 9673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 9683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Res) { 9693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res->setName(TypeName); 970579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines TypeList[NumRecords] = nullptr; 9713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else // Otherwise, create a new struct. 9723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res = StructType::create(Context, TypeName); 9733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeName.clear(); 974c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 9753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Type*, 8> EltTys; 9763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1, e = Record.size(); i != e; ++i) { 9773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *T = getTypeByID(Record[i])) 9783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien EltTys.push_back(T); 9793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 9803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (EltTys.size() != Record.size()-1) 983579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 9843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res->setBody(EltTys, Record[0]); 9853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Res; 9863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: [] 9893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() != 1) 990579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 9913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 9923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumRecords >= TypeList.size()) 993579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTYPETable); 994c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 9953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check to see if this was forward referenced, if so fill in the temp. 9963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 9973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Res) { 9983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res->setName(TypeName); 999579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines TypeList[NumRecords] = nullptr; 10003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else // Otherwise, create a new struct with no body. 10013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res = StructType::create(Context, TypeName); 10023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeName.clear(); 10033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Res; 10043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1005c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 10063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 10073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 1008579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 10093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByID(Record[1]))) 10103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = ArrayType::get(ResultTy, Record[0]); 10113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 1012579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidType); 10133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 10143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 10153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 1016579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 10173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByID(Record[1]))) 10183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = VectorType::get(ResultTy, Record[0]); 10193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 1020579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidType); 10213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 10223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 10233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 10243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumRecords >= TypeList.size()) 1025579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTYPETable); 10263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(ResultTy && "Didn't read a type?"); 1027579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines assert(!TypeList[NumRecords] && "Already read type?"); 10283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList[NumRecords++] = ResultTy; 10293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 10303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 10313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 10323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// FIXME: Remove in LLVM 3.1 1033d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseOldTypeTable() { 1034c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Stream.EnterSubBlock(TYPE_BLOCK_ID_OLD_3_0)) 1035579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 10363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 10373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!TypeList.empty()) 1038579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTYPETable); 1039c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 1040c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // While horrible, we have no good ordering of types in the bc file. Just 10423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // iteratively parse types out of the bc file in multiple passes until we get 10433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // them all. Do this by saving a cursor for the start of the type block. 10443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BitstreamCursor StartOfTypeBlockCursor(Stream); 1045c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumTypesRead = 0; 1047c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 10493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienRestartScan: 10503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NextTypeID = 0; 10513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool ReadAnyTypes = false; 1052c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this type table. 10543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 10553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 10563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 10573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextTypeID != TypeList.size()) 1058579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTYPETable); 1059c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If we haven't read all of the types yet, iterate again. 10613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumTypesRead != TypeList.size()) { 10623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If we didn't successfully read any types in this pass, then we must 10633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // have an unhandled forward reference. 10643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!ReadAnyTypes) 1065579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTYPETable); 1066c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream = StartOfTypeBlockCursor; 10683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien goto RestartScan; 10693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1070c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 1072579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTYPETable); 1073d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 10743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1075c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 10773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No known subblocks, always skip them. 10783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadSubBlockID(); 10793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 1080579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 10813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 10823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1083c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 10853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 10863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 10873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1088c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 10903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 1091579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Type *ResultTy = nullptr; 1092d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 1093579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines default: return Error(BitcodeError::InvalidTYPETable); 10943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 10953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // TYPE_CODE_NUMENTRY contains a count of the number of types in the 10963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // type list. This allows us to reserve space. 10973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 1098579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTYPETable); 10993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList.resize(Record[0]); 11003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 11013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_VOID: // VOID 11023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getVoidTy(Context); 11033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FLOAT: // FLOAT 11053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getFloatTy(Context); 11063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_DOUBLE: // DOUBLE 11083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getDoubleTy(Context); 11093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_X86_FP80: // X86_FP80 11113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getX86_FP80Ty(Context); 11123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FP128: // FP128 11143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getFP128Ty(Context); 11153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 11173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getPPC_FP128Ty(Context); 11183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_LABEL: // LABEL 11203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getLabelTy(Context); 11213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_METADATA: // METADATA 11233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getMetadataTy(Context); 11243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_X86_MMX: // X86_MMX 11263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getX86_MMXTy(Context); 11273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 11293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 1130579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTYPETable); 11313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = IntegerType::get(Context, Record[0]); 11323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_OPAQUE: // OPAQUE 11343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextTypeID < TypeList.size() && TypeList[NextTypeID] == 0) 1135b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines ResultTy = StructType::create(Context, ""); 11363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1137c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien case TYPE_CODE_STRUCT_OLD_3_0: {// STRUCT_OLD 11383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextTypeID >= TypeList.size()) break; 11393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If we already read it, don't reprocess. 11403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (TypeList[NextTypeID] && 11413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien !cast<StructType>(TypeList[NextTypeID])->isOpaque()) 11423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 11443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Set a type. 11453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (TypeList[NextTypeID] == 0) 1146b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines TypeList[NextTypeID] = StructType::create(Context, ""); 11473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 11483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Type*> EltTys; 11493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1, e = Record.size(); i != e; ++i) { 11503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *Elt = getTypeByIDOrNull(Record[i])) 11513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien EltTys.push_back(Elt); 11523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 11533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 11553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 11563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (EltTys.size() != Record.size()-1) 11573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; // Not all elements are ready. 1158c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 11593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<StructType>(TypeList[NextTypeID])->setBody(EltTys, Record[0]); 11603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = TypeList[NextTypeID]; 11613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList[NextTypeID] = 0; 11623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 11643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 11653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // [pointee type, address space] 11663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 1167579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTYPETable); 11683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned AddressSpace = 0; 11693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() == 2) 11703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AddressSpace = Record[1]; 11713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[0]))) 11723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = PointerType::get(ResultTy, AddressSpace); 11733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 11753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FUNCTION_OLD: { 11763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FIXME: attrid is dead, remove it in LLVM 3.0 11773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [vararg, attrid, retty, paramty x N] 11783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 1179579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTYPETable); 11803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Type*> ArgTys; 11813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 3, e = Record.size(); i != e; ++i) { 11823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *Elt = getTypeByIDOrNull(Record[i])) 11833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArgTys.push_back(Elt); 11843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 11853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 11873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ArgTys.size()+3 != Record.size()) 11883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; // Something was null. 11893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[2]))) 11903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 11913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 11933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FUNCTION: { 11943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [vararg, retty, paramty x N] 11953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 1196579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTYPETable); 11973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Type*> ArgTys; 11983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 2, e = Record.size(); i != e; ++i) { 11993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *Elt = getTypeByIDOrNull(Record[i])) 12003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArgTys.push_back(Elt); 12013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 12023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ArgTys.size()+2 != Record.size()) 12053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; // Something was null. 12063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[1]))) 12073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 12083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 12113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 1212579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTYPETable); 12133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[1]))) 12143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = ArrayType::get(ResultTy, Record[0]); 12153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 12173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 1218579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTYPETable); 12193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[1]))) 12203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = VectorType::get(ResultTy, Record[0]); 12213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1223c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 12243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextTypeID >= TypeList.size()) 1225579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTYPETable); 1226c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 12273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ResultTy && TypeList[NextTypeID] == 0) { 12283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ++NumTypesRead; 12293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ReadAnyTypes = true; 1230c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 12313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList[NextTypeID] = ResultTy; 12323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1233c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 12343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ++NextTypeID; 12353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 12373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1239d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseOldTypeSymbolTable() { 1240c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Stream.EnterSubBlock(TYPE_SYMTAB_BLOCK_ID_OLD_3_0)) 1241579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 12423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 12443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this type table. 12463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string TypeName; 12473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 12483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 12493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 12503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 1251579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 1252d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 12533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 12563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No known subblocks, always skip them. 12573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadSubBlockID(); 12583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 1259579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 12603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 12613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 12643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 12653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 12663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 12693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 1270d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 12713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: unknown type. 12723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TST_CODE_ENTRY: // TST_ENTRY: [typeid, namechar x N] 12743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 1, TypeName)) 1275579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 12763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned TypeID = Record[0]; 12773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (TypeID >= TypeList.size()) 1278579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 12793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Only apply the type name to a struct type with no name. 12813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (StructType *STy = dyn_cast<StructType>(TypeList[TypeID])) 12823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!STy->isLiteral() && !STy->hasName()) 12833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien STy->setName(TypeName); 12843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeName.clear(); 12853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 12893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1290d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseValueSymbolTable() { 12913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) 1292579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 12933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 12953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this value table. 12973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<128> ValueName; 12983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 12993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 13003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 13013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 1302579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 1303d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 13043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 13063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No known subblocks, always skip them. 13073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadSubBlockID(); 13083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 1309579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 13103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 13113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 13143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 13153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 13163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 13193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 1320d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 13213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: unknown type. 13223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 13233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N] 13243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 1, ValueName)) 1325579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 13263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ValueID = Record[0]; 13273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ValueID >= ValueList.size()) 1328579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 13293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = ValueList[ValueID]; 13303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V->setName(StringRef(ValueName.data(), ValueName.size())); 13323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueName.clear(); 13333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 13343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::VST_CODE_BBENTRY: { 13363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 1, ValueName)) 1337579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 13383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *BB = getBasicBlock(Record[0]); 1339579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!BB) 1340579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 13413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BB->setName(StringRef(ValueName.data(), ValueName.size())); 13433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueName.clear(); 13443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 13453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 13493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1350d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseMetadata() { 13513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NextMDValueNo = MDValueList.size(); 13523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) 1354579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 13553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 13573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records. 13593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 13603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 13613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 13623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 1363579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 1364d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 13653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 13683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No known subblocks, always skip them. 13693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadSubBlockID(); 13703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 1371579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 13723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 13733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 13763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 13773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 13783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool IsFunctionLocal = false; 13813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 13823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 1383d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Code = Stream.readRecord(Code, Record); 13843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Code) { 13853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: ignore. 13863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 13873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_NAME: { 13883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read named of the named metadata. 13893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NameLength = Record.size(); 13903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<8> Name; 13913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Name.resize(NameLength); 13923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != NameLength; ++i) 13933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Name[i] = Record[i]; 13943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 13953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Code = Stream.ReadCode(); 13963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // METADATA_NAME is always followed by METADATA_NAMED_NODE. 1398d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned NextBitCode = Stream.readRecord(Code, Record); 13993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(NextBitCode == bitc::METADATA_NAMED_NODE); (void)NextBitCode; 14003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 14013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read named metadata elements. 14023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 14033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NamedMDNode *NMD = TheModule->getOrInsertNamedMetadata(Name); 14043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) { 1405579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines MDNode *MD = dyn_cast_or_null<MDNode>(MDValueList.getValueFwdRef(Record[i])); 1406579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!MD) 1407579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 14083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NMD->addOperand(MD); 14093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 14113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_FN_NODE: 14133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien IsFunctionLocal = true; 14143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // fall-through 14153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_NODE: { 14163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() % 2 == 1) 1417579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 14183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 14193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 14203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Value*, 8> Elts; 14213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; i += 2) { 14223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[i]); 1423d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 1424579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 14253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ty->isMetadataTy()) 14263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); 14273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (!Ty->isVoidTy()) 14283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty)); 14293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 1430900c6c1f08f7c572125d7d39abe0f0f9eafbfa14Chris Wailes Elts.push_back(nullptr); 14313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = MDNode::getWhenValsUnresolved(Context, Elts, IsFunctionLocal); 14333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien IsFunctionLocal = false; 14343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValueList.AssignValue(V, NextMDValueNo++); 14353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 14363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_STRING: { 14383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned MDStringLength = Record.size(); 14393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<8> String; 14403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien String.resize(MDStringLength); 14413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != MDStringLength; ++i) 14423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien String[i] = Record[i]; 14433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = MDString::get(Context, 14443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien StringRef(String.data(), String.size())); 14453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValueList.AssignValue(V, NextMDValueNo++); 14463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 14473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_KIND: { 14493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned RecordLength = Record.size(); 14503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty() || RecordLength < 2) 1451579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 14523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<8> Name; 14533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Name.resize(RecordLength-1); 14543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Kind = Record[0]; 14553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1; i != RecordLength; ++i) 14563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Name[i-1] = Record[i]; 1457c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 14583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NewKind = TheModule->getMDKindID(Name.str()); 14593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) 1460579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::ConflictingMETADATA_KINDRecords); 14613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 14623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 14663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1467d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// decodeSignRotatedValue - Decode a signed value stored with the sign bit in 14683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// the LSB for dense VBR encoding. 1469d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesuint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) { 14703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((V & 1) == 0) 14713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V >> 1; 14723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (V != 1) 14733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return -(V >> 1); 14743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // There is no such thing as -0 with integers. "-0" really means MININT. 14753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return 1ULL << 63; 14763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 14773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1478a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines// FIXME: Delete this in LLVM 4.0 and just assert that the aliasee is a 1479a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines// GlobalObject. 1480a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hinesstatic GlobalObject & 1481a630078b32eb37a8de91ae09e26babf235d4fc9fStephen HinesgetGlobalObjectInExpr(const DenseMap<GlobalAlias *, Constant *> &Map, 1482a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines Constant &C) { 1483a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines auto *GO = dyn_cast<GlobalObject>(&C); 1484a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines if (GO) 1485a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines return *GO; 1486a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines 1487a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines auto *GA = dyn_cast<GlobalAlias>(&C); 1488a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines if (GA) 1489a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines return getGlobalObjectInExpr(Map, *Map.find(GA)->second); 1490a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines 1491a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines auto &CE = cast<ConstantExpr>(C); 1492a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines assert(CE.getOpcode() == Instruction::BitCast || 1493a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines CE.getOpcode() == Instruction::GetElementPtr || 1494a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines CE.getOpcode() == Instruction::AddrSpaceCast); 1495a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines if (CE.getOpcode() == Instruction::GetElementPtr) 1496a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines assert(cast<GEPOperator>(CE).hasAllZeroIndices()); 1497a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines return getGlobalObjectInExpr(Map, *CE.getOperand(0)); 1498a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines} 1499a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines 15003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ResolveGlobalAndAliasInits - Resolve all of the initializers for global 15013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// values and aliases that we can. 1502d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ResolveGlobalAndAliasInits() { 15033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist; 15043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist; 15053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInitWorklist.swap(GlobalInits); 15073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AliasInitWorklist.swap(AliasInits); 15083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!GlobalInitWorklist.empty()) { 15103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ValID = GlobalInitWorklist.back().second; 15113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ValID >= ValueList.size()) { 15123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Not ready to resolve this yet, it requires something later in the file. 15133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInits.push_back(GlobalInitWorklist.back()); 15143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 1515579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) 15163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInitWorklist.back().first->setInitializer(C); 15173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 1518579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::ExpectedConstant); 15193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInitWorklist.pop_back(); 15213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1523a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines // FIXME: Delete this in LLVM 4.0 1524a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines // Older versions of llvm could write an alias pointing to another. We cannot 1525a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines // construct those aliases, so we first collect an alias to aliasee expression 1526a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines // and then compute the actual aliasee. 1527a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines DenseMap<GlobalAlias *, Constant *> AliasInit; 1528a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines 15293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!AliasInitWorklist.empty()) { 15303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ValID = AliasInitWorklist.back().second; 15313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ValID >= ValueList.size()) { 15323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AliasInits.push_back(AliasInitWorklist.back()); 15333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 1534579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) 1535a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines AliasInit.insert(std::make_pair(AliasInitWorklist.back().first, C)); 15363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 1537579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::ExpectedConstant); 15383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AliasInitWorklist.pop_back(); 15403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1541a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines 1542a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines for (auto &Pair : AliasInit) { 1543a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines auto &GO = getGlobalObjectInExpr(AliasInit, *Pair.second); 1544a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines Pair.first->setAliasee(&GO); 1545a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines } 1546a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines 1547d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 15483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 15493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1550d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesstatic APInt ReadWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) { 1551d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SmallVector<uint64_t, 8> Words(Vals.size()); 1552d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::transform(Vals.begin(), Vals.end(), Words.begin(), 1553d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitcodeReader::decodeSignRotatedValue); 1554d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1555d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return APInt(TypeBits, Words); 1556d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 1557d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1558d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseConstants() { 15593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) 1560579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 15613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 15633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this value table. 15653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *CurTy = Type::getInt32Ty(Context); 15663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NextCstNo = ValueList.size(); 15673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 1568d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 1569d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1570d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 1571d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 1572d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 1573579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 1574d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 1575d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (NextCstNo != ValueList.size()) 1576579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidConstantReference); 1577d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1578d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Once all the constants have been read, go through and resolve forward 1579d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // references. 1580d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ValueList.ResolveConstantForwardRefs(); 1581d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 1582d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 1583d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 15843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 15853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 15883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 1589579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Value *V = nullptr; 1590d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned BitCode = Stream.readRecord(Entry.ID, Record); 15913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (BitCode) { 15923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: unknown constant 15933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_UNDEF: // UNDEF 15943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); 15953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 15963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] 15973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 1598579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 15993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[0] >= TypeList.size()) 1600579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 16013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CurTy = TypeList[Record[0]]; 16023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; // Skip the ValueList manipulation. 16033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_NULL: // NULL 16043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = Constant::getNullValue(CurTy); 16053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_INTEGER: // INTEGER: [intval] 16073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!CurTy->isIntegerTy() || Record.empty()) 1608579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 1609d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0])); 16103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval] 16123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!CurTy->isIntegerTy() || Record.empty()) 1613579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 16143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1615d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt VInt = ReadWideAPInt(Record, 1616d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines cast<IntegerType>(CurTy)->getBitWidth()); 1617d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantInt::get(Context, VInt); 1618d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 16193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] 16223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 1623579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 1624d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (CurTy->isHalfTy()) 1625d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf, 1626d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(16, (uint16_t)Record[0]))); 1627d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else if (CurTy->isFloatTy()) 1628d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEsingle, 1629d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(32, (uint32_t)Record[0]))); 16303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (CurTy->isDoubleTy()) 1631d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEdouble, 1632d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(64, Record[0]))); 16333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (CurTy->isX86_FP80Ty()) { 16343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Bits are not stored the same way as a normal i80 APInt, compensate. 16353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien uint64_t Rearrange[2]; 16363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16); 16373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Rearrange[1] = Record[0] >> 48; 1638d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::x87DoubleExtended, 1639d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(80, Rearrange))); 16403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (CurTy->isFP128Ty()) 1641d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEquad, 1642d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(128, Record))); 16433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (CurTy->isPPC_FP128Ty()) 1644d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::PPCDoubleDouble, 1645d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(128, Record))); 16463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 16473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); 16483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] 16523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 1653579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 16543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 1656b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Constant*, 16> Elts; 16573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (StructType *STy = dyn_cast<StructType>(CurTy)) { 16593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 16603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getConstantFwdRef(Record[i], 16613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien STy->getElementType(i))); 16623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantStruct::get(STy, Elts); 16633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) { 16643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *EltTy = ATy->getElementType(); 16653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 16663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 16673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantArray::get(ATy, Elts); 16683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) { 16693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *EltTy = VTy->getElementType(); 16703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 16713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 16723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantVector::get(Elts); 16733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 16743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); 16753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_STRING: { // STRING: [values] 16793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 1680579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 16813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArrayType *ATy = cast<ArrayType>(CurTy); 16833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *EltTy = ATy->getElementType(); 16843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 16863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Constant*> Elts; 16873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 16883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ConstantInt::get(EltTy, Record[i])); 16893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantArray::get(ATy, Elts); 16903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CSTRING: { // CSTRING: [values] 16933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 1694579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 16953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArrayType *ATy = cast<ArrayType>(CurTy); 16973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *EltTy = ATy->getElementType(); 16983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 17003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Constant*> Elts; 17013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 17023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ConstantInt::get(EltTy, Record[i])); 17033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(Constant::getNullValue(EltTy)); 17043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantArray::get(ATy, Elts); 17053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] 1708d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1709579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 17103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien int Opc = GetDecodedBinaryOpcode(Record[0], CurTy); 17113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc < 0) { 17123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); // Unknown binop. 17133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 17143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy); 17153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy); 17163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Flags = 0; 17173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() >= 4) { 17183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc == Instruction::Add || 17193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Sub || 17203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Mul || 17213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Shl) { 17223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 17233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Flags |= OverflowingBinaryOperator::NoSignedWrap; 17243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 17253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Flags |= OverflowingBinaryOperator::NoUnsignedWrap; 17263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (Opc == Instruction::SDiv || 17273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::UDiv || 17283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::LShr || 17293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::AShr) { 17303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[3] & (1 << bitc::PEO_EXACT)) 17313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Flags |= SDivOperator::IsExact; 17323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::get(Opc, LHS, RHS, Flags); 17353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] 1739d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1740579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 17413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien int Opc = GetDecodedCastOpcode(Record[0]); 17423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc < 0) { 17433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); // Unknown cast. 17443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 17453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[1]); 1746d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!OpTy) 1747579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 17483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); 17493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getCast(Opc, Op, CurTy); 17503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_INBOUNDS_GEP: 17543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands] 1755d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() & 1) 1756579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 17573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Constant*, 16> Elts; 17583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 17593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ElTy = getTypeByID(Record[i]); 1760d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!ElTy) 1761579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 17623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); 17633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end()); 17653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getGetElementPtr(Elts[0], Indices, 17663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BitCode == 17673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bitc::CST_CODE_CE_INBOUNDS_GEP); 17683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_SELECT: // CE_SELECT: [opval#, opval#, opval#] 1771d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1772579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 17733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0], 17743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type::getInt1Ty(Context)), 17753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.getConstantFwdRef(Record[1],CurTy), 17763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.getConstantFwdRef(Record[2],CurTy)); 17773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval] 1779d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1780579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 17813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *OpTy = 17823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1783579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!OpTy) 1784579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 17853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 17863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 17873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getExtractElement(Op0, Op1); 17883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval] 17913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1792579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (Record.size() < 3 || !OpTy) 1793579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 17943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 17953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[1], 17963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpTy->getElementType()); 17973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 17983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getInsertElement(Op0, Op1, Op2); 17993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 18003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] 18023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1803579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (Record.size() < 3 || !OpTy) 1804579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 18053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 18063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); 18073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 18083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpTy->getNumElements()); 18093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy); 18103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 18113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 18123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval] 18143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *RTy = dyn_cast<VectorType>(CurTy); 18153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *OpTy = 18163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1817579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (Record.size() < 4 || !RTy || !OpTy) 1818579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 18193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 18203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 18213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 18223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien RTy->getNumElements()); 18233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy); 18243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 18253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 18263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] 1828d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 4) 1829579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 18303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[0]); 1831579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!OpTy) 1832579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 18333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 18343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 18353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpTy->isFPOrFPVectorTy()) 18373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getFCmp(Record[3], Op0, Op1); 18383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 18393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getICmp(Record[3], Op0, Op1); 18403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 18413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_INLINEASM: { 1843d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 2) 1844579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 18453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string AsmStr, ConstrStr; 18463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool HasSideEffects = Record[0] & 1; 18473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool IsAlignStack = Record[0] >> 1; 18483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned AsmStrSize = Record[1]; 18493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (2+AsmStrSize >= Record.size()) 1850579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 18513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ConstStrSize = Record[2+AsmStrSize]; 18523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (3+AsmStrSize+ConstStrSize > Record.size()) 1853579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 18543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != AsmStrSize; ++i) 18563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AsmStr += (char)Record[2+i]; 18573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != ConstStrSize; ++i) 18583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ConstrStr += (char)Record[3+AsmStrSize+i]; 18593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PointerType *PTy = cast<PointerType>(CurTy); 18603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), 18613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AsmStr, ConstrStr, HasSideEffects, IsAlignStack); 18623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 18633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_BLOCKADDRESS:{ 1865d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1866579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 18673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *FnTy = getTypeByID(Record[0]); 1868579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!FnTy) 1869579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 18703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *Fn = 18713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy)); 1872579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!Fn) 1873579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 1874c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 18753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalVariable *FwdRef = new GlobalVariable(*Fn->getParent(), 18763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type::getInt8Ty(Context), 18773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien false, GlobalValue::InternalLinkage, 18783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 0, ""); 18793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BlockAddrFwdRefs[Fn].push_back(std::make_pair(Record[2], FwdRef)); 18803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = FwdRef; 18813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1882c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 18833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.AssignValue(V, NextCstNo); 18863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ++NextCstNo; 18873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextCstNo != ValueList.size()) 1890579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidConstantReference); 18913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 1893579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::ExpectedConstant); 18943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Once all the constants have been read, go through and resolve forward 18963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // references. 18973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.ResolveConstantForwardRefs(); 1898d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 18993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 19003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// RememberAndSkipFunctionBody - When we see the block for a function body, 19023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// remember where it is and then skip it. This lets us lazily deserialize the 19033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// functions. 1904d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::RememberAndSkipFunctionBody() { 19053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Get the function we are talking about. 19063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (FunctionsWithBodies.empty()) 1907579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InsufficientFunctionProtos); 19083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *Fn = FunctionsWithBodies.back(); 19103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionsWithBodies.pop_back(); 19113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Save the current stream state. 19133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien uint64_t CurBit = Stream.GetCurrentBitNo(); 19143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DeferredFunctionInfo[Fn] = CurBit; 19153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Skip over the function block for now. 19173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 1918579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 1919d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 19203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 19213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1922d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::GlobalCleanup() { 1923d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Patch the initializers for globals and aliases up. 1924d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ResolveGlobalAndAliasInits(); 1925d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!GlobalInits.empty() || !AliasInits.empty()) 1926579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedGlobalInitializerSet); 1927d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1928d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Look for intrinsic functions which need to be upgraded at some point 1929d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); 1930d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines FI != FE; ++FI) { 1931d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Function *NewFn; 1932d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (UpgradeIntrinsicFunction(FI, NewFn)) 1933d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn)); 1934d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 1935d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1936d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Look for global variables which need to be renamed. 1937d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (Module::global_iterator 1938d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines GI = TheModule->global_begin(), GE = TheModule->global_end(); 1939d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines GI != GE; ++GI) 1940d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines UpgradeGlobalVariable(GI); 1941d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Force deallocation of memory for these vectors to favor the client that 1942d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // want lazy deserialization. 1943d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); 1944d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); 1945d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 1946d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 1947d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1948d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseModule(bool Resume) { 1949d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Resume) 1950d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.JumpToBit(NextUnreadBit); 1951d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 1952579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 19533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 19553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::string> SectionTable; 19563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::string> GCTable; 19573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this module. 1959d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 1960d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advance(); 19613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1962d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 1963d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 1964579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 1965d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 1966d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return GlobalCleanup(); 19673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1968d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: 1969d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.ID) { 19703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Skip unknown content. 19713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 1972579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 19733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BLOCKINFO_BLOCK_ID: 19753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockInfoBlock()) 1976579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 19773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::PARAMATTR_BLOCK_ID: 1979d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseAttributeBlock()) 1980d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 19813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_BLOCK_ID_NEW: 1983d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseTypeTable()) 1984d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 19853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1986c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien case TYPE_BLOCK_ID_OLD_3_0: 1987d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseOldTypeTable()) 1988d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 19893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1990c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien case TYPE_SYMTAB_BLOCK_ID_OLD_3_0: 1991d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseOldTypeSymbolTable()) 1992d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 19933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::VALUE_SYMTAB_BLOCK_ID: 1995d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseValueSymbolTable()) 1996d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1997d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SeenValueSymbolTable = true; 19983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CONSTANTS_BLOCK_ID: 2000d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseConstants()) 2001d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2002d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ResolveGlobalAndAliasInits()) 2003d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 20043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_BLOCK_ID: 2006d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseMetadata()) 2007d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 20083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNCTION_BLOCK_ID: 20103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If this is the first function body we've seen, reverse the 20113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FunctionsWithBodies list. 2012d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!SeenFirstFunctionBody) { 20133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end()); 2014d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = GlobalCleanup()) 2015d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2016d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SeenFirstFunctionBody = true; 20173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2019d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = RememberAndSkipFunctionBody()) 2020d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2021d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // For streaming bitcode, suspend parsing when we reach the function 2022d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // bodies. Subsequent materialization calls will resume it when 2023d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // necessary. For streaming, the function bodies must be at the end of 2024d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // the bitcode. If the bitcode file is old, the symbol table will be 2025d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // at the end instead and will not have been seen yet. In this case, 2026d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // just finish the parse now. 2027d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (LazyStreamer && SeenValueSymbolTable) { 2028d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines NextUnreadBit = Stream.GetCurrentBitNo(); 2029d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 2030d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 2031d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 20323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 20353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2036d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2037d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 2038d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 20393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2041d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 20423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 2043d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 20443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: break; // Default behavior, ignore unknown content. 2045b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines case bitc::MODULE_CODE_VERSION: { // VERSION: [version#] 20463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 2047579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 20483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Only version #0 is supported so far. 20493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[0] != 0) 2050579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidValue); 20513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 2052b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines } 20533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 20543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2056579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 20573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TheModule->setTargetTriple(S); 20583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] 20613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2063579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 20643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TheModule->setDataLayout(S); 20653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] 20683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2070579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 20713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TheModule->setModuleInlineAsm(S); 20723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N] 20753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2077579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 2078b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // ANDROID: Ignore value, since we never used it anyways. 2079b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // TheModule->addLibrary(S); 20803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] 20833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2085579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 20863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SectionTable.push_back(S); 20873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N] 20903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2092579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 20933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GCTable.push_back(S); 20943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // GLOBALVAR: [pointer type, isconst, initid, 20973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // linkage, alignment, section, visibility, threadlocal, 20983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // unnamed_addr] 20993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_GLOBALVAR: { 21003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 6) 2101579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 21023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[0]); 2103d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 2104579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 21053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Ty->isPointerTy()) 2106579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTypeForValue); 21073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); 21083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ty = cast<PointerType>(Ty)->getElementType(); 21093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool isConstant = Record[1]; 21113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]); 21123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Alignment = (1 << Record[4]) >> 1; 21133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string Section; 21143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[5]) { 21153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[5]-1 >= SectionTable.size()) 2116579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidID); 21173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Section = SectionTable[Record[5]-1]; 21183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; 21203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 6) 21213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Visibility = GetDecodedVisibility(Record[6]); 21228b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao 21238b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal; 21243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 7) 21258b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao TLM = GetDecodedThreadLocalMode(Record[7]); 21263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool UnnamedAddr = false; 21283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 8) 21293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UnnamedAddr = Record[8]; 21303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalVariable *NewGV = 21323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien new GlobalVariable(*TheModule, Ty, isConstant, Linkage, 0, "", 0, 21338b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao TLM, AddressSpace); 21343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGV->setAlignment(Alignment); 21353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Section.empty()) 21363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGV->setSection(Section); 21373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGV->setVisibility(Visibility); 21383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGV->setUnnamedAddr(UnnamedAddr); 21393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.push_back(NewGV); 21413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Remember which value to use for the global initializer. 21433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (unsigned InitID = Record[2]) 21443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInits.push_back(std::make_pair(NewGV, InitID-1)); 21453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 21463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [type, callingconv, isproto, linkage, paramattr, 21483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // alignment, section, visibility, gc, unnamed_addr] 21493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_FUNCTION: { 21503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 8) 2151579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 21523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[0]); 2153d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 2154579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 21553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Ty->isPointerTy()) 2156579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTypeForValue); 21573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionType *FTy = 21583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType()); 21593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!FTy) 2160579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTypeForValue); 21613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, 21633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien "", TheModule); 21643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setCallingConv(static_cast<CallingConv::ID>(Record[1])); 21663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool isProto = Record[2]; 21673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setLinkage(GetDecodedLinkage(Record[3])); 21683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setAttributes(getAttributes(Record[4])); 21693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setAlignment((1 << Record[5]) >> 1); 21713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[6]) { 21723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[6]-1 >= SectionTable.size()) 2173579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidID); 21743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setSection(SectionTable[Record[6]-1]); 21753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setVisibility(GetDecodedVisibility(Record[7])); 21773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 8 && Record[8]) { 21783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[8]-1 > GCTable.size()) 2179579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidID); 21803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setGC(GCTable[Record[8]-1].c_str()); 21813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool UnnamedAddr = false; 21833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 9) 21843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UnnamedAddr = Record[9]; 21853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setUnnamedAddr(UnnamedAddr); 21863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.push_back(Func); 21873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If this is a function with a body, remember the prototype we are 21893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // creating now, so that we can match up the body with them later. 2190d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isProto) { 21913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionsWithBodies.push_back(Func); 2192d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (LazyStreamer) DeferredFunctionInfo[Func] = 0; 2193d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 21943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 21953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // ALIAS: [alias type, aliasee val#, linkage] 21973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // ALIAS: [alias type, aliasee val#, linkage, visibility] 21983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_ALIAS: { 21993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 2200579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 22013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[0]); 2202d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 2203579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 2204a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines auto *PTy = dyn_cast<PointerType>(Ty); 2205a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines if (!PTy) 2206579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTypeForValue); 22073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2208a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines GlobalAlias *NewGA = 2209a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(), 2210a630078b32eb37a8de91ae09e26babf235d4fc9fStephen Hines GetDecodedLinkage(Record[2]), "", 0, TheModule); 22113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Old bitcode files didn't have visibility field. 22123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 3) 22133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGA->setVisibility(GetDecodedVisibility(Record[3])); 22143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.push_back(NewGA); 22153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AliasInits.push_back(std::make_pair(NewGA, Record[1])); 22163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 22173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// MODULE_CODE_PURGEVALS: [numvals] 22193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_PURGEVALS: 22203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Trim down the value list to the specified size. 22213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1 || Record[0] > ValueList.size()) 2222579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 22233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.shrinkTo(Record[0]); 22243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 22253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 22273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 22293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2230d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseBitcodeInto(Module *M) { 2231579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines TheModule = nullptr; 22323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2233d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = InitStream()) 2234d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 22353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Sniff for the signature. 22373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.Read(8) != 'B' || 22383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(8) != 'C' || 22393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0x0 || 22403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xC || 22413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xE || 22423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xD) 2243579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidBitcodeSignature); 22443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // We expect a number of well-defined blocks, though we don't necessarily 22463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // need to understand them all. 2247d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2248d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.AtEndOfStream()) 2249d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 2250d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2251d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = 2252d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs); 2253d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2254d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2255d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2256579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 2257d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2258d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 22593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2260d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: 2261d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.ID) { 2262d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::BLOCKINFO_BLOCK_ID: 2263d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.ReadBlockInfoBlock()) 2264579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 2265d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 2266d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::MODULE_BLOCK_ID: 2267d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Reject multiple MODULE_BLOCK's in a single bitstream. 2268d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (TheModule) 2269579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidMultipleBlocks); 2270d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines TheModule = M; 2271d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseModule(false)) 2272d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2273d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (LazyStreamer) 2274d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 2275d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 2276d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines default: 2277d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.SkipBlock()) 2278579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 2279d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 2280d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 2281d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 2282d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2283d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // There should be no records in the top-level of blocks. 22843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2285d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The ranlib in Xcode 4 will align archive members by appending newlines 22863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // to the end of them. If this file size is a multiple of 4 but not 8, we 22873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // have to read and ignore these final 4 bytes :-( 2288d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.getAbbrevIDWidth() == 2 && Entry.ID == 2 && 22893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a && 2290b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines Stream.AtEndOfStream()) 2291d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 22923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2293579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 22943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 22973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2298579361346abc6696c805e3904a18178ebce4e4a3Stephen Hinesllvm::ErrorOr<std::string> BitcodeReader::parseModuleTriple() { 22993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 2300579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 23013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 23033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2304579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines std::string Triple; 23053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this module. 2306d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2307d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 23083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2309d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2310d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 2311d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2312579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 2313d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2314579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Triple; 2315d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2316d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 2317d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 23183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 2321d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 23223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: break; // Default behavior, ignore unknown content. 23233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 23243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 23253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2326579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 23273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Triple = S; 23283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 23293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 23323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 23343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2335579361346abc6696c805e3904a18178ebce4e4a3Stephen Hinesllvm::ErrorOr<std::string> BitcodeReader::parseTriple() { 2336d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = InitStream()) 2337d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 23383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Sniff for the signature. 23403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.Read(8) != 'B' || 23413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(8) != 'C' || 23423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0x0 || 23433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xC || 23443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xE || 23453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xD) 2346579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidBitcodeSignature); 23473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // We expect a number of well-defined blocks, though we don't necessarily 23493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // need to understand them all. 2350d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2351d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advance(); 23523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2353d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2354d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2355579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 2356d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2357d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 23583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2359d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: 2360d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Entry.ID == bitc::MODULE_BLOCK_ID) 2361579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return parseModuleTriple(); 23623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2363d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Ignore other sub-blocks. 2364d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Stream.SkipBlock()) 2365579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 2366d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 2367d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2368d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2369d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.skipRecord(Entry.ID); 2370d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 23713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 23743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ParseMetadataAttachment - Parse metadata attachments. 2376d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseMetadataAttachment() { 23773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) 2378579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 23793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 2381d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2382d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 2383d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2384d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2385d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 2386d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2387579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 2388d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2389d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 2390d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2391d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 23923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 23933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 2394d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 23953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a metadata attachment record. 23963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 2397d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 23983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: ignore. 23993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_ATTACHMENT: { 24013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned RecordLength = Record.size(); 24023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty() || (RecordLength - 1) % 2 == 1) 2403579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 24043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Instruction *Inst = InstructionList[Record[0]]; 24053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1; i != RecordLength; i = i+2) { 24063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Kind = Record[i]; 24073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DenseMap<unsigned, unsigned>::iterator I = 24083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDKindMap.find(Kind); 24093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I == MDKindMap.end()) 2410579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidID); 24113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Node = MDValueList.getValueFwdRef(Record[i+1]); 24123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Inst->setMetadata(I->second, cast<MDNode>(Node)); 24133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 24193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ParseFunctionBody - Lazily parse the specified function body block. 2421d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::ParseFunctionBody(Function *F) { 24223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) 2423579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 24243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.clear(); 24263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ModuleValueListSize = ValueList.size(); 24273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ModuleMDValueListSize = MDValueList.size(); 24283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Add all the function arguments to the value table. 24303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) 24313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.push_back(I); 24323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NextValueNo = ValueList.size(); 2434579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines BasicBlock *CurBB = nullptr; 24353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned CurBBNo = 0; 24363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DebugLoc LastLoc; 2438c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 24393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records. 24403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 24413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 24423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 24433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 24443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 2445579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::MalformedBlock); 24463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 24503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Stream.ReadSubBlockID()) { 24513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Skip unknown content. 24523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 2453579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 24543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CONSTANTS_BLOCK_ID: 2456d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseConstants()) 2457d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 24583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NextValueNo = ValueList.size(); 24593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::VALUE_SYMTAB_BLOCK_ID: 2461d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseValueSymbolTable()) 2462d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 24633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_ATTACHMENT_ID: 2465d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseMetadataAttachment()) 2466d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 24673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_BLOCK_ID: 2469d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseMetadata()) 2470d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 24713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 24743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 24773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 24783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 24793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 24823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 2483579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Instruction *I = nullptr; 2484d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned BitCode = Stream.readRecord(Code, Record); 24853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (BitCode) { 24863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: reject 2487579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidValue); 24883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks] 24893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1 || Record[0] == 0) 2490579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 24913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Create all the basic blocks for the function. 24923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionBBs.resize(Record[0]); 24933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) 24943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionBBs[i] = BasicBlock::Create(Context, "", F); 24953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CurBB = FunctionBBs[0]; 24963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 2497c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 24983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN 24993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // This record indicates that the last instruction is at the same 25003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // location as the previous instruction with a location. 2501579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines I = nullptr; 2502c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 25033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Get the last instruction emitted. 25043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CurBB && !CurBB->empty()) 25053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = &CurBB->back(); 25063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (CurBBNo && FunctionBBs[CurBBNo-1] && 25073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien !FunctionBBs[CurBBNo-1]->empty()) 25083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = &FunctionBBs[CurBBNo-1]->back(); 2509c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 2510579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!I) 2511579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 25123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I->setDebugLoc(LastLoc); 2513579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines I = nullptr; 25143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 2515c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 25163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia] 2517579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines I = nullptr; // Get the last instruction emitted. 25183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CurBB && !CurBB->empty()) 25193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = &CurBB->back(); 25203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (CurBBNo && FunctionBBs[CurBBNo-1] && 25213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien !FunctionBBs[CurBBNo-1]->empty()) 25223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = &FunctionBBs[CurBBNo-1]->back(); 2523579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!I || Record.size() < 4) 2524579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 2525c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 25263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Line = Record[0], Col = Record[1]; 25273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ScopeID = Record[2], IAID = Record[3]; 2528c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 2529579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines MDNode *Scope = nullptr, *IA = nullptr; 25303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ScopeID) Scope = cast<MDNode>(MDValueList.getValueFwdRef(ScopeID-1)); 25313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (IAID) IA = cast<MDNode>(MDValueList.getValueFwdRef(IAID-1)); 25323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LastLoc = DebugLoc::get(Line, Col, Scope, IA); 25333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I->setDebugLoc(LastLoc); 2534579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines I = nullptr; 25353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 25363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode] 25393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 25403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *LHS, *RHS; 25413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 25423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, LHS->getType(), RHS) || 25433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+1 > Record.size()) 2544579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 25453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); 2547d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Opc == -1) 2548579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 25493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); 25503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 25513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpNum < Record.size()) { 25523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc == Instruction::Add || 25533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Sub || 25543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Mul || 25553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Shl) { 25563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 25573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<BinaryOperator>(I)->setHasNoSignedWrap(true); 25583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 25593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true); 25603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (Opc == Instruction::SDiv || 25613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::UDiv || 25623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::LShr || 25633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::AShr) { 25643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[OpNum] & (1 << bitc::PEO_EXACT)) 25653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<BinaryOperator>(I)->setIsExact(true); 25663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 25693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc] 25713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 25723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 25733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 25743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+2 != Record.size()) 2575579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 25763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ResTy = getTypeByID(Record[OpNum]); 25783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien int Opc = GetDecodedCastOpcode(Record[OpNum+1]); 2579579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (Opc == -1 || !ResTy) 2580579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 25813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy); 25823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 25833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 25843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INBOUNDS_GEP: 25863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands] 25873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 25883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *BasePtr; 25893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) 2590579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 25913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Value*, 16> GEPIdx; 25933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (OpNum != Record.size()) { 25943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 25953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2596579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 25973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GEPIdx.push_back(Op); 25983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = GetElementPtrInst::Create(BasePtr, GEPIdx); 26013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP) 26033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<GetElementPtrInst>(I)->setIsInBounds(true); 26043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_EXTRACTVAL: { 26083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // EXTRACTVAL: [opty, opval, n x indices] 26093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Agg; 26113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2612579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 26133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<unsigned, 4> EXTRACTVALIdx; 26153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned RecSize = Record.size(); 26163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum != RecSize; ++OpNum) { 26173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien uint64_t Index = Record[OpNum]; 26183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((unsigned)Index != Index) 2619579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidValue); 26203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien EXTRACTVALIdx.push_back((unsigned)Index); 26213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ExtractValueInst::Create(Agg, EXTRACTVALIdx); 26243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INSERTVAL: { 26293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // INSERTVAL: [opty, opval, opty, opval, n x indices] 26303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Agg; 26323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2633579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 26343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Val; 26353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Val)) 2636579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 26373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<unsigned, 4> INSERTVALIdx; 26393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned RecSize = Record.size(); 26403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum != RecSize; ++OpNum) { 26413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien uint64_t Index = Record[OpNum]; 26423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((unsigned)Index != Index) 2643579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidValue); 26443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien INSERTVALIdx.push_back((unsigned)Index); 26453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = InsertValueInst::Create(Agg, Val, INSERTVALIdx); 26483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval] 26533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // obsolete form of select 26543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // handles select i1 ... in old bitcode 26553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *TrueVal, *FalseVal, *Cond; 26573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 26583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 26593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, Type::getInt1Ty(Context), Cond)) 2660579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 26613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = SelectInst::Create(Cond, TrueVal, FalseVal); 26633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred] 26683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // new form of select 26693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // handles select i1 or select [N x i1] 26703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *TrueVal, *FalseVal, *Cond; 26723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 26733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 26743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValueTypePair(Record, OpNum, NextValueNo, Cond)) 2675579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 26763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // select condition can be either i1 or [N x i1] 26783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (VectorType* vector_type = 26793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast<VectorType>(Cond->getType())) { 26803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // expect <n x i1> 26813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (vector_type->getElementType() != Type::getInt1Ty(Context)) 2682579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTypeForValue); 26833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 26843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // expect i1 26853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Cond->getType() != Type::getInt1Ty(Context)) 2686579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidTypeForValue); 26873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = SelectInst::Create(Cond, TrueVal, FalseVal); 26903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval] 26953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Vec, *Idx; 26973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 26983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 2699579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 27003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ExtractElementInst::Create(Vec, Idx); 27013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval] 27063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 27073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Vec, *Elt, *Idx; 27083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 27093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 27103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<VectorType>(Vec->getType())->getElementType(), Elt) || 27113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 2712579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 27133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = InsertElementInst::Create(Vec, Elt, Idx); 27143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval] 27193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 27203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Vec1, *Vec2, *Mask; 27213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) || 27223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, Vec1->getType(), Vec2)) 2723579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 27243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) 2726579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 27273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new ShuffleVectorInst(Vec1, Vec2, Mask); 27283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred] 27333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Old form of ICmp/FCmp returning bool 27343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were 27353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // both legal on vectors but had different behaviour. 27363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred] 27373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FCmp/ICmp returning bool or vector of bool 27383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 27403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *LHS, *RHS; 27413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 27423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, LHS->getType(), RHS) || 27433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+1 != Record.size()) 2744579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 27453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (LHS->getType()->isFPOrFPVectorTy()) 27473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); 27483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 27493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS); 27503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>] 27553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien { 27563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 27573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Size == 0) { 27583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ReturnInst::Create(Context); 27593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 2764900c6c1f08f7c572125d7d39abe0f0f9eafbfa14Chris Wailes Value *Op = nullptr; 27653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2766579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 27673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpNum != Record.size()) 2768579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 27693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ReturnInst::Create(Context, Op); 27713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] 27753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() != 1 && Record.size() != 3) 2776579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 27773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *TrueDest = getBasicBlock(Record[0]); 2778579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!TrueDest) 2779579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 27803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() == 1) { 27823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = BranchInst::Create(TrueDest); 27833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else { 27863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *FalseDest = getBasicBlock(Record[1]); 27873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Cond = getFnValueByID(Record[2], Type::getInt1Ty(Context)); 2788579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!FalseDest || !Cond) 2789579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 27903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = BranchInst::Create(TrueDest, FalseDest, Cond); 27913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...] 27963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3 || (Record.size() & 1) == 0) 2797579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 27983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[0]); 27993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Cond = getFnValueByID(Record[1], OpTy); 28003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *Default = getBasicBlock(Record[2]); 2801579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!OpTy || !Cond || !Default) 2802579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 28033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumCases = (Record.size()-3)/2; 28043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); 28053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(SI); 28063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = NumCases; i != e; ++i) { 28073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ConstantInt *CaseVal = 28083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy)); 28093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); 2810579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!CaseVal || !DestBB) { 28113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete SI; 2812579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 28133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SI->addCase(CaseVal, DestBB); 28153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = SI; 28173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 28183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] 28203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 2821579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 28223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[0]); 28233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Address = getFnValueByID(Record[1], OpTy); 2824579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!OpTy || !Address) 2825579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 28263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumDests = Record.size()-2; 28273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); 28283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(IBI); 28293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = NumDests; i != e; ++i) { 28303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) { 28313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien IBI->addDestination(DestBB); 28323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 28333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete IBI; 2834579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 28353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = IBI; 28383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 28393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 2840c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 28413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INVOKE: { 28423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] 2843d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 4) 2844579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 2845b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines AttributeSet PAL = getAttributes(Record[0]); 28463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned CCInfo = Record[1]; 28473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *NormalBB = getBasicBlock(Record[2]); 28483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *UnwindBB = getBasicBlock(Record[3]); 28493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 4; 28513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Callee; 28523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 2853579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 28543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); 2856579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines FunctionType *FTy = !CalleeTy ? nullptr : 28573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast<FunctionType>(CalleeTy->getElementType()); 28583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check that the right number of fixed parameters are here. 2860579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!FTy || !NormalBB || !UnwindBB || 28613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.size() < OpNum+FTy->getNumParams()) 2862579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 28633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Value*, 16> Ops; 28653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 28663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ops.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 2867579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!Ops.back()) 2868579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 28693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!FTy->isVarArg()) { 28723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() != OpNum) 2873579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 28743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 28753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read type/value pairs for varargs params. 28763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (OpNum != Record.size()) { 28773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 28783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2879579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 28803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ops.push_back(Op); 28813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops); 28853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 28863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<InvokeInst>(I)->setCallingConv( 28873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien static_cast<CallingConv::ID>(CCInfo)); 28883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<InvokeInst>(I)->setAttributes(PAL); 28893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 28903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_RESUME: { // RESUME: [opval] 28923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Idx = 0; 2893579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Value *Val = nullptr; 28943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, Idx, NextValueNo, Val)) 2895579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 28963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ResumeInst::Create(Val); 28973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 28983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 28993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 2900c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao case FUNC_CODE_INST_UNWIND_2_7: { // UNWIND_OLD 2901c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao // 'unwind' instruction has been removed in LLVM 3.1 2902c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao // Replace 'unwind' with 'landingpad' and 'resume'. 2903c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Type *ExnTy = StructType::get(Type::getInt8PtrTy(Context), 2904900c6c1f08f7c572125d7d39abe0f0f9eafbfa14Chris Wailes Type::getInt32Ty(Context), nullptr); 2905c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Constant *PersFn = 2906c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao F->getParent()-> 2907c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao getOrInsertFunction("__gcc_personality_v0", 2908c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao FunctionType::get(Type::getInt32Ty(Context), true)); 2909c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 2910c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao LandingPadInst *LP = LandingPadInst::Create(ExnTy, PersFn, 1); 2911c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao LP->setCleanup(true); 2912c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 2913c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao CurBB->getInstList().push_back(LP); 2914c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao I = ResumeInst::Create(LP); 29153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 29163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 2917c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao } 29183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE 29193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new UnreachableInst(Context); 29203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 29213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 29223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...] 29233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1 || ((Record.size()-1)&1)) 2924579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 29253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[0]); 2926d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 2927579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 29283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2); 29303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(PN); 29313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) { 29333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = getFnValueByID(Record[1+i], Ty); 29343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *BB = getBasicBlock(Record[2+i]); 2935d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!V || !BB) 2936579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 29373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PN->addIncoming(V, BB); 29383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = PN; 29403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 29413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_LANDINGPAD: { 29443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?] 29453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Idx = 0; 29463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 4) 2947579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 29483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[Idx++]); 2949d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 2950579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 2951579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Value *PersFn = nullptr; 29523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, Idx, NextValueNo, PersFn)) 2953579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 29543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool IsCleanup = !!Record[Idx++]; 29563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumClauses = Record[Idx++]; 29573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LandingPadInst *LP = LandingPadInst::Create(Ty, PersFn, NumClauses); 29583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LP->setCleanup(IsCleanup); 29593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned J = 0; J != NumClauses; ++J) { 29603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LandingPadInst::ClauseType CT = 29613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LandingPadInst::ClauseType(Record[Idx++]); (void)CT; 29623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Val; 29633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, Idx, NextValueNo, Val)) { 29653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete LP; 2966579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 29673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert((CT != LandingPadInst::Catch || 29703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien !isa<ArrayType>(Val->getType())) && 29713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien "Catch clause has a invalid type!"); 29723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert((CT != LandingPadInst::Filter || 29733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien isa<ArrayType>(Val->getType())) && 29743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien "Filter clause has invalid type!"); 2975d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines LP->addClause(cast<Constant>(Val)); 29763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = LP; 29793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 29803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 29813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align] 29843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() != 4) 2985579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 29863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PointerType *Ty = 29873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<PointerType>(getTypeByID(Record[0])); 29883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[1]); 29893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Size = getFnValueByID(Record[2], OpTy); 29903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Align = Record[3]; 2991d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty || !Size) 2992579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 29933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); 29943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 29953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 29963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol] 29983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 29993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 30003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 30013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+2 != Record.size()) 3002579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 30033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 30043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); 30053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_LOADATOMIC: { 30093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // LOADATOMIC: [opty, op, align, vol, ordering, synchscope] 30103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 30113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 30123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 30133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+4 != Record.size()) 3014579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 3015c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 30163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 30173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); 30183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Release || 30193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering == AcquireRelease) 3020579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 30213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering != NotAtomic && Record[OpNum] == 0) 3022579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 30233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); 30243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 30253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1, 30263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering, SynchScope); 30273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_STORE: { // STORE2:[ptrty, ptr, val, align, vol] 30313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 30323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Val, *Ptr; 30333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 30343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), Val) || 30363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+2 != Record.size()) 3037579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 30383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 30393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 30403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_STOREATOMIC: { 30443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // STOREATOMIC: [ptrty, ptr, val, align, vol, ordering, synchscope] 30453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 30463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Val, *Ptr; 30473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 30483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), Val) || 30503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+4 != Record.size()) 3051579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 30523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 30533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); 30543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Acquire || 30553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering == AcquireRelease) 3056579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 30573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); 30583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering != NotAtomic && Record[OpNum] == 0) 3059579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 30603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 30613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1, 30623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering, SynchScope); 30633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CMPXCHG: { 30673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // CMPXCHG:[ptrty, ptr, cmp, new, vol, ordering, synchscope] 30683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 30693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Ptr, *Cmp, *New; 30703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 30713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), Cmp) || 30733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), New) || 30753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+3 != Record.size()) 3076579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 30773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+1]); 30783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Unordered) 3079579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 30803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+2]); 3081c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray I = new AtomicCmpXchgInst(Ptr, Cmp, New, Ordering, Ordering, SynchScope); 30823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]); 30833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_ATOMICRMW: { 30873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // ATOMICRMW:[ptrty, ptr, val, op, vol, ordering, synchscope] 30883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 30893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Ptr, *Val; 30903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 30913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), Val) || 30933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+4 != Record.size()) 3094579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 30953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicRMWInst::BinOp Operation = GetDecodedRMWOperation(Record[OpNum]); 30963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Operation < AtomicRMWInst::FIRST_BINOP || 30973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Operation > AtomicRMWInst::LAST_BINOP) 3098579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 30993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); 31003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Unordered) 3101579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 31023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); 31033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SynchScope); 31043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]); 31053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 31063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 31073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, synchscope] 31093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (2 != Record.size()) 3110579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 31113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[0]); 31123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Unordered || 31133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering == Monotonic) 3114579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 31153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[1]); 31163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new FenceInst(Context, Ordering, SynchScope); 31173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 31183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 31193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CALL: { 31213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] 31223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 3123579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 31243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3125b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines AttributeSet PAL = getAttributes(Record[0]); 31263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned CCInfo = Record[1]; 31273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 2; 31293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Callee; 31303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 3131579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 31323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); 3134579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines FunctionType *FTy = nullptr; 31353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType()); 31363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!FTy || Record.size() < FTy->getNumParams()+OpNum) 3137579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 31383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Value*, 16> Args; 31403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read the fixed params. 31413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 31423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (FTy->getParamType(i)->isLabelTy()) 31433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Args.push_back(getBasicBlock(Record[OpNum])); 31443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 31453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Args.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 3146579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!Args.back()) 3147579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 31483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read type/value pairs for varargs params. 31513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!FTy->isVarArg()) { 31523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpNum != Record.size()) 3153579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 31543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 31553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (OpNum != Record.size()) { 31563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 31573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 3158579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 31593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Args.push_back(Op); 31603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = CallInst::Create(Callee, Args); 31643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 31653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<CallInst>(I)->setCallingConv( 31663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien static_cast<CallingConv::ID>(CCInfo>>1)); 31673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<CallInst>(I)->setTailCall(CCInfo & 1); 31683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<CallInst>(I)->setAttributes(PAL); 31693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 31703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] 31723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 3173579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 31743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[0]); 31753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op = getFnValueByID(Record[1], OpTy); 31763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ResTy = getTypeByID(Record[2]); 31773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!OpTy || !Op || !ResTy) 3178579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidRecord); 31793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new VAArgInst(Op, ResTy); 31803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 31813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 31823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Add instruction to end of current BB. If there is no current BB, reject 31863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // this file. 3187579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!CurBB) { 31883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete I; 3189579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidInstructionWithNoBB); 31903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CurBB->getInstList().push_back(I); 31923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If this was a terminator instruction, move to the next block. 31943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (isa<TerminatorInst>(I)) { 31953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ++CurBBNo; 31963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0; 31973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Non-void values get registered in the value table for future use. 32003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I && !I->getType()->isVoidTy()) 32013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.AssignValue(I, NextValueNo++); 32023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check the function list for unresolved values. 32053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Argument *A = dyn_cast<Argument>(ValueList.back())) { 3206579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!A->getParent()) { 32073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // We found at least one unresolved value. Nuke them all to avoid leaks. 32083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){ 3209579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if ((A = dyn_cast_or_null<Argument>(ValueList[i])) && !A->getParent()) { 32103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien A->replaceAllUsesWith(UndefValue::get(A->getType())); 32113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete A; 32123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 3214579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::NeverResolvedValueFoundInFunction); 32153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FIXME: Check for unresolved forward-declared metadata references 32193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // and clean up leaks. 32203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // See if anything took the address of blocks in this function. If so, 32223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // resolve them now. 32233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DenseMap<Function*, std::vector<BlockAddrRefTy> >::iterator BAFRI = 32243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BlockAddrFwdRefs.find(F); 32253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BAFRI != BlockAddrFwdRefs.end()) { 32263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<BlockAddrRefTy> &RefList = BAFRI->second; 32273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = RefList.size(); i != e; ++i) { 32283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned BlockIdx = RefList[i].first; 32293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BlockIdx >= FunctionBBs.size()) 3230579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidID); 3231c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 32323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalVariable *FwdRef = RefList[i].second; 32333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx])); 32343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FwdRef->eraseFromParent(); 32353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 3236c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 32373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BlockAddrFwdRefs.erase(BAFRI); 32383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 3239c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 32403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Trim the value list down to the size it was before we parsed this function. 32413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.shrinkTo(ModuleValueListSize); 32423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValueList.shrinkTo(ModuleMDValueListSize); 32433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<BasicBlock*>().swap(FunctionBBs); 3244d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 32453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 32463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 32483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// GVMaterializer implementation 32493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 32503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::isMaterializable(const GlobalValue *GV) const { 32533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (const Function *F = dyn_cast<Function>(GV)) { 32543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return F->isDeclaration() && 32553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DeferredFunctionInfo.count(const_cast<Function*>(F)); 32563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 32583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 32593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3260579361346abc6696c805e3904a18178ebce4e4a3Stephen Hinesstd::error_code BitcodeReader::materialize(GlobalValue *GV) { 32613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *F = dyn_cast<Function>(GV); 32623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If it's not a function or is already material, ignore the request. 3263d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!F || !F->isMaterializable()) 3264d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 32653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F); 32673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!"); 32683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Move the bit stream to the saved position of the deferred function body. 32703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.JumpToBit(DFII->second); 32713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3272d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines if (std::error_code EC = ParseFunctionBody(F)) 3273d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 32743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Upgrade any old intrinsic calls in the function. 32763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(), 32773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien E = UpgradedIntrinsics.end(); I != E; ++I) { 32783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I->first != I->second) { 32793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (Value::use_iterator UI = I->first->use_begin(), 32803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UE = I->first->use_end(); UI != UE; ) { 32813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 32823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UpgradeIntrinsicCall(CI, I->second); 32833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3287d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 32883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 32893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::isDematerializable(const GlobalValue *GV) const { 32913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien const Function *F = dyn_cast<Function>(GV); 32923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!F || F->isDeclaration()) 32933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 32943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return DeferredFunctionInfo.count(const_cast<Function*>(F)); 32953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 32963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReader::Dematerialize(GlobalValue *GV) { 32983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *F = dyn_cast<Function>(GV); 32993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If this function isn't dematerializable, this is a noop. 33003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!F || !isDematerializable(F)) 33013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 33023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(DeferredFunctionInfo.count(F) && "No info to read function later?"); 33043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Just forget the function body, we can remat it later. 33063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien F->deleteBody(); 33073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 33083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3310d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::MaterializeModule(Module *M) { 33113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(M == TheModule && 33123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien "Can only Materialize the Module this BitcodeReader is attached to."); 33133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Iterate over the module, deserializing any functions that are still on 33143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // disk. 33153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (Module::iterator F = TheModule->begin(), E = TheModule->end(); 3316d724d097437f40a5689464429f948ec41e4a2415Stephen Hines F != E; ++F) { 3317d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (F->isMaterializable()) { 3318579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (std::error_code EC = materialize(F)) 3319d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 3320d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3321d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 33223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Upgrade any intrinsic calls that slipped through (should not happen!) and 33243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // delete the old functions to clean up. We can't do this unless the entire 33253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // module is materialized because there could always be another function body 33263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // with calls to the old function. 33273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (std::vector<std::pair<Function*, Function*> >::iterator I = 33283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) { 33293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I->first != I->second) { 33303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (Value::use_iterator UI = I->first->use_begin(), 33313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UE = I->first->use_end(); UI != UE; ) { 33323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 33333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UpgradeIntrinsicCall(CI, I->second); 33343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 33353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!I->first->use_empty()) 33363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I->first->replaceAllUsesWith(I->second); 33373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I->first->eraseFromParent(); 33383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 33393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 33403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics); 33413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Upgrade to new EH scheme. N.B. This will go away in 3.1. 33433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UpgradeExceptionHandling(M); 33443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check debug info intrinsics. 33463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CheckDebugInfoIntrinsics(TheModule); 33473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3348d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 33493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 33503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3351d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::InitStream() { 3352d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (LazyStreamer) 3353d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return InitLazyStream(); 3354d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return InitStreamFromBuffer(); 3355d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 3356d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3357d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::InitStreamFromBuffer() { 3358d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *BufPtr = (const unsigned char*)Buffer->getBufferStart(); 3359d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); 3360d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3361579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (Buffer->getBufferSize() & 3) 3362579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidBitcodeSignature); 3363d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3364d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // If we have a wrapper header, parse it and ignore the non-bc file contents. 3365d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The magic number is 0x0B17C0DE stored in little endian. 3366d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (isBitcodeWrapper(BufPtr, BufEnd)) 3367d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true)) 3368579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidBitcodeWrapperHeader); 3369d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3370d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamFile.reset(new BitstreamReader(BufPtr, BufEnd)); 3371579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Stream.init(&*StreamFile); 3372d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3373d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 3374d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 3375d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3376d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesstd::error_code BitcodeReader::InitLazyStream() { 3377d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Check and strip off the bitcode wrapper; BitstreamReader expects never to 3378d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // see it. 3379d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamingMemoryObject *Bytes = new StreamingMemoryObject(LazyStreamer); 3380d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamFile.reset(new BitstreamReader(Bytes)); 3381579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Stream.init(&*StreamFile); 3382d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3383d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned char buf[16]; 3384579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (Bytes->readBytes(buf, 16, 0) != 16) 3385579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidBitcodeSignature); 3386d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3387d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isBitcode(buf, buf + 16)) 3388579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Error(BitcodeError::InvalidBitcodeSignature); 3389d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3390d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (isBitcodeWrapper(buf, buf + 4)) { 3391d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *bitcodeStart = buf; 3392d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *bitcodeEnd = buf + 16; 3393d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false); 3394d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Bytes->dropLeadingBytes(bitcodeStart - buf); 3395d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Bytes->setKnownObjectSize(bitcodeEnd - bitcodeStart); 3396d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 3397d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hines return std::error_code(); 3398d724d097437f40a5689464429f948ec41e4a2415Stephen Hines} 3399d724d097437f40a5689464429f948ec41e4a2415Stephen Hines 3400d724d097437f40a5689464429f948ec41e4a2415Stephen Hinesnamespace { 34018f5c2a1c1392a6d6bdb5700f73eeadd7b01ea0b7Stephen Hinesclass BitcodeErrorCategoryType : public std::error_category { 34028f5c2a1c1392a6d6bdb5700f73eeadd7b01ea0b7Stephen Hines const char *name() const LLVM_NOEXCEPT override { 3403d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "llvm.bitcode"; 3404d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3405c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray std::string message(int IE) const override { 3406d724d097437f40a5689464429f948ec41e4a2415Stephen Hines BitcodeReader::ErrorType E = static_cast<BitcodeReader::ErrorType>(IE); 3407d724d097437f40a5689464429f948ec41e4a2415Stephen Hines switch (E) { 3408d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::ConflictingMETADATA_KINDRecords: 3409d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Conflicting METADATA_KIND records"; 3410d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::CouldNotFindFunctionInStream: 3411d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Could not find function in stream"; 3412d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::ExpectedConstant: 3413d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Expected a constant"; 3414d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InsufficientFunctionProtos: 3415d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Insufficient function protos"; 3416d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidBitcodeSignature: 3417d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid bitcode signature"; 3418d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidBitcodeWrapperHeader: 3419d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid bitcode wrapper header"; 3420d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidConstantReference: 3421d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid ronstant reference"; 3422d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidID: 3423d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid ID"; 3424d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidInstructionWithNoBB: 3425d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid instruction with no BB"; 3426d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidRecord: 3427d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid record"; 3428d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidTypeForValue: 3429d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid type for value"; 3430d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidTYPETable: 3431d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid TYPE table"; 3432d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidType: 3433d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid type"; 3434d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::MalformedBlock: 3435d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Malformed block"; 3436d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::MalformedGlobalInitializerSet: 3437d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Malformed global initializer set"; 3438d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidMultipleBlocks: 3439d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid multiple blocks"; 3440d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::NeverResolvedValueFoundInFunction: 3441d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Never resolved value found in function"; 3442d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidValue: 3443d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid value"; 3444d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3445d724d097437f40a5689464429f948ec41e4a2415Stephen Hines llvm_unreachable("Unknown error type!"); 3446d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3447d724d097437f40a5689464429f948ec41e4a2415Stephen Hines}; 3448d724d097437f40a5689464429f948ec41e4a2415Stephen Hines} 3449d724d097437f40a5689464429f948ec41e4a2415Stephen Hines 3450d0993af5b1337f8186dd9aedea2e138a919e02e9Stephen Hinesconst std::error_category &BitcodeReader::BitcodeErrorCategory() { 3451d724d097437f40a5689464429f948ec41e4a2415Stephen Hines static BitcodeErrorCategoryType O; 3452d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return O; 3453d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 34543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 34563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// External interface 34573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 34583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// getLazyBitcodeModule - lazy function-at-a-time loading from a file. 34603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// 3461579361346abc6696c805e3904a18178ebce4e4a3Stephen Hinesllvm::ErrorOr<llvm::Module *> 3462579361346abc6696c805e3904a18178ebce4e4a3Stephen Hinesllvm_3_0::getLazyBitcodeModule(std::unique_ptr<llvm::MemoryBuffer> &&Buffer, 3463579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines llvm::LLVMContext &Context) { 34643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Module *M = new Module(Buffer->getBufferIdentifier(), Context); 3465579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines BitcodeReader *R = new BitcodeReader(Buffer.get(), Context); 34663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien M->setMaterializer(R); 34673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3468579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines auto cleanupOnError = [&](std::error_code EC) { 3469579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines R->releaseBuffer(); // Never take ownership on error. 34703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete M; // Also deletes R. 3471579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return EC; 3472579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines }; 3473579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines 3474579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (std::error_code EC = R->ParseBitcodeInto(M)) 3475579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return cleanupOnError(EC); 3476579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines 3477579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Buffer.release(); // The BitcodeReader owns it now. 34783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return M; 34793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 34803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ParseBitcodeFile - Read the specified bitcode file, returning the module. 34823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// If an error occurs, return null and fill in *ErrMsg if non-null. 3483579361346abc6696c805e3904a18178ebce4e4a3Stephen Hinesllvm::ErrorOr<llvm::Module *> llvm_3_0::parseBitcodeFile(llvm::MemoryBufferRef Buffer, 3484579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines llvm::LLVMContext &Context) { 34853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3487579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines std::unique_ptr<llvm::MemoryBuffer> Buf = llvm::MemoryBuffer::getMemBuffer(Buffer, false); 3488579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines llvm::ErrorOr<llvm::Module *> ModuleOrErr = 3489579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines llvm_3_0::getLazyBitcodeModule(std::move(Buf), Context); 3490579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (!ModuleOrErr) 3491579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return ModuleOrErr; 3492579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines Module *M = ModuleOrErr.get(); 34933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read in the entire module, and destroy the BitcodeReader. 3494579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (std::error_code EC = M->materializeAllPermanently()) { 34953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete M; 3496579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return EC; 34973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 34983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return M; 35003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 35013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3502579361346abc6696c805e3904a18178ebce4e4a3Stephen Hinesstd::string llvm_3_0::getBitcodeTargetTriple(MemoryBufferRef Buffer, 3503579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines LLVMContext &Context) { 3504579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); 3505579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines auto R = llvm::make_unique<BitcodeReader>(Buf.release(), Context); 3506579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines ErrorOr<std::string> Triple = R->parseTriple(); 3507579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines if (Triple.getError()) 3508579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return ""; 3509579361346abc6696c805e3904a18178ebce4e4a3Stephen Hines return Triple.get(); 35103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3511