BitcodeReader.cpp revision d724d097437f40a5689464429f948ec41e4a2415
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" 19b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/AutoUpgrade.h" 20b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/Constants.h" 21b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/DerivedTypes.h" 22b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/InlineAsm.h" 23b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/IntrinsicInst.h" 24b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/IRBuilder.h" 25b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/Module.h" 26b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/OperandTraits.h" 27b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/Operator.h" 28b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/ADT/SmallPtrSet.h" 29c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien#include "llvm/Support/CFG.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) { 47c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!Visited.insert(BB)) 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") { 95c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LPI->addClause(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") { 126c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LPI->addClause(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); 146c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Type *LPadSlotTy = StructType::get(ExnTy, SelTy, NULL); 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()) { 269c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *Resume = cast<CallInst>(EHResume->use_back()); 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 292c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// This function strips all debug info intrinsics, except for llvm.dbg.declare. 293c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// If an llvm.dbg.declare intrinsic is invalid, then this function simply 294c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// strips that use. 295c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien void CheckDebugInfoIntrinsics(Module *M) { 296c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Function *FuncStart = M->getFunction("llvm.dbg.func.start")) { 297c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien while (!FuncStart->use_empty()) 298c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien cast<CallInst>(FuncStart->use_back())->eraseFromParent(); 299c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien FuncStart->eraseFromParent(); 300c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 301c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 302c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Function *StopPoint = M->getFunction("llvm.dbg.stoppoint")) { 303c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien while (!StopPoint->use_empty()) 304c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien cast<CallInst>(StopPoint->use_back())->eraseFromParent(); 305c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien StopPoint->eraseFromParent(); 306c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 307c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 308c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Function *RegionStart = M->getFunction("llvm.dbg.region.start")) { 309c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien while (!RegionStart->use_empty()) 310c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien cast<CallInst>(RegionStart->use_back())->eraseFromParent(); 311c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien RegionStart->eraseFromParent(); 312c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 313c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 314c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Function *RegionEnd = M->getFunction("llvm.dbg.region.end")) { 315c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien while (!RegionEnd->use_empty()) 316c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien cast<CallInst>(RegionEnd->use_back())->eraseFromParent(); 317c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien RegionEnd->eraseFromParent(); 318c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 319c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 320c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Function *Declare = M->getFunction("llvm.dbg.declare")) { 321c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!Declare->use_empty()) { 322c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien DbgDeclareInst *DDI = cast<DbgDeclareInst>(Declare->use_back()); 323c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!isa<MDNode>(DDI->getArgOperand(0)) || 324c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien !isa<MDNode>(DDI->getArgOperand(1))) { 325c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien while (!Declare->use_empty()) { 326c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *CI = cast<CallInst>(Declare->use_back()); 327c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CI->eraseFromParent(); 328c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 329c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Declare->eraseFromParent(); 330c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 331c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 332c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 333c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 334c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien} // end anonymous namespace 3353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReader::FreeState() { 3373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BufferOwned) 3383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete Buffer; 3393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Buffer = 0; 3403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Type*>().swap(TypeList); 3413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.clear(); 3423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValueList.clear(); 3433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 344b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines std::vector<AttributeSet>().swap(MAttributes); 3453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<BasicBlock*>().swap(FunctionBBs); 3463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Function*>().swap(FunctionsWithBodies); 3473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DeferredFunctionInfo.clear(); 3483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDKindMap.clear(); 3493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 3523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// Helper functions to implement forward reference resolution, etc. 3533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 3543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ConvertToString - Convert a string from a record into an std::string, return 3563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// true on failure. 3573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chientemplate<typename StrTy> 3583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic bool ConvertToString(SmallVector<uint64_t, 64> &Record, unsigned Idx, 3593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien StrTy &Result) { 3603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx > Record.size()) 3613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return true; 3623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = Idx, e = Record.size(); i != e; ++i) 3643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Result += (char)Record[i]; 3653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 3663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) { 3693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 3703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Map unknown/new linkages to external 3713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 0: return GlobalValue::ExternalLinkage; 3723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 1: return GlobalValue::WeakAnyLinkage; 3733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 2: return GlobalValue::AppendingLinkage; 3743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 3: return GlobalValue::InternalLinkage; 3753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 4: return GlobalValue::LinkOnceAnyLinkage; 3763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 5: return GlobalValue::DLLImportLinkage; 3773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 6: return GlobalValue::DLLExportLinkage; 3783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 7: return GlobalValue::ExternalWeakLinkage; 3793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 8: return GlobalValue::CommonLinkage; 3803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 9: return GlobalValue::PrivateLinkage; 3813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 10: return GlobalValue::WeakODRLinkage; 3823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 11: return GlobalValue::LinkOnceODRLinkage; 3833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 12: return GlobalValue::AvailableExternallyLinkage; 3843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 13: return GlobalValue::LinkerPrivateLinkage; 3853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 14: return GlobalValue::LinkerPrivateWeakLinkage; 386d724d097437f40a5689464429f948ec41e4a2415Stephen Hines //ANDROID: convert LinkOnceODRAutoHideLinkage -> LinkOnceODRLinkage 387d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case 15: return GlobalValue::LinkOnceODRLinkage; 3883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 3893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) { 3923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 3933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Map unknown visibilities to default. 3943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 0: return GlobalValue::DefaultVisibility; 3953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 1: return GlobalValue::HiddenVisibility; 3963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 2: return GlobalValue::ProtectedVisibility; 3973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 3983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 4008b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liaostatic GlobalVariable::ThreadLocalMode GetDecodedThreadLocalMode(unsigned Val) { 4018b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao switch (Val) { 4028b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 0: return GlobalVariable::NotThreadLocal; 4038b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao default: // Map unknown non-zero value to general dynamic. 4048b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 1: return GlobalVariable::GeneralDynamicTLSModel; 4058b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 2: return GlobalVariable::LocalDynamicTLSModel; 4068b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 3: return GlobalVariable::InitialExecTLSModel; 4078b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 4: return GlobalVariable::LocalExecTLSModel; 4088b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao } 4098b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao} 4108b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao 4113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic int GetDecodedCastOpcode(unsigned Val) { 4123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: return -1; 4143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_TRUNC : return Instruction::Trunc; 4153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_ZEXT : return Instruction::ZExt; 4163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_SEXT : return Instruction::SExt; 4173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_FPTOUI : return Instruction::FPToUI; 4183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_FPTOSI : return Instruction::FPToSI; 4193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_UITOFP : return Instruction::UIToFP; 4203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_SITOFP : return Instruction::SIToFP; 4213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_FPTRUNC : return Instruction::FPTrunc; 4223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_FPEXT : return Instruction::FPExt; 4233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_PTRTOINT: return Instruction::PtrToInt; 4243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_INTTOPTR: return Instruction::IntToPtr; 4253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_BITCAST : return Instruction::BitCast; 4263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic int GetDecodedBinaryOpcode(unsigned Val, Type *Ty) { 4293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: return -1; 4313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_ADD: 4323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FAdd : Instruction::Add; 4333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_SUB: 4343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FSub : Instruction::Sub; 4353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_MUL: 4363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FMul : Instruction::Mul; 4373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_UDIV: return Instruction::UDiv; 4383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_SDIV: 4393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FDiv : Instruction::SDiv; 4403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_UREM: return Instruction::URem; 4413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_SREM: 4423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FRem : Instruction::SRem; 4433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_SHL: return Instruction::Shl; 4443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_LSHR: return Instruction::LShr; 4453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_ASHR: return Instruction::AShr; 4463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_AND: return Instruction::And; 4473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_OR: return Instruction::Or; 4483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_XOR: return Instruction::Xor; 4493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 4523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic AtomicRMWInst::BinOp GetDecodedRMWOperation(unsigned Val) { 4533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: return AtomicRMWInst::BAD_BINOP; 4553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_XCHG: return AtomicRMWInst::Xchg; 4563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_ADD: return AtomicRMWInst::Add; 4573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_SUB: return AtomicRMWInst::Sub; 4583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_AND: return AtomicRMWInst::And; 4593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_NAND: return AtomicRMWInst::Nand; 4603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_OR: return AtomicRMWInst::Or; 4613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_XOR: return AtomicRMWInst::Xor; 4623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_MAX: return AtomicRMWInst::Max; 4633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_MIN: return AtomicRMWInst::Min; 4643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_UMAX: return AtomicRMWInst::UMax; 4653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_UMIN: return AtomicRMWInst::UMin; 4663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 4693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic AtomicOrdering GetDecodedOrdering(unsigned Val) { 4703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_NOTATOMIC: return NotAtomic; 4723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_UNORDERED: return Unordered; 4733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_MONOTONIC: return Monotonic; 4743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_ACQUIRE: return Acquire; 4753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_RELEASE: return Release; 4763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_ACQREL: return AcquireRelease; 4773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Map unknown orderings to sequentially-consistent. 4783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_SEQCST: return SequentiallyConsistent; 4793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 4823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic SynchronizationScope GetDecodedSynchScope(unsigned Val) { 4833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::SYNCHSCOPE_SINGLETHREAD: return SingleThread; 4853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Map unknown scopes to cross-thread. 4863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::SYNCHSCOPE_CROSSTHREAD: return CrossThread; 4873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 4903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chiennamespace llvm { 4913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chiennamespace { 4923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// @brief A class for maintaining the slot number definition 4933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// as a placeholder for the actual definition for forward constants defs. 4943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien class ConstantPlaceHolder : public ConstantExpr { 4953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien void operator=(const ConstantPlaceHolder &); // DO NOT IMPLEMENT 4963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien public: 4973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // allocate space for exactly one operand 4983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien void *operator new(size_t s) { 4993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return User::operator new(s, 1); 5003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien explicit ConstantPlaceHolder(Type *Ty, LLVMContext& Context) 5023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) { 5033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Op<0>() = UndefValue::get(Type::getInt32Ty(Context)); 5043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// @brief Methods to support type inquiry through isa, cast, and dyn_cast. 5073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien //static inline bool classof(const ConstantPlaceHolder *) { return true; } 5083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien static bool classof(const Value *V) { 5093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return isa<ConstantExpr>(V) && 5103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1; 5113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// Provide fast operand accessors 5153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien //DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 5163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien }; 5173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// FIXME: can we inherit this from ConstantExpr? 5203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chientemplate <> 5213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstruct OperandTraits<ConstantPlaceHolder> : 5223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien public FixedNumOperandTraits<ConstantPlaceHolder, 1> { 5233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien}; 5243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) { 5283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx == size()) { 5293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien push_back(V); 5303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 5313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 5343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx+1); 5353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien WeakVH &OldV = ValuePtrs[Idx]; 5373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OldV == 0) { 5383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV = V; 5393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 5403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Handle constants and non-constants (e.g. instrs) differently for 5433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // efficiency. 5443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Constant *PHC = dyn_cast<Constant>(&*OldV)) { 5453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResolveConstants.push_back(std::make_pair(PHC, Idx)); 5463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV = V; 5473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 5483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If there was a forward reference to this value, replace it. 5493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *PrevVal = OldV; 5503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV->replaceAllUsesWith(V); 5513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete PrevVal; 5523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienConstant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, 5573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty) { 5583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 5593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx + 1); 5603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Value *V = ValuePtrs[Idx]) { 5623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(Ty == V->getType() && "Type mismatch in constant table!"); 5633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return cast<Constant>(V); 5643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Create and return a placeholder, which will later be RAUW'd. 5673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *C = new ConstantPlaceHolder(Ty, Context); 5683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValuePtrs[Idx] = C; 5693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return C; 5703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienValue *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty) { 5733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 5743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx + 1); 5753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Value *V = ValuePtrs[Idx]) { 5773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!"); 5783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V; 5793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No type specified, must be invalid reference. 5823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ty == 0) return 0; 5833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Create and return a placeholder, which will later be RAUW'd. 5853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = new Argument(Ty); 5863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValuePtrs[Idx] = V; 5873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V; 5883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ResolveConstantForwardRefs - Once all constants are read, this method bulk 5913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// resolves any forward references. The idea behind this is that we sometimes 5923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// get constants (such as large arrays) which reference *many* forward ref 5933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// constants. Replacing each of these causes a lot of thrashing when 5943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// building/reuniquing the constant. Instead of doing this, we look at all the 5953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// uses and rewrite all the place holders at once for any constant that uses 5963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// a placeholder. 5973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReaderValueList::ResolveConstantForwardRefs() { 5983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Sort the values by-pointer so that they are efficient to look up with a 5993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // binary search. 6003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::sort(ResolveConstants.begin(), ResolveConstants.end()); 6013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Constant*, 64> NewOps; 6033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!ResolveConstants.empty()) { 6053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *RealVal = operator[](ResolveConstants.back().second); 6063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Placeholder = ResolveConstants.back().first; 6073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResolveConstants.pop_back(); 6083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Loop over all users of the placeholder, updating them to reference the 6103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // new value. If they reference more than one placeholder, update them all 6113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // at once. 6123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!Placeholder->use_empty()) { 6133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value::use_iterator UI = Placeholder->use_begin(); 6143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien User *U = *UI; 6153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If the using object isn't uniqued, just update the operands. This 6173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // handles instructions and initializers for global variables. 6183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!isa<Constant>(U) || isa<GlobalValue>(U)) { 6193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UI.getUse().set(RealVal); 6203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 6213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Otherwise, we have a constant that uses the placeholder. Replace that 6243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // constant with a new constant that has *all* placeholder uses updated. 6253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *UserC = cast<Constant>(U); 6263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (User::op_iterator I = UserC->op_begin(), E = UserC->op_end(); 6273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I != E; ++I) { 6283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *NewOp; 6293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!isa<ConstantPlaceHolder>(*I)) { 6303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Not a placeholder reference. 6313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOp = *I; 6323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (*I == Placeholder) { 6333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Common case is that it just references this one placeholder. 6343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOp = RealVal; 6353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 6363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Otherwise, look up the placeholder in ResolveConstants. 6373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResolveConstantsTy::iterator It = 6383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::lower_bound(ResolveConstants.begin(), ResolveConstants.end(), 6393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::pair<Constant*, unsigned>(cast<Constant>(*I), 6403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 0)); 6413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(It != ResolveConstants.end() && It->first == *I); 6423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOp = operator[](It->second); 6433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOps.push_back(cast<Constant>(NewOp)); 6463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Make the new constant. 6493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *NewC; 6503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) { 6513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewC = ConstantArray::get(UserCA->getType(), NewOps); 6523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) { 6533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewC = ConstantStruct::get(UserCS->getType(), NewOps); 6543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (isa<ConstantVector>(UserC)) { 6553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewC = ConstantVector::get(NewOps); 6563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 6573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr."); 6583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewC = cast<ConstantExpr>(UserC)->getWithOperands(NewOps); 6593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UserC->replaceAllUsesWith(NewC); 6623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UserC->destroyConstant(); 6633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOps.clear(); 6643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Update all ValueHandles, they should be the only users at this point. 6673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Placeholder->replaceAllUsesWith(RealVal); 6683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete Placeholder; 6693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 6713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReaderMDValueList::AssignValue(Value *V, unsigned Idx) { 6733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx == size()) { 6743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien push_back(V); 6753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 6763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 6793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx+1); 6803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien WeakVH &OldV = MDValuePtrs[Idx]; 6823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OldV == 0) { 6833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV = V; 6843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 6853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If there was a forward reference to this value, replace it. 6883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDNode *PrevVal = cast<MDNode>(OldV); 6893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV->replaceAllUsesWith(V); 6903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDNode::deleteTemporary(PrevVal); 6913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Deleting PrevVal sets Idx value in MDValuePtrs to null. Set new 6923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // value for Idx. 6933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValuePtrs[Idx] = V; 6943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 6953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienValue *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { 6973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 6983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx + 1); 6993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Value *V = MDValuePtrs[Idx]) { 7013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(V->getType()->isMetadataTy() && "Type mismatch in value table!"); 7023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V; 7033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 7043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Create and return a placeholder, which will later be RAUW'd. 7063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = MDNode::getTemporary(Context, ArrayRef<Value*>()); 7073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValuePtrs[Idx] = V; 7083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V; 7093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 7103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienType *BitcodeReader::getTypeByID(unsigned ID) { 7123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // The type table size is always specified correctly. 7133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ID >= TypeList.size()) 7143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return 0; 715c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 7163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *Ty = TypeList[ID]) 7173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty; 7183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If we have a forward reference, the only possible case is when it is to a 7203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // named struct. Just create a placeholder for now. 7213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return TypeList[ID] = StructType::create(Context); 7223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 7233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// FIXME: Remove in LLVM 3.1, only used by ParseOldTypeTable. 7253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienType *BitcodeReader::getTypeByIDOrNull(unsigned ID) { 7263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ID >= TypeList.size()) 7273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList.resize(ID+1); 728c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 7293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return TypeList[ID]; 7303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 7313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 7343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// Functions for parsing blocks from the bitcode file 7353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 7363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 737d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 738d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// \brief This fills an AttrBuilder object with the LLVM attributes that have 739d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// been decoded from the given integer. This function must stay in sync with 740d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// 'encodeLLVMAttributesForBitcode'. 741d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesstatic void decodeLLVMAttributesForBitcode(AttrBuilder &B, 742d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines uint64_t EncodedAttrs) { 743d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // FIXME: Remove in 4.0. 744d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 745d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The alignment is stored as a 16-bit raw value from bits 31--16. We shift 746d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // the bits above 31 down by 11 bits. 747d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16; 748d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines assert((!Alignment || isPowerOf2_32(Alignment)) && 749d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines "Alignment must be a power of two."); 750d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 751d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Alignment) 752d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines B.addAlignmentAttr(Alignment); 753d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines B.addRawValue(((EncodedAttrs & (0xfffffULL << 32)) >> 11) | 754d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines (EncodedAttrs & 0xffff)); 755d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 756d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 757d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseAttributeBlock() { 7583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) 759d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 7603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!MAttributes.empty()) 762d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidMultipleBlocks); 7633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 7653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 766d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SmallVector<AttributeSet, 8> Attrs; 7673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records. 7693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 770d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 7713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 772d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 773d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 774d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 775d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 776d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 777d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 778d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 779d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 780d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 7813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 7823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 7843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 785d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 7863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: ignore. 7873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 788d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::PARAMATTR_CODE_ENTRY_OLD: { // ENTRY: [paramidx0, attr0, ...] 789d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // FIXME: Remove in 4.0. 7903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() & 1) 791d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 7923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 793b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 794d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines AttrBuilder B; 795d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines decodeLLVMAttributesForBitcode(B, Record[i+1]); 796d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.push_back(AttributeSet::get(Context, Record[i], B)); 7973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 7983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 799d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines MAttributes.push_back(AttributeSet::get(Context, Attrs)); 800d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.clear(); 801d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 802d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 803d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [attrgrp0, attrgrp1, ...] 804d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (unsigned i = 0, e = Record.size(); i != e; ++i) 805d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.push_back(MAttributeGroups[Record[i]]); 8063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 807b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines MAttributes.push_back(AttributeSet::get(Context, Attrs)); 8083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Attrs.clear(); 8093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 8143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 815d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 816d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseTypeTable() { 8173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW)) 818d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 819c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 8203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return ParseTypeTableBody(); 8213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 8223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 823d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseTypeTableBody() { 8243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!TypeList.empty()) 825d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidMultipleBlocks); 8263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 8283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumRecords = 0; 8293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<64> TypeName; 831c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 8323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this type table. 8333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 834d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 835d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 836d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 837d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 838d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 839d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 840d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 8413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumRecords != TypeList.size()) 842d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 843d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 844d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 845d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 846d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 8473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 8503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 8513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ResultTy = 0; 852d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 853d724d097437f40a5689464429f948ec41e4a2415Stephen Hines default: 854d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 8553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 8563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // TYPE_CODE_NUMENTRY contains a count of the number of types in the 8573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // type list. This allows us to reserve space. 8583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 859d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 8603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList.resize(Record[0]); 8613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 8623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_VOID: // VOID 8633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getVoidTy(Context); 8643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 865d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::TYPE_CODE_HALF: // HALF 866d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ResultTy = Type::getHalfTy(Context); 867d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 8683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FLOAT: // FLOAT 8693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getFloatTy(Context); 8703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_DOUBLE: // DOUBLE 8723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getDoubleTy(Context); 8733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_X86_FP80: // X86_FP80 8753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getX86_FP80Ty(Context); 8763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FP128: // FP128 8783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getFP128Ty(Context); 8793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 8813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getPPC_FP128Ty(Context); 8823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_LABEL: // LABEL 8843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getLabelTy(Context); 8853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_METADATA: // METADATA 8873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getMetadataTy(Context); 8883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_X86_MMX: // X86_MMX 8903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getX86_MMXTy(Context); 8913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 8933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 894d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 8953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = IntegerType::get(Context, Record[0]); 8973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 8993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // [pointee type, address space] 9003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 901d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 9023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned AddressSpace = 0; 9033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() == 2) 9043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AddressSpace = Record[1]; 9053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = getTypeByID(Record[0]); 906d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (ResultTy == 0) 907d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 9083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = PointerType::get(ResultTy, AddressSpace); 9093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FUNCTION_OLD: { 912b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // FIXME: attrid is dead, remove it in LLVM 4.0 9133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [vararg, attrid, retty, paramty x N] 9143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 915d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 916b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Type*, 8> ArgTys; 9173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 3, e = Record.size(); i != e; ++i) { 9183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *T = getTypeByID(Record[i])) 9193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArgTys.push_back(T); 9203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 9213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 923c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 9243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = getTypeByID(Record[2]); 9253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ResultTy == 0 || ArgTys.size() < Record.size()-3) 926d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 9273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 9283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 9293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FUNCTION: { 9323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [vararg, retty, paramty x N] 9333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 934d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 935d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SmallVector<Type*, 8> ArgTys; 9363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 2, e = Record.size(); i != e; ++i) { 9373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *T = getTypeByID(Record[i])) 9383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArgTys.push_back(T); 9393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 9403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 942c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 9433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = getTypeByID(Record[1]); 9443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ResultTy == 0 || ArgTys.size() < Record.size()-2) 945d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 9463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 9473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 9483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N] 9513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 952d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 953b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Type*, 8> EltTys; 9543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1, e = Record.size(); i != e; ++i) { 9553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *T = getTypeByID(Record[i])) 9563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien EltTys.push_back(T); 9573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 9583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (EltTys.size() != Record.size()-1) 961d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 9623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = StructType::get(Context, EltTys, Record[0]); 9633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N] 9663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, TypeName)) 967d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 9683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 9693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 9703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N] 9713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 972d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 973c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 9743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumRecords >= TypeList.size()) 975d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 976c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 9773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check to see if this was forward referenced, if so fill in the temp. 9783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 9793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Res) { 9803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res->setName(TypeName); 9813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList[NumRecords] = 0; 9823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else // Otherwise, create a new struct. 9833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res = StructType::create(Context, TypeName); 9843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeName.clear(); 985c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 9863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Type*, 8> EltTys; 9873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1, e = Record.size(); i != e; ++i) { 9883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *T = getTypeByID(Record[i])) 9893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien EltTys.push_back(T); 9903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 9913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (EltTys.size() != Record.size()-1) 994d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 9953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res->setBody(EltTys, Record[0]); 9963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Res; 9973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: [] 10003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() != 1) 1001d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 10023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 10033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumRecords >= TypeList.size()) 1004d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 1005c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check to see if this was forward referenced, if so fill in the temp. 10073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 10083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Res) { 10093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res->setName(TypeName); 10103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList[NumRecords] = 0; 10113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else // Otherwise, create a new struct with no body. 10123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res = StructType::create(Context, TypeName); 10133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeName.clear(); 10143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Res; 10153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1016c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 10173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 10183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 1019d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 10203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByID(Record[1]))) 10213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = ArrayType::get(ResultTy, Record[0]); 10223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 1023d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 10243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 10253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 10263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 1027d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 10283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByID(Record[1]))) 10293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = VectorType::get(ResultTy, Record[0]); 10303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 1031d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 10323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 10333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 10343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 10353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumRecords >= TypeList.size()) 1036d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 10373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(ResultTy && "Didn't read a type?"); 10383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(TypeList[NumRecords] == 0 && "Already read type?"); 10393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList[NumRecords++] = ResultTy; 10403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 10413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 10423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 10433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// FIXME: Remove in LLVM 3.1 1044d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseOldTypeTable() { 1045c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Stream.EnterSubBlock(TYPE_BLOCK_ID_OLD_3_0)) 1046d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 10473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 10483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!TypeList.empty()) 1049d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 1050c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 1051c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // While horrible, we have no good ordering of types in the bc file. Just 10533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // iteratively parse types out of the bc file in multiple passes until we get 10543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // them all. Do this by saving a cursor for the start of the type block. 10553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BitstreamCursor StartOfTypeBlockCursor(Stream); 1056c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumTypesRead = 0; 1058c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 10603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienRestartScan: 10613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NextTypeID = 0; 10623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool ReadAnyTypes = false; 1063c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this type table. 10653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 10663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 10673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 10683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextTypeID != TypeList.size()) 1069d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 1070c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If we haven't read all of the types yet, iterate again. 10723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumTypesRead != TypeList.size()) { 10733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If we didn't successfully read any types in this pass, then we must 10743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // have an unhandled forward reference. 10753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!ReadAnyTypes) 1076d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 1077c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream = StartOfTypeBlockCursor; 10793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien goto RestartScan; 10803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1081c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 1083d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 1084d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 10853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1086c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 10883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No known subblocks, always skip them. 10893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadSubBlockID(); 10903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 1091d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 10923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 10933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1094c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 10963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 10973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 10983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1099c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 11003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 11013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 11023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ResultTy = 0; 1103d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 1104d724d097437f40a5689464429f948ec41e4a2415Stephen Hines default: return Error(InvalidTYPETable); 11053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 11063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // TYPE_CODE_NUMENTRY contains a count of the number of types in the 11073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // type list. This allows us to reserve space. 11083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 1109d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 11103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList.resize(Record[0]); 11113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 11123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_VOID: // VOID 11133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getVoidTy(Context); 11143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FLOAT: // FLOAT 11163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getFloatTy(Context); 11173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_DOUBLE: // DOUBLE 11193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getDoubleTy(Context); 11203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_X86_FP80: // X86_FP80 11223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getX86_FP80Ty(Context); 11233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FP128: // FP128 11253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getFP128Ty(Context); 11263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 11283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getPPC_FP128Ty(Context); 11293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_LABEL: // LABEL 11313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getLabelTy(Context); 11323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_METADATA: // METADATA 11343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getMetadataTy(Context); 11353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_X86_MMX: // X86_MMX 11373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getX86_MMXTy(Context); 11383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 11403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 1141d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 11423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = IntegerType::get(Context, Record[0]); 11433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_OPAQUE: // OPAQUE 11453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextTypeID < TypeList.size() && TypeList[NextTypeID] == 0) 1146b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines ResultTy = StructType::create(Context, ""); 11473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1148c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien case TYPE_CODE_STRUCT_OLD_3_0: {// STRUCT_OLD 11493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextTypeID >= TypeList.size()) break; 11503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If we already read it, don't reprocess. 11513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (TypeList[NextTypeID] && 11523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien !cast<StructType>(TypeList[NextTypeID])->isOpaque()) 11533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 11553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Set a type. 11563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (TypeList[NextTypeID] == 0) 1157b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines TypeList[NextTypeID] = StructType::create(Context, ""); 11583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 11593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Type*> EltTys; 11603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1, e = Record.size(); i != e; ++i) { 11613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *Elt = getTypeByIDOrNull(Record[i])) 11623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien EltTys.push_back(Elt); 11633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 11643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 11663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 11673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (EltTys.size() != Record.size()-1) 11683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; // Not all elements are ready. 1169c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 11703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<StructType>(TypeList[NextTypeID])->setBody(EltTys, Record[0]); 11713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = TypeList[NextTypeID]; 11723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList[NextTypeID] = 0; 11733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 11753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 11763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // [pointee type, address space] 11773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 1178d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 11793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned AddressSpace = 0; 11803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() == 2) 11813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AddressSpace = Record[1]; 11823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[0]))) 11833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = PointerType::get(ResultTy, AddressSpace); 11843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 11863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FUNCTION_OLD: { 11873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FIXME: attrid is dead, remove it in LLVM 3.0 11883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [vararg, attrid, retty, paramty x N] 11893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 1190d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 11913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Type*> ArgTys; 11923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 3, e = Record.size(); i != e; ++i) { 11933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *Elt = getTypeByIDOrNull(Record[i])) 11943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArgTys.push_back(Elt); 11953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 11963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 11983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ArgTys.size()+3 != Record.size()) 11993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; // Something was null. 12003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[2]))) 12013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 12023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FUNCTION: { 12053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [vararg, retty, paramty x N] 12063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 1207d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 12083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Type*> ArgTys; 12093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 2, e = Record.size(); i != e; ++i) { 12103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *Elt = getTypeByIDOrNull(Record[i])) 12113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArgTys.push_back(Elt); 12123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 12133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ArgTys.size()+2 != Record.size()) 12163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; // Something was null. 12173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[1]))) 12183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 12193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 12223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 1223d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 12243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[1]))) 12253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = ArrayType::get(ResultTy, Record[0]); 12263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 12283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 1229d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 12303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[1]))) 12313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = VectorType::get(ResultTy, Record[0]); 12323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1234c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 12353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextTypeID >= TypeList.size()) 1236d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 1237c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 12383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ResultTy && TypeList[NextTypeID] == 0) { 12393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ++NumTypesRead; 12403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ReadAnyTypes = true; 1241c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 12423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList[NextTypeID] = ResultTy; 12433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1244c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 12453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ++NextTypeID; 12463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 12483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1250d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseOldTypeSymbolTable() { 1251c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Stream.EnterSubBlock(TYPE_SYMTAB_BLOCK_ID_OLD_3_0)) 1252d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 12533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 12553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this type table. 12573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string TypeName; 12583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 12593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 12603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 12613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 1262d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1263d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 12643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 12673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No known subblocks, always skip them. 12683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadSubBlockID(); 12693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 1270d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 12713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 12723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 12753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 12763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 12773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 12803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 1281d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 12823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: unknown type. 12833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TST_CODE_ENTRY: // TST_ENTRY: [typeid, namechar x N] 12853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 1, TypeName)) 1286d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 12873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned TypeID = Record[0]; 12883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (TypeID >= TypeList.size()) 1289d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 12903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Only apply the type name to a struct type with no name. 12923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (StructType *STy = dyn_cast<StructType>(TypeList[TypeID])) 12933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!STy->isLiteral() && !STy->hasName()) 12943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien STy->setName(TypeName); 12953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeName.clear(); 12963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 13003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1301d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseValueSymbolTable() { 13023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) 1303d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 13043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 13063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this value table. 13083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<128> ValueName; 13093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 13103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 13113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 13123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 1313d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1314d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 13153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 13173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No known subblocks, always skip them. 13183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadSubBlockID(); 13193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 1320d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 13213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 13223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 13253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 13263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 13273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 13303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 1331d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 13323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: unknown type. 13333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 13343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N] 13353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 1, ValueName)) 1336d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 13373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ValueID = Record[0]; 13383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ValueID >= ValueList.size()) 1339d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 13403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = ValueList[ValueID]; 13413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V->setName(StringRef(ValueName.data(), ValueName.size())); 13433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueName.clear(); 13443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 13453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::VST_CODE_BBENTRY: { 13473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 1, ValueName)) 1348d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 13493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *BB = getBasicBlock(Record[0]); 13503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BB == 0) 1351d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 13523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BB->setName(StringRef(ValueName.data(), ValueName.size())); 13543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueName.clear(); 13553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 13563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 13603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1361d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseMetadata() { 13623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NextMDValueNo = MDValueList.size(); 13633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) 1365d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 13663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 13683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records. 13703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 13713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 13723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 13733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 1374d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1375d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 13763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 13793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No known subblocks, always skip them. 13803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadSubBlockID(); 13813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 1382d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 13833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 13843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 13873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 13883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 13893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool IsFunctionLocal = false; 13923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 13933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 1394d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Code = Stream.readRecord(Code, Record); 13953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Code) { 13963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: ignore. 13973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 13983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_NAME: { 13993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read named of the named metadata. 14003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NameLength = Record.size(); 14013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<8> Name; 14023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Name.resize(NameLength); 14033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != NameLength; ++i) 14043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Name[i] = Record[i]; 14053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 14063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Code = Stream.ReadCode(); 14073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 14083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // METADATA_NAME is always followed by METADATA_NAMED_NODE. 1409d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned NextBitCode = Stream.readRecord(Code, Record); 14103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(NextBitCode == bitc::METADATA_NAMED_NODE); (void)NextBitCode; 14113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 14123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read named metadata elements. 14133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 14143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NamedMDNode *NMD = TheModule->getOrInsertNamedMetadata(Name); 14153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) { 14163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDNode *MD = dyn_cast<MDNode>(MDValueList.getValueFwdRef(Record[i])); 14173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (MD == 0) 1418d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 14193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NMD->addOperand(MD); 14203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 14223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_FN_NODE: 14243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien IsFunctionLocal = true; 14253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // fall-through 14263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_NODE: { 14273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() % 2 == 1) 1428d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 14293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 14303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 14313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Value*, 8> Elts; 14323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; i += 2) { 14333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[i]); 1434d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 1435d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 14363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ty->isMetadataTy()) 14373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); 14383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (!Ty->isVoidTy()) 14393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty)); 14403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 14413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(NULL); 14423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = MDNode::getWhenValsUnresolved(Context, Elts, IsFunctionLocal); 14443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien IsFunctionLocal = false; 14453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValueList.AssignValue(V, NextMDValueNo++); 14463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 14473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_STRING: { 14493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned MDStringLength = Record.size(); 14503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<8> String; 14513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien String.resize(MDStringLength); 14523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != MDStringLength; ++i) 14533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien String[i] = Record[i]; 14543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = MDString::get(Context, 14553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien StringRef(String.data(), String.size())); 14563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValueList.AssignValue(V, NextMDValueNo++); 14573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 14583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_KIND: { 14603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned RecordLength = Record.size(); 14613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty() || RecordLength < 2) 1462d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 14633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<8> Name; 14643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Name.resize(RecordLength-1); 14653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Kind = Record[0]; 14663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1; i != RecordLength; ++i) 14673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Name[i-1] = Record[i]; 1468c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 14693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NewKind = TheModule->getMDKindID(Name.str()); 14703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) 1471d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(ConflictingMETADATA_KINDRecords); 14723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 14733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 14773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1478d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// decodeSignRotatedValue - Decode a signed value stored with the sign bit in 14793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// the LSB for dense VBR encoding. 1480d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesuint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) { 14813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((V & 1) == 0) 14823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V >> 1; 14833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (V != 1) 14843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return -(V >> 1); 14853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // There is no such thing as -0 with integers. "-0" really means MININT. 14863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return 1ULL << 63; 14873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 14883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 14893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ResolveGlobalAndAliasInits - Resolve all of the initializers for global 14903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// values and aliases that we can. 1491d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ResolveGlobalAndAliasInits() { 14923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist; 14933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist; 14943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 14953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInitWorklist.swap(GlobalInits); 14963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AliasInitWorklist.swap(AliasInits); 14973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 14983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!GlobalInitWorklist.empty()) { 14993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ValID = GlobalInitWorklist.back().second; 15003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ValID >= ValueList.size()) { 15013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Not ready to resolve this yet, it requires something later in the file. 15023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInits.push_back(GlobalInitWorklist.back()); 15033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 15043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 15053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInitWorklist.back().first->setInitializer(C); 15063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 1507d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(ExpectedConstant); 15083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInitWorklist.pop_back(); 15103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!AliasInitWorklist.empty()) { 15133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ValID = AliasInitWorklist.back().second; 15143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ValID >= ValueList.size()) { 15153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AliasInits.push_back(AliasInitWorklist.back()); 15163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 15173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 15183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AliasInitWorklist.back().first->setAliasee(C); 15193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 1520d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(ExpectedConstant); 15213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AliasInitWorklist.pop_back(); 15233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1524d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 15253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 15263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1527d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesstatic APInt ReadWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) { 1528d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SmallVector<uint64_t, 8> Words(Vals.size()); 1529d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::transform(Vals.begin(), Vals.end(), Words.begin(), 1530d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitcodeReader::decodeSignRotatedValue); 1531d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1532d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return APInt(TypeBits, Words); 1533d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 1534d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1535d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseConstants() { 15363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) 1537d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 15383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 15403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this value table. 15423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *CurTy = Type::getInt32Ty(Context); 15433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NextCstNo = ValueList.size(); 15443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 1545d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 1546d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1547d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 1548d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 1549d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 1550d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1551d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 1552d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (NextCstNo != ValueList.size()) 1553d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidConstantReference); 1554d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1555d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Once all the constants have been read, go through and resolve forward 1556d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // references. 1557d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ValueList.ResolveConstantForwardRefs(); 1558d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1559d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 1560d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 15613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 15623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 15653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 15663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = 0; 1567d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned BitCode = Stream.readRecord(Entry.ID, Record); 15683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (BitCode) { 15693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: unknown constant 15703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_UNDEF: // UNDEF 15713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); 15723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 15733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] 15743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 1575d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 15763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[0] >= TypeList.size()) 1577d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 15783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CurTy = TypeList[Record[0]]; 15793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; // Skip the ValueList manipulation. 15803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_NULL: // NULL 15813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = Constant::getNullValue(CurTy); 15823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 15833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_INTEGER: // INTEGER: [intval] 15843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!CurTy->isIntegerTy() || Record.empty()) 1585d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1586d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0])); 15873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 15883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval] 15893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!CurTy->isIntegerTy() || Record.empty()) 1590d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 15913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1592d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt VInt = ReadWideAPInt(Record, 1593d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines cast<IntegerType>(CurTy)->getBitWidth()); 1594d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantInt::get(Context, VInt); 1595d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 15963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 15973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] 15993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 1600d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1601d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (CurTy->isHalfTy()) 1602d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf, 1603d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(16, (uint16_t)Record[0]))); 1604d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else if (CurTy->isFloatTy()) 1605d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEsingle, 1606d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(32, (uint32_t)Record[0]))); 16073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (CurTy->isDoubleTy()) 1608d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEdouble, 1609d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(64, Record[0]))); 16103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (CurTy->isX86_FP80Ty()) { 16113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Bits are not stored the same way as a normal i80 APInt, compensate. 16123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien uint64_t Rearrange[2]; 16133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16); 16143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Rearrange[1] = Record[0] >> 48; 1615d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::x87DoubleExtended, 1616d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(80, Rearrange))); 16173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (CurTy->isFP128Ty()) 1618d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEquad, 1619d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(128, Record))); 16203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (CurTy->isPPC_FP128Ty()) 1621d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::PPCDoubleDouble, 1622d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(128, Record))); 16233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 16243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); 16253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] 16293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 1630d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 16313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 1633b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Constant*, 16> Elts; 16343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (StructType *STy = dyn_cast<StructType>(CurTy)) { 16363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 16373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getConstantFwdRef(Record[i], 16383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien STy->getElementType(i))); 16393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantStruct::get(STy, Elts); 16403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) { 16413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *EltTy = ATy->getElementType(); 16423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 16433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 16443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantArray::get(ATy, Elts); 16453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) { 16463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *EltTy = VTy->getElementType(); 16473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 16483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 16493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantVector::get(Elts); 16503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 16513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); 16523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_STRING: { // STRING: [values] 16563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 1657d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 16583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArrayType *ATy = cast<ArrayType>(CurTy); 16603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *EltTy = ATy->getElementType(); 16613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 16633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Constant*> Elts; 16643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 16653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ConstantInt::get(EltTy, Record[i])); 16663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantArray::get(ATy, Elts); 16673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CSTRING: { // CSTRING: [values] 16703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 1671d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 16723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArrayType *ATy = cast<ArrayType>(CurTy); 16743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *EltTy = ATy->getElementType(); 16753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 16773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Constant*> Elts; 16783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 16793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ConstantInt::get(EltTy, Record[i])); 16803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(Constant::getNullValue(EltTy)); 16813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantArray::get(ATy, Elts); 16823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] 1685d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1686d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 16873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien int Opc = GetDecodedBinaryOpcode(Record[0], CurTy); 16883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc < 0) { 16893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); // Unknown binop. 16903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 16913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy); 16923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy); 16933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Flags = 0; 16943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() >= 4) { 16953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc == Instruction::Add || 16963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Sub || 16973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Mul || 16983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Shl) { 16993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 17003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Flags |= OverflowingBinaryOperator::NoSignedWrap; 17013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 17023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Flags |= OverflowingBinaryOperator::NoUnsignedWrap; 17033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (Opc == Instruction::SDiv || 17043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::UDiv || 17053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::LShr || 17063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::AShr) { 17073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[3] & (1 << bitc::PEO_EXACT)) 17083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Flags |= SDivOperator::IsExact; 17093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::get(Opc, LHS, RHS, Flags); 17123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] 1716d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1717d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien int Opc = GetDecodedCastOpcode(Record[0]); 17193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc < 0) { 17203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); // Unknown cast. 17213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 17223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[1]); 1723d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!OpTy) 1724d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); 17263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getCast(Opc, Op, CurTy); 17273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_INBOUNDS_GEP: 17313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands] 1732d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() & 1) 1733d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Constant*, 16> Elts; 17353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 17363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ElTy = getTypeByID(Record[i]); 1737d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!ElTy) 1738d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); 17403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end()); 17423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getGetElementPtr(Elts[0], Indices, 17433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BitCode == 17443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bitc::CST_CODE_CE_INBOUNDS_GEP); 17453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_SELECT: // CE_SELECT: [opval#, opval#, opval#] 1748d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1749d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0], 17513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type::getInt1Ty(Context)), 17523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.getConstantFwdRef(Record[1],CurTy), 17533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.getConstantFwdRef(Record[2],CurTy)); 17543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval] 1756d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1757d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *OpTy = 17593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1760d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (OpTy == 0) 1761d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 17633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 17643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getExtractElement(Op0, Op1); 17653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval] 17683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *OpTy = dyn_cast<VectorType>(CurTy); 17693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3 || OpTy == 0) 1770d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 17723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[1], 17733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpTy->getElementType()); 17743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 17753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getInsertElement(Op0, Op1, Op2); 17763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] 17793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *OpTy = dyn_cast<VectorType>(CurTy); 17803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3 || OpTy == 0) 1781d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 17833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); 17843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 17853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpTy->getNumElements()); 17863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy); 17873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 17883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval] 17913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *RTy = dyn_cast<VectorType>(CurTy); 17923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *OpTy = 17933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 17943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 4 || RTy == 0 || OpTy == 0) 1795d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 17973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 17983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 17993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien RTy->getNumElements()); 18003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy); 18013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 18023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 18033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] 1805d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 4) 1806d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 18073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[0]); 1808d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (OpTy == 0) 1809d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 18103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 18113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 18123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpTy->isFPOrFPVectorTy()) 18143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getFCmp(Record[3], Op0, Op1); 18153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 18163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getICmp(Record[3], Op0, Op1); 18173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 18183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_INLINEASM: { 1820d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 2) 1821d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 18223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string AsmStr, ConstrStr; 18233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool HasSideEffects = Record[0] & 1; 18243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool IsAlignStack = Record[0] >> 1; 18253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned AsmStrSize = Record[1]; 18263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (2+AsmStrSize >= Record.size()) 1827d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 18283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ConstStrSize = Record[2+AsmStrSize]; 18293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (3+AsmStrSize+ConstStrSize > Record.size()) 1830d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 18313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != AsmStrSize; ++i) 18333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AsmStr += (char)Record[2+i]; 18343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != ConstStrSize; ++i) 18353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ConstrStr += (char)Record[3+AsmStrSize+i]; 18363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PointerType *PTy = cast<PointerType>(CurTy); 18373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), 18383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AsmStr, ConstrStr, HasSideEffects, IsAlignStack); 18393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 18403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_BLOCKADDRESS:{ 1842d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1843d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 18443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *FnTy = getTypeByID(Record[0]); 1845d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (FnTy == 0) 1846d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 18473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *Fn = 18483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy)); 1849d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Fn == 0) 1850d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1851c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 18523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalVariable *FwdRef = new GlobalVariable(*Fn->getParent(), 18533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type::getInt8Ty(Context), 18543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien false, GlobalValue::InternalLinkage, 18553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 0, ""); 18563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BlockAddrFwdRefs[Fn].push_back(std::make_pair(Record[2], FwdRef)); 18573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = FwdRef; 18583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1859c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 18603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.AssignValue(V, NextCstNo); 18633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ++NextCstNo; 18643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextCstNo != ValueList.size()) 1867d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidConstantReference); 18683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 1870d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(ExpectedConstant); 18713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Once all the constants have been read, go through and resolve forward 18733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // references. 18743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.ResolveConstantForwardRefs(); 1875d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 18763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 18773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// RememberAndSkipFunctionBody - When we see the block for a function body, 18793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// remember where it is and then skip it. This lets us lazily deserialize the 18803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// functions. 1881d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::RememberAndSkipFunctionBody() { 18823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Get the function we are talking about. 18833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (FunctionsWithBodies.empty()) 1884d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InsufficientFunctionProtos); 18853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *Fn = FunctionsWithBodies.back(); 18873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionsWithBodies.pop_back(); 18883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Save the current stream state. 18903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien uint64_t CurBit = Stream.GetCurrentBitNo(); 18913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DeferredFunctionInfo[Fn] = CurBit; 18923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Skip over the function block for now. 18943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 1895d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1896d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 18973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 18983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1899d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::GlobalCleanup() { 1900d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Patch the initializers for globals and aliases up. 1901d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ResolveGlobalAndAliasInits(); 1902d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!GlobalInits.empty() || !AliasInits.empty()) 1903d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedGlobalInitializerSet); 1904d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1905d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Look for intrinsic functions which need to be upgraded at some point 1906d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); 1907d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines FI != FE; ++FI) { 1908d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Function *NewFn; 1909d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (UpgradeIntrinsicFunction(FI, NewFn)) 1910d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn)); 1911d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 1912d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1913d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Look for global variables which need to be renamed. 1914d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (Module::global_iterator 1915d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines GI = TheModule->global_begin(), GE = TheModule->global_end(); 1916d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines GI != GE; ++GI) 1917d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines UpgradeGlobalVariable(GI); 1918d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Force deallocation of memory for these vectors to favor the client that 1919d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // want lazy deserialization. 1920d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); 1921d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); 1922d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1923d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 1924d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1925d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseModule(bool Resume) { 1926d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Resume) 1927d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.JumpToBit(NextUnreadBit); 1928d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 1929d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 19303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 19323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::string> SectionTable; 19333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::string> GCTable; 19343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this module. 1936d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 1937d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advance(); 19383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1939d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 1940d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 1941d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1942d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 1943d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return GlobalCleanup(); 19443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1945d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: 1946d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.ID) { 19473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Skip unknown content. 19483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 1949d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 19503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BLOCKINFO_BLOCK_ID: 19523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockInfoBlock()) 1953d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 19543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::PARAMATTR_BLOCK_ID: 1956d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseAttributeBlock()) 1957d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 19583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_BLOCK_ID_NEW: 1960d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseTypeTable()) 1961d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 19623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1963c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien case TYPE_BLOCK_ID_OLD_3_0: 1964d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseOldTypeTable()) 1965d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 19663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1967c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien case TYPE_SYMTAB_BLOCK_ID_OLD_3_0: 1968d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseOldTypeSymbolTable()) 1969d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 19703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::VALUE_SYMTAB_BLOCK_ID: 1972d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseValueSymbolTable()) 1973d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1974d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SeenValueSymbolTable = true; 19753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CONSTANTS_BLOCK_ID: 1977d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseConstants()) 1978d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1979d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ResolveGlobalAndAliasInits()) 1980d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 19813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_BLOCK_ID: 1983d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseMetadata()) 1984d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 19853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNCTION_BLOCK_ID: 19873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If this is the first function body we've seen, reverse the 19883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FunctionsWithBodies list. 1989d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!SeenFirstFunctionBody) { 19903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end()); 1991d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = GlobalCleanup()) 1992d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1993d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SeenFirstFunctionBody = true; 19943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 19953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1996d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = RememberAndSkipFunctionBody()) 1997d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1998d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // For streaming bitcode, suspend parsing when we reach the function 1999d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // bodies. Subsequent materialization calls will resume it when 2000d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // necessary. For streaming, the function bodies must be at the end of 2001d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // the bitcode. If the bitcode file is old, the symbol table will be 2002d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // at the end instead and will not have been seen yet. In this case, 2003d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // just finish the parse now. 2004d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (LazyStreamer && SeenValueSymbolTable) { 2005d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines NextUnreadBit = Stream.GetCurrentBitNo(); 2006d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2007d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 2008d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 20093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 20123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2013d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2014d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 2015d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 20163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2018d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 20193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 2020d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 20213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: break; // Default behavior, ignore unknown content. 2022b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines case bitc::MODULE_CODE_VERSION: { // VERSION: [version#] 20233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 2024d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 20253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Only version #0 is supported so far. 20263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[0] != 0) 2027d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 20283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 2029b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines } 20303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 20313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2033d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 20343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TheModule->setTargetTriple(S); 20353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] 20383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2040d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 20413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TheModule->setDataLayout(S); 20423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] 20453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2047d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 20483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TheModule->setModuleInlineAsm(S); 20493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N] 20523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2054d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2055b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // ANDROID: Ignore value, since we never used it anyways. 2056b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // TheModule->addLibrary(S); 20573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] 20603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2062d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 20633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SectionTable.push_back(S); 20643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N] 20673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2069d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 20703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GCTable.push_back(S); 20713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // GLOBALVAR: [pointer type, isconst, initid, 20743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // linkage, alignment, section, visibility, threadlocal, 20753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // unnamed_addr] 20763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_GLOBALVAR: { 20773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 6) 2078d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 20793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[0]); 2080d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 2081d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 20823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Ty->isPointerTy()) 2083d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 20843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); 20853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ty = cast<PointerType>(Ty)->getElementType(); 20863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 20873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool isConstant = Record[1]; 20883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]); 20893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Alignment = (1 << Record[4]) >> 1; 20903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string Section; 20913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[5]) { 20923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[5]-1 >= SectionTable.size()) 2093d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 20943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Section = SectionTable[Record[5]-1]; 20953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; 20973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 6) 20983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Visibility = GetDecodedVisibility(Record[6]); 20998b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao 21008b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal; 21013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 7) 21028b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao TLM = GetDecodedThreadLocalMode(Record[7]); 21033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool UnnamedAddr = false; 21053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 8) 21063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UnnamedAddr = Record[8]; 21073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalVariable *NewGV = 21093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien new GlobalVariable(*TheModule, Ty, isConstant, Linkage, 0, "", 0, 21108b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao TLM, AddressSpace); 21113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGV->setAlignment(Alignment); 21123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Section.empty()) 21133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGV->setSection(Section); 21143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGV->setVisibility(Visibility); 21153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGV->setUnnamedAddr(UnnamedAddr); 21163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.push_back(NewGV); 21183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Remember which value to use for the global initializer. 21203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (unsigned InitID = Record[2]) 21213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInits.push_back(std::make_pair(NewGV, InitID-1)); 21223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 21233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [type, callingconv, isproto, linkage, paramattr, 21253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // alignment, section, visibility, gc, unnamed_addr] 21263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_FUNCTION: { 21273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 8) 2128d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 21293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[0]); 2130d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 2131d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 21323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Ty->isPointerTy()) 2133d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 21343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionType *FTy = 21353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType()); 21363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!FTy) 2137d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 21383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, 21403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien "", TheModule); 21413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setCallingConv(static_cast<CallingConv::ID>(Record[1])); 21433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool isProto = Record[2]; 21443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setLinkage(GetDecodedLinkage(Record[3])); 21453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setAttributes(getAttributes(Record[4])); 21463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setAlignment((1 << Record[5]) >> 1); 21483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[6]) { 21493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[6]-1 >= SectionTable.size()) 2150d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 21513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setSection(SectionTable[Record[6]-1]); 21523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setVisibility(GetDecodedVisibility(Record[7])); 21543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 8 && Record[8]) { 21553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[8]-1 > GCTable.size()) 2156d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 21573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setGC(GCTable[Record[8]-1].c_str()); 21583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool UnnamedAddr = false; 21603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 9) 21613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UnnamedAddr = Record[9]; 21623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setUnnamedAddr(UnnamedAddr); 21633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.push_back(Func); 21643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If this is a function with a body, remember the prototype we are 21663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // creating now, so that we can match up the body with them later. 2167d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isProto) { 21683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionsWithBodies.push_back(Func); 2169d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (LazyStreamer) DeferredFunctionInfo[Func] = 0; 2170d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 21713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 21723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // ALIAS: [alias type, aliasee val#, linkage] 21743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // ALIAS: [alias type, aliasee val#, linkage, visibility] 21753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_ALIAS: { 21763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 2177d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 21783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[0]); 2179d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 2180d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 21813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Ty->isPointerTy()) 2182d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 21833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]), 21853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien "", 0, TheModule); 21863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Old bitcode files didn't have visibility field. 21873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 3) 21883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGA->setVisibility(GetDecodedVisibility(Record[3])); 21893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.push_back(NewGA); 21903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AliasInits.push_back(std::make_pair(NewGA, Record[1])); 21913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 21923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// MODULE_CODE_PURGEVALS: [numvals] 21943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_PURGEVALS: 21953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Trim down the value list to the specified size. 21963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1 || Record[0] > ValueList.size()) 2197d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 21983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.shrinkTo(Record[0]); 21993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 22003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 22023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 22043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2205d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseBitcodeInto(Module *M) { 22063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TheModule = 0; 22073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2208d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = InitStream()) 2209d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 22103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Sniff for the signature. 22123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.Read(8) != 'B' || 22133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(8) != 'C' || 22143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0x0 || 22153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xC || 22163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xE || 22173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xD) 2218d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 22193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // We expect a number of well-defined blocks, though we don't necessarily 22213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // need to understand them all. 2222d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2223d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.AtEndOfStream()) 2224d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2225d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2226d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = 2227d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs); 2228d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2229d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2230d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2231d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2232d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2233d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 22343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2235d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: 2236d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.ID) { 2237d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::BLOCKINFO_BLOCK_ID: 2238d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.ReadBlockInfoBlock()) 2239d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2240d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 2241d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::MODULE_BLOCK_ID: 2242d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Reject multiple MODULE_BLOCK's in a single bitstream. 2243d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (TheModule) 2244d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidMultipleBlocks); 2245d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines TheModule = M; 2246d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseModule(false)) 2247d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2248d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (LazyStreamer) 2249d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2250d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 2251d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines default: 2252d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.SkipBlock()) 2253d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2254d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 2255d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 2256d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 2257d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2258d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // There should be no records in the top-level of blocks. 22593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2260d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The ranlib in Xcode 4 will align archive members by appending newlines 22613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // to the end of them. If this file size is a multiple of 4 but not 8, we 22623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // have to read and ignore these final 4 bytes :-( 2263d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.getAbbrevIDWidth() == 2 && Entry.ID == 2 && 22643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a && 2265b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines Stream.AtEndOfStream()) 2266d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 22673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2268d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 22693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 22723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2273d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseModuleTriple(std::string &Triple) { 22743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 2275d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 22763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 22783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this module. 2280d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2281d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 22823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2283d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2284d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 2285d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2286d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2287d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2288d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2289d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2290d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 2291d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 22923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 2295d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 22963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: break; // Default behavior, ignore unknown content. 22973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 22983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 22993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2300d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 23013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Triple = S; 23023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 23033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 23063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 23083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2309d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseTriple(std::string &Triple) { 2310d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = InitStream()) 2311d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 23123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Sniff for the signature. 23143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.Read(8) != 'B' || 23153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(8) != 'C' || 23163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0x0 || 23173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xC || 23183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xE || 23193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xD) 2320d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 23213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // We expect a number of well-defined blocks, though we don't necessarily 23233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // need to understand them all. 2324d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2325d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advance(); 23263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2327d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2328d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2329d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2330d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2331d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 23323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2333d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: 2334d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Entry.ID == bitc::MODULE_BLOCK_ID) 2335d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return ParseModuleTriple(Triple); 23363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2337d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Ignore other sub-blocks. 2338d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Stream.SkipBlock()) 2339d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2340d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 2341d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2342d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2343d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.skipRecord(Entry.ID); 2344d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 23453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 23483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ParseMetadataAttachment - Parse metadata attachments. 2350d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseMetadataAttachment() { 23513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) 2352d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 23533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 2355d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2356d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 2357d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2358d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2359d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 2360d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2361d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2362d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2363d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2364d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2365d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 23663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 23673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 2368d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 23693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a metadata attachment record. 23703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 2371d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 23723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: ignore. 23733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 23743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_ATTACHMENT: { 23753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned RecordLength = Record.size(); 23763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty() || (RecordLength - 1) % 2 == 1) 2377d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 23783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Instruction *Inst = InstructionList[Record[0]]; 23793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1; i != RecordLength; i = i+2) { 23803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Kind = Record[i]; 23813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DenseMap<unsigned, unsigned>::iterator I = 23823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDKindMap.find(Kind); 23833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I == MDKindMap.end()) 2384d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 23853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Node = MDValueList.getValueFwdRef(Record[i+1]); 23863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Inst->setMetadata(I->second, cast<MDNode>(Node)); 23873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 23893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 23933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ParseFunctionBody - Lazily parse the specified function body block. 2395d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseFunctionBody(Function *F) { 23963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) 2397d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 23983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.clear(); 24003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ModuleValueListSize = ValueList.size(); 24013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ModuleMDValueListSize = MDValueList.size(); 24023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Add all the function arguments to the value table. 24043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) 24053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.push_back(I); 24063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NextValueNo = ValueList.size(); 24083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *CurBB = 0; 24093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned CurBBNo = 0; 24103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DebugLoc LastLoc; 2412c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 24133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records. 24143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 24153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 24163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 24173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 24183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 2419d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 24203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 24243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Stream.ReadSubBlockID()) { 24253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Skip unknown content. 24263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 2427d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 24283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CONSTANTS_BLOCK_ID: 2430d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseConstants()) 2431d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 24323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NextValueNo = ValueList.size(); 24333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::VALUE_SYMTAB_BLOCK_ID: 2435d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseValueSymbolTable()) 2436d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 24373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_ATTACHMENT_ID: 2439d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseMetadataAttachment()) 2440d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 24413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_BLOCK_ID: 2443d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseMetadata()) 2444d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 24453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 24483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 24513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 24523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 24533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 24563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 24573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Instruction *I = 0; 2458d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned BitCode = Stream.readRecord(Code, Record); 24593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (BitCode) { 24603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: reject 2461d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 24623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks] 24633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1 || Record[0] == 0) 2464d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 24653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Create all the basic blocks for the function. 24663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionBBs.resize(Record[0]); 24673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) 24683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionBBs[i] = BasicBlock::Create(Context, "", F); 24693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CurBB = FunctionBBs[0]; 24703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 2471c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 24723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN 24733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // This record indicates that the last instruction is at the same 24743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // location as the previous instruction with a location. 24753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = 0; 2476c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 24773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Get the last instruction emitted. 24783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CurBB && !CurBB->empty()) 24793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = &CurBB->back(); 24803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (CurBBNo && FunctionBBs[CurBBNo-1] && 24813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien !FunctionBBs[CurBBNo-1]->empty()) 24823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = &FunctionBBs[CurBBNo-1]->back(); 2483c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 2484d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (I == 0) 2485d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 24863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I->setDebugLoc(LastLoc); 24873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = 0; 24883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 2489c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 24903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia] 24913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = 0; // Get the last instruction emitted. 24923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CurBB && !CurBB->empty()) 24933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = &CurBB->back(); 24943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (CurBBNo && FunctionBBs[CurBBNo-1] && 24953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien !FunctionBBs[CurBBNo-1]->empty()) 24963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = &FunctionBBs[CurBBNo-1]->back(); 24973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I == 0 || Record.size() < 4) 2498d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2499c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 25003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Line = Record[0], Col = Record[1]; 25013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ScopeID = Record[2], IAID = Record[3]; 2502c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 25033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDNode *Scope = 0, *IA = 0; 25043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ScopeID) Scope = cast<MDNode>(MDValueList.getValueFwdRef(ScopeID-1)); 25053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (IAID) IA = cast<MDNode>(MDValueList.getValueFwdRef(IAID-1)); 25063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LastLoc = DebugLoc::get(Line, Col, Scope, IA); 25073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I->setDebugLoc(LastLoc); 25083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = 0; 25093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 25103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode] 25133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 25143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *LHS, *RHS; 25153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 25163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, LHS->getType(), RHS) || 25173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+1 > Record.size()) 2518d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 25193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); 2521d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Opc == -1) 2522d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 25233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); 25243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 25253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpNum < Record.size()) { 25263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc == Instruction::Add || 25273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Sub || 25283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Mul || 25293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Shl) { 25303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 25313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<BinaryOperator>(I)->setHasNoSignedWrap(true); 25323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 25333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true); 25343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (Opc == Instruction::SDiv || 25353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::UDiv || 25363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::LShr || 25373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::AShr) { 25383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[OpNum] & (1 << bitc::PEO_EXACT)) 25393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<BinaryOperator>(I)->setIsExact(true); 25403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 25433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc] 25453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 25463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 25473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 25483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+2 != Record.size()) 2549d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 25503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ResTy = getTypeByID(Record[OpNum]); 25523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien int Opc = GetDecodedCastOpcode(Record[OpNum+1]); 25533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc == -1 || ResTy == 0) 2554d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 25553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy); 25563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 25573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 25583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INBOUNDS_GEP: 25603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands] 25613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 25623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *BasePtr; 25633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) 2564d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 25653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Value*, 16> GEPIdx; 25673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (OpNum != Record.size()) { 25683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 25693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2570d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 25713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GEPIdx.push_back(Op); 25723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = GetElementPtrInst::Create(BasePtr, GEPIdx); 25753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 25763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP) 25773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<GetElementPtrInst>(I)->setIsInBounds(true); 25783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 25793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_EXTRACTVAL: { 25823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // EXTRACTVAL: [opty, opval, n x indices] 25833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 25843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Agg; 25853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2586d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 25873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<unsigned, 4> EXTRACTVALIdx; 25893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned RecSize = Record.size(); 25903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum != RecSize; ++OpNum) { 25913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien uint64_t Index = Record[OpNum]; 25923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((unsigned)Index != Index) 2593d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 25943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien EXTRACTVALIdx.push_back((unsigned)Index); 25953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ExtractValueInst::Create(Agg, EXTRACTVALIdx); 25983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 25993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INSERTVAL: { 26033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // INSERTVAL: [opty, opval, opty, opval, n x indices] 26043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Agg; 26063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2607d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 26083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Val; 26093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Val)) 2610d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 26113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<unsigned, 4> INSERTVALIdx; 26133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned RecSize = Record.size(); 26143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum != RecSize; ++OpNum) { 26153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien uint64_t Index = Record[OpNum]; 26163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((unsigned)Index != Index) 2617d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 26183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien INSERTVALIdx.push_back((unsigned)Index); 26193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = InsertValueInst::Create(Agg, Val, INSERTVALIdx); 26223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval] 26273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // obsolete form of select 26283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // handles select i1 ... in old bitcode 26293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *TrueVal, *FalseVal, *Cond; 26313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 26323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 26333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, Type::getInt1Ty(Context), Cond)) 2634d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 26353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = SelectInst::Create(Cond, TrueVal, FalseVal); 26373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred] 26423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // new form of select 26433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // handles select i1 or select [N x i1] 26443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *TrueVal, *FalseVal, *Cond; 26463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 26473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 26483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValueTypePair(Record, OpNum, NextValueNo, Cond)) 2649d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 26503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // select condition can be either i1 or [N x i1] 26523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (VectorType* vector_type = 26533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast<VectorType>(Cond->getType())) { 26543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // expect <n x i1> 26553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (vector_type->getElementType() != Type::getInt1Ty(Context)) 2656d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 26573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 26583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // expect i1 26593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Cond->getType() != Type::getInt1Ty(Context)) 2660d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 26613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = SelectInst::Create(Cond, TrueVal, FalseVal); 26643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval] 26693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Vec, *Idx; 26713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 26723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 2673d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 26743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ExtractElementInst::Create(Vec, Idx); 26753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval] 26803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Vec, *Elt, *Idx; 26823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 26833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 26843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<VectorType>(Vec->getType())->getElementType(), Elt) || 26853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 2686d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 26873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = InsertElementInst::Create(Vec, Elt, Idx); 26883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval] 26933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Vec1, *Vec2, *Mask; 26953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) || 26963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, Vec1->getType(), Vec2)) 2697d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 26983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) 2700d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new ShuffleVectorInst(Vec1, Vec2, Mask); 27023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred] 27073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Old form of ICmp/FCmp returning bool 27083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were 27093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // both legal on vectors but had different behaviour. 27103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred] 27113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FCmp/ICmp returning bool or vector of bool 27123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 27143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *LHS, *RHS; 27153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 27163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, LHS->getType(), RHS) || 27173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+1 != Record.size()) 2718d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (LHS->getType()->isFPOrFPVectorTy()) 27213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); 27223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 27233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS); 27243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>] 27293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien { 27303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 27313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Size == 0) { 27323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ReturnInst::Create(Context); 27333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 27383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op = NULL; 27393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2740d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpNum != Record.size()) 2742d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ReturnInst::Create(Context, Op); 27453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] 27493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() != 1 && Record.size() != 3) 2750d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *TrueDest = getBasicBlock(Record[0]); 27523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (TrueDest == 0) 2753d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() == 1) { 27563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = BranchInst::Create(TrueDest); 27573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else { 27603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *FalseDest = getBasicBlock(Record[1]); 27613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Cond = getFnValueByID(Record[2], Type::getInt1Ty(Context)); 27623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (FalseDest == 0 || Cond == 0) 2763d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = BranchInst::Create(TrueDest, FalseDest, Cond); 27653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...] 27703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3 || (Record.size() & 1) == 0) 2771d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[0]); 27733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Cond = getFnValueByID(Record[1], OpTy); 27743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *Default = getBasicBlock(Record[2]); 27753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpTy == 0 || Cond == 0 || Default == 0) 2776d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumCases = (Record.size()-3)/2; 27783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); 27793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(SI); 27803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = NumCases; i != e; ++i) { 27813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ConstantInt *CaseVal = 27823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy)); 27833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); 27843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CaseVal == 0 || DestBB == 0) { 27853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete SI; 2786d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SI->addCase(CaseVal, DestBB); 27893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = SI; 27913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] 27943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 2795d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[0]); 27973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Address = getFnValueByID(Record[1], OpTy); 27983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpTy == 0 || Address == 0) 2799d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 28003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumDests = Record.size()-2; 28013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); 28023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(IBI); 28033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = NumDests; i != e; ++i) { 28043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) { 28053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien IBI->addDestination(DestBB); 28063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 28073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete IBI; 2808d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 28093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = IBI; 28123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 28133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 2814c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 28153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INVOKE: { 28163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] 2817d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 4) 2818d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2819b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines AttributeSet PAL = getAttributes(Record[0]); 28203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned CCInfo = Record[1]; 28213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *NormalBB = getBasicBlock(Record[2]); 28223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *UnwindBB = getBasicBlock(Record[3]); 28233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 4; 28253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Callee; 28263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 2827d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 28283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); 28303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionType *FTy = !CalleeTy ? 0 : 28313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast<FunctionType>(CalleeTy->getElementType()); 28323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check that the right number of fixed parameters are here. 28343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (FTy == 0 || NormalBB == 0 || UnwindBB == 0 || 28353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.size() < OpNum+FTy->getNumParams()) 2836d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 28373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Value*, 16> Ops; 28393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 28403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ops.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 2841d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Ops.back() == 0) 2842d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 28433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!FTy->isVarArg()) { 28463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() != OpNum) 2847d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 28483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 28493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read type/value pairs for varargs params. 28503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (OpNum != Record.size()) { 28513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 28523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2853d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 28543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ops.push_back(Op); 28553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops); 28593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 28603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<InvokeInst>(I)->setCallingConv( 28613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien static_cast<CallingConv::ID>(CCInfo)); 28623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<InvokeInst>(I)->setAttributes(PAL); 28633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 28643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_RESUME: { // RESUME: [opval] 28663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Idx = 0; 28673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Val = 0; 28683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, Idx, NextValueNo, Val)) 2869d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 28703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ResumeInst::Create(Val); 28713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 28723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 28733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 2874c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao case FUNC_CODE_INST_UNWIND_2_7: { // UNWIND_OLD 2875c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao // 'unwind' instruction has been removed in LLVM 3.1 2876c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao // Replace 'unwind' with 'landingpad' and 'resume'. 2877c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Type *ExnTy = StructType::get(Type::getInt8PtrTy(Context), 2878c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Type::getInt32Ty(Context), NULL); 2879c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Constant *PersFn = 2880c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao F->getParent()-> 2881c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao getOrInsertFunction("__gcc_personality_v0", 2882c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao FunctionType::get(Type::getInt32Ty(Context), true)); 2883c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 2884c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao LandingPadInst *LP = LandingPadInst::Create(ExnTy, PersFn, 1); 2885c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao LP->setCleanup(true); 2886c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 2887c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao CurBB->getInstList().push_back(LP); 2888c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao I = ResumeInst::Create(LP); 28893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 28903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 2891c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao } 28923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE 28933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new UnreachableInst(Context); 28943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 28953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 28963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...] 28973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1 || ((Record.size()-1)&1)) 2898d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 28993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[0]); 2900d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 2901d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2); 29043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(PN); 29053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) { 29073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = getFnValueByID(Record[1+i], Ty); 29083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *BB = getBasicBlock(Record[2+i]); 2909d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!V || !BB) 2910d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PN->addIncoming(V, BB); 29123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = PN; 29143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 29153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_LANDINGPAD: { 29183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?] 29193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Idx = 0; 29203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 4) 2921d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[Idx++]); 2923d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 2924d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *PersFn = 0; 29263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, Idx, NextValueNo, PersFn)) 2927d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool IsCleanup = !!Record[Idx++]; 29303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumClauses = Record[Idx++]; 29313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LandingPadInst *LP = LandingPadInst::Create(Ty, PersFn, NumClauses); 29323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LP->setCleanup(IsCleanup); 29333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned J = 0; J != NumClauses; ++J) { 29343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LandingPadInst::ClauseType CT = 29353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LandingPadInst::ClauseType(Record[Idx++]); (void)CT; 29363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Val; 29373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, Idx, NextValueNo, Val)) { 29393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete LP; 2940d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert((CT != LandingPadInst::Catch || 29443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien !isa<ArrayType>(Val->getType())) && 29453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien "Catch clause has a invalid type!"); 29463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert((CT != LandingPadInst::Filter || 29473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien isa<ArrayType>(Val->getType())) && 29483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien "Filter clause has invalid type!"); 29493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LP->addClause(Val); 29503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = LP; 29533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 29543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 29553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align] 29583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() != 4) 2959d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PointerType *Ty = 29613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<PointerType>(getTypeByID(Record[0])); 29623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[1]); 29633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Size = getFnValueByID(Record[2], OpTy); 29643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Align = Record[3]; 2965d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty || !Size) 2966d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); 29683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 29693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 29703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol] 29723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 29733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 29743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 29753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+2 != Record.size()) 2976d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); 29793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 29803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 29813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_LOADATOMIC: { 29833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // LOADATOMIC: [opty, op, align, vol, ordering, synchscope] 29843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 29853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 29863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 29873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+4 != Record.size()) 2988d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2989c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 29903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); 29923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Release || 29933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering == AcquireRelease) 2994d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering != NotAtomic && Record[OpNum] == 0) 2996d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); 29983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1, 30003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering, SynchScope); 30013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_STORE: { // STORE2:[ptrty, ptr, val, align, vol] 30053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 30063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Val, *Ptr; 30073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 30083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), Val) || 30103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+2 != Record.size()) 3011d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 30133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 30143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_STOREATOMIC: { 30183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // STOREATOMIC: [ptrty, ptr, val, align, vol, ordering, synchscope] 30193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 30203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Val, *Ptr; 30213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 30223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), Val) || 30243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+4 != Record.size()) 3025d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 30273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); 30283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Acquire || 30293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering == AcquireRelease) 3030d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); 30323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering != NotAtomic && Record[OpNum] == 0) 3033d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 30353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1, 30363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering, SynchScope); 30373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CMPXCHG: { 30413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // CMPXCHG:[ptrty, ptr, cmp, new, vol, ordering, synchscope] 30423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 30433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Ptr, *Cmp, *New; 30443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 30453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), Cmp) || 30473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), New) || 30493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+3 != Record.size()) 3050d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+1]); 30523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Unordered) 3053d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+2]); 30553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new AtomicCmpXchgInst(Ptr, Cmp, New, Ordering, SynchScope); 30563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]); 30573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_ATOMICRMW: { 30613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // ATOMICRMW:[ptrty, ptr, val, op, vol, ordering, synchscope] 30623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 30633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Ptr, *Val; 30643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 30653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), Val) || 30673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+4 != Record.size()) 3068d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicRMWInst::BinOp Operation = GetDecodedRMWOperation(Record[OpNum]); 30703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Operation < AtomicRMWInst::FIRST_BINOP || 30713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Operation > AtomicRMWInst::LAST_BINOP) 3072d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); 30743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Unordered) 3075d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); 30773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SynchScope); 30783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]); 30793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, synchscope] 30833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (2 != Record.size()) 3084d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[0]); 30863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Unordered || 30873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering == Monotonic) 3088d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[1]); 30903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new FenceInst(Context, Ordering, SynchScope); 30913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CALL: { 30953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] 30963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 3097d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3099b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines AttributeSet PAL = getAttributes(Record[0]); 31003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned CCInfo = Record[1]; 31013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 2; 31033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Callee; 31043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 3105d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 31063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); 31083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionType *FTy = 0; 31093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType()); 31103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!FTy || Record.size() < FTy->getNumParams()+OpNum) 3111d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 31123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Value*, 16> Args; 31143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read the fixed params. 31153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 31163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (FTy->getParamType(i)->isLabelTy()) 31173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Args.push_back(getBasicBlock(Record[OpNum])); 31183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 31193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Args.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 3120d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Args.back() == 0) 3121d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 31223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read type/value pairs for varargs params. 31253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!FTy->isVarArg()) { 31263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpNum != Record.size()) 3127d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 31283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 31293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (OpNum != Record.size()) { 31303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 31313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 3132d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 31333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Args.push_back(Op); 31343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = CallInst::Create(Callee, Args); 31383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 31393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<CallInst>(I)->setCallingConv( 31403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien static_cast<CallingConv::ID>(CCInfo>>1)); 31413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<CallInst>(I)->setTailCall(CCInfo & 1); 31423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<CallInst>(I)->setAttributes(PAL); 31433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 31443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] 31463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 3147d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 31483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[0]); 31493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op = getFnValueByID(Record[1], OpTy); 31503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ResTy = getTypeByID(Record[2]); 31513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!OpTy || !Op || !ResTy) 3152d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 31533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new VAArgInst(Op, ResTy); 31543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 31553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 31563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Add instruction to end of current BB. If there is no current BB, reject 31603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // this file. 31613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CurBB == 0) { 31623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete I; 3163d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidInstructionWithNoBB); 31643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CurBB->getInstList().push_back(I); 31663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If this was a terminator instruction, move to the next block. 31683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (isa<TerminatorInst>(I)) { 31693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ++CurBBNo; 31703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0; 31713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Non-void values get registered in the value table for future use. 31743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I && !I->getType()->isVoidTy()) 31753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.AssignValue(I, NextValueNo++); 31763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check the function list for unresolved values. 31793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Argument *A = dyn_cast<Argument>(ValueList.back())) { 31803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (A->getParent() == 0) { 31813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // We found at least one unresolved value. Nuke them all to avoid leaks. 31823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){ 31833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((A = dyn_cast<Argument>(ValueList[i])) && A->getParent() == 0) { 31843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien A->replaceAllUsesWith(UndefValue::get(A->getType())); 31853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete A; 31863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 3188d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(NeverResolvedValueFoundInFunction); 31893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FIXME: Check for unresolved forward-declared metadata references 31933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // and clean up leaks. 31943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // See if anything took the address of blocks in this function. If so, 31963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // resolve them now. 31973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DenseMap<Function*, std::vector<BlockAddrRefTy> >::iterator BAFRI = 31983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BlockAddrFwdRefs.find(F); 31993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BAFRI != BlockAddrFwdRefs.end()) { 32003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<BlockAddrRefTy> &RefList = BAFRI->second; 32013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = RefList.size(); i != e; ++i) { 32023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned BlockIdx = RefList[i].first; 32033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BlockIdx >= FunctionBBs.size()) 3204d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 3205c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 32063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalVariable *FwdRef = RefList[i].second; 32073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx])); 32083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FwdRef->eraseFromParent(); 32093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 3210c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 32113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BlockAddrFwdRefs.erase(BAFRI); 32123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 3213c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 32143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Trim the value list down to the size it was before we parsed this function. 32153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.shrinkTo(ModuleValueListSize); 32163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValueList.shrinkTo(ModuleMDValueListSize); 32173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<BasicBlock*>().swap(FunctionBBs); 3218d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 32193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 32203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 32223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// GVMaterializer implementation 32233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 32243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::isMaterializable(const GlobalValue *GV) const { 32273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (const Function *F = dyn_cast<Function>(GV)) { 32283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return F->isDeclaration() && 32293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DeferredFunctionInfo.count(const_cast<Function*>(F)); 32303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 32323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 32333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3234d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::Materialize(GlobalValue *GV) { 32353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *F = dyn_cast<Function>(GV); 32363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If it's not a function or is already material, ignore the request. 3237d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!F || !F->isMaterializable()) 3238d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 32393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F); 32413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!"); 32423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Move the bit stream to the saved position of the deferred function body. 32443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.JumpToBit(DFII->second); 32453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3246d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseFunctionBody(F)) 3247d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 32483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Upgrade any old intrinsic calls in the function. 32503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(), 32513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien E = UpgradedIntrinsics.end(); I != E; ++I) { 32523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I->first != I->second) { 32533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (Value::use_iterator UI = I->first->use_begin(), 32543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UE = I->first->use_end(); UI != UE; ) { 32553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 32563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UpgradeIntrinsicCall(CI, I->second); 32573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3261d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 32623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 32633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::isDematerializable(const GlobalValue *GV) const { 32653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien const Function *F = dyn_cast<Function>(GV); 32663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!F || F->isDeclaration()) 32673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 32683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return DeferredFunctionInfo.count(const_cast<Function*>(F)); 32693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 32703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReader::Dematerialize(GlobalValue *GV) { 32723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *F = dyn_cast<Function>(GV); 32733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If this function isn't dematerializable, this is a noop. 32743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!F || !isDematerializable(F)) 32753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 32763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(DeferredFunctionInfo.count(F) && "No info to read function later?"); 32783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Just forget the function body, we can remat it later. 32803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien F->deleteBody(); 32813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 32823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3284d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::MaterializeModule(Module *M) { 32853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(M == TheModule && 32863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien "Can only Materialize the Module this BitcodeReader is attached to."); 32873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Iterate over the module, deserializing any functions that are still on 32883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // disk. 32893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (Module::iterator F = TheModule->begin(), E = TheModule->end(); 3290d724d097437f40a5689464429f948ec41e4a2415Stephen Hines F != E; ++F) { 3291d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (F->isMaterializable()) { 3292d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = Materialize(F)) 3293d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 3294d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3295d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 32963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Upgrade any intrinsic calls that slipped through (should not happen!) and 32983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // delete the old functions to clean up. We can't do this unless the entire 32993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // module is materialized because there could always be another function body 33003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // with calls to the old function. 33013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (std::vector<std::pair<Function*, Function*> >::iterator I = 33023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) { 33033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I->first != I->second) { 33043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (Value::use_iterator UI = I->first->use_begin(), 33053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UE = I->first->use_end(); UI != UE; ) { 33063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 33073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UpgradeIntrinsicCall(CI, I->second); 33083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 33093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!I->first->use_empty()) 33103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I->first->replaceAllUsesWith(I->second); 33113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I->first->eraseFromParent(); 33123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 33133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 33143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics); 33153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Upgrade to new EH scheme. N.B. This will go away in 3.1. 33173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UpgradeExceptionHandling(M); 33183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check debug info intrinsics. 33203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CheckDebugInfoIntrinsics(TheModule); 33213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3322d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 33233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 33243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3325d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::InitStream() { 3326d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (LazyStreamer) 3327d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return InitLazyStream(); 3328d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return InitStreamFromBuffer(); 3329d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 3330d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3331d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::InitStreamFromBuffer() { 3332d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *BufPtr = (const unsigned char*)Buffer->getBufferStart(); 3333d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); 3334d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3335d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Buffer->getBufferSize() & 3) { 3336d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isRawBitcode(BufPtr, BufEnd) && !isBitcodeWrapper(BufPtr, BufEnd)) 3337d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 3338d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else 3339d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(BitcodeStreamInvalidSize); 3340d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 3341d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3342d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // If we have a wrapper header, parse it and ignore the non-bc file contents. 3343d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The magic number is 0x0B17C0DE stored in little endian. 3344d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (isBitcodeWrapper(BufPtr, BufEnd)) 3345d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true)) 3346d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeWrapperHeader); 3347d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3348d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamFile.reset(new BitstreamReader(BufPtr, BufEnd)); 3349d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.init(*StreamFile); 3350d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3351d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 3352d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 3353d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3354d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::InitLazyStream() { 3355d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Check and strip off the bitcode wrapper; BitstreamReader expects never to 3356d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // see it. 3357d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamingMemoryObject *Bytes = new StreamingMemoryObject(LazyStreamer); 3358d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamFile.reset(new BitstreamReader(Bytes)); 3359d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.init(*StreamFile); 3360d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3361d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned char buf[16]; 336288f8c52abea50f411c3774c935a6a1e04d17c182Stephen Hines if (Bytes->readBytes(0, 16, buf) == -1) 3363d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(BitcodeStreamInvalidSize); 3364d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3365d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isBitcode(buf, buf + 16)) 3366d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 3367d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3368d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (isBitcodeWrapper(buf, buf + 4)) { 3369d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *bitcodeStart = buf; 3370d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *bitcodeEnd = buf + 16; 3371d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false); 3372d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Bytes->dropLeadingBytes(bitcodeStart - buf); 3373d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Bytes->setKnownObjectSize(bitcodeEnd - bitcodeStart); 3374d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 3375d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 3376d724d097437f40a5689464429f948ec41e4a2415Stephen Hines} 3377d724d097437f40a5689464429f948ec41e4a2415Stephen Hines 3378d724d097437f40a5689464429f948ec41e4a2415Stephen Hinesnamespace { 3379d724d097437f40a5689464429f948ec41e4a2415Stephen Hinesclass BitcodeErrorCategoryType : public _do_message { 3380d724d097437f40a5689464429f948ec41e4a2415Stephen Hines const char *name() const LLVM_OVERRIDE { 3381d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "llvm.bitcode"; 3382d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3383d724d097437f40a5689464429f948ec41e4a2415Stephen Hines std::string message(int IE) const LLVM_OVERRIDE { 3384d724d097437f40a5689464429f948ec41e4a2415Stephen Hines BitcodeReader::ErrorType E = static_cast<BitcodeReader::ErrorType>(IE); 3385d724d097437f40a5689464429f948ec41e4a2415Stephen Hines switch (E) { 3386d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::BitcodeStreamInvalidSize: 3387d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Bitcode stream length should be >= 16 bytes and a multiple of 4"; 3388d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::ConflictingMETADATA_KINDRecords: 3389d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Conflicting METADATA_KIND records"; 3390d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::CouldNotFindFunctionInStream: 3391d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Could not find function in stream"; 3392d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::ExpectedConstant: 3393d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Expected a constant"; 3394d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InsufficientFunctionProtos: 3395d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Insufficient function protos"; 3396d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidBitcodeSignature: 3397d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid bitcode signature"; 3398d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidBitcodeWrapperHeader: 3399d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid bitcode wrapper header"; 3400d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidConstantReference: 3401d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid ronstant reference"; 3402d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidID: 3403d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid ID"; 3404d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidInstructionWithNoBB: 3405d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid instruction with no BB"; 3406d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidRecord: 3407d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid record"; 3408d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidTypeForValue: 3409d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid type for value"; 3410d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidTYPETable: 3411d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid TYPE table"; 3412d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidType: 3413d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid type"; 3414d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::MalformedBlock: 3415d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Malformed block"; 3416d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::MalformedGlobalInitializerSet: 3417d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Malformed global initializer set"; 3418d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidMultipleBlocks: 3419d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid multiple blocks"; 3420d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::NeverResolvedValueFoundInFunction: 3421d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Never resolved value found in function"; 3422d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidValue: 3423d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid value"; 3424d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3425d724d097437f40a5689464429f948ec41e4a2415Stephen Hines llvm_unreachable("Unknown error type!"); 3426d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3427d724d097437f40a5689464429f948ec41e4a2415Stephen Hines}; 3428d724d097437f40a5689464429f948ec41e4a2415Stephen Hines} 3429d724d097437f40a5689464429f948ec41e4a2415Stephen Hines 3430d724d097437f40a5689464429f948ec41e4a2415Stephen Hinesconst error_category &BitcodeReader::BitcodeErrorCategory() { 3431d724d097437f40a5689464429f948ec41e4a2415Stephen Hines static BitcodeErrorCategoryType O; 3432d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return O; 3433d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 34343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 34363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// External interface 34373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 34383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// getLazyBitcodeModule - lazy function-at-a-time loading from a file. 34403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// 3441c7d67a701663191bcdab2416c11b69fae16d49fbLogan ChienModule *llvm_3_0::getLazyBitcodeModule(MemoryBuffer *Buffer, 3442c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LLVMContext& Context, 3443c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien std::string *ErrMsg) { 34443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Module *M = new Module(Buffer->getBufferIdentifier(), Context); 34453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BitcodeReader *R = new BitcodeReader(Buffer, Context); 34463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien M->setMaterializer(R); 3447d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = R->ParseBitcodeInto(M)) { 34483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ErrMsg) 3449d724d097437f40a5689464429f948ec41e4a2415Stephen Hines *ErrMsg = EC.message(); 34503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete M; // Also deletes R. 34523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return 0; 34533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 34543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Have the BitcodeReader dtor delete 'Buffer'. 34553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien R->setBufferOwned(true); 34563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return M; 34573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 34583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ParseBitcodeFile - Read the specified bitcode file, returning the module. 34603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// If an error occurs, return null and fill in *ErrMsg if non-null. 3461c7d67a701663191bcdab2416c11b69fae16d49fbLogan ChienModule *llvm_3_0::ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext& Context, 3462c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien std::string *ErrMsg){ 3463c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Module *M = llvm_3_0::getLazyBitcodeModule(Buffer, Context, ErrMsg); 34643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!M) return 0; 34653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether 34673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // there was an error. 34683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien static_cast<BitcodeReader*>(M->getMaterializer())->setBufferOwned(false); 34693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read in the entire module, and destroy the BitcodeReader. 34713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (M->MaterializeAllPermanently(ErrMsg)) { 34723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete M; 34733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return 0; 34743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 34753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return M; 34773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 34783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3479c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chienstd::string llvm_3_0::getBitcodeTargetTriple(MemoryBuffer *Buffer, 3480c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LLVMContext& Context, 3481c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien std::string *ErrMsg) { 34823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BitcodeReader *R = new BitcodeReader(Buffer, Context); 34833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Don't let the BitcodeReader dtor delete 'Buffer'. 34843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien R->setBufferOwned(false); 34853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string Triple(""); 3487d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = R->ParseTriple(Triple)) 34883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ErrMsg) 3489d724d097437f40a5689464429f948ec41e4a2415Stephen Hines *ErrMsg = EC.message(); 34903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete R; 34923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Triple; 34933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3494