BitcodeReader.cpp revision c2074caf075818abb6d3689ad924ca09f4a5ba1f
13bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===- BitcodeReader.cpp - Internal BitcodeReader implementation ----------===// 23bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// 33bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// The LLVM Compiler Infrastructure 43bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// 53bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// This file is distributed under the University of Illinois Open Source 63bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// License. See LICENSE.TXT for details. 73bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// 83bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 93bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// 103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// This header defines the BitcodeReader class. 113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// 123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/Bitcode/ReaderWriter.h" 153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "BitcodeReader.h" 16c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien#include "BitReader_3_0.h" 173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/ADT/SmallString.h" 183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/ADT/SmallVector.h" 19c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray#include "llvm/IR/AutoUpgrade.h" 20c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray#include "llvm/IR/CFG.h" 21b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/Constants.h" 22b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/DerivedTypes.h" 23b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/InlineAsm.h" 24b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/IntrinsicInst.h" 25b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/IRBuilder.h" 26b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/Module.h" 27b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/OperandTraits.h" 28b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/IR/Operator.h" 29b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines#include "llvm/ADT/SmallPtrSet.h" 303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/Support/MathExtras.h" 313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/Support/MemoryBuffer.h" 323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienusing namespace llvm; 33c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chienusing namespace llvm_3_0; 34c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 35c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao#define FUNC_CODE_INST_UNWIND_2_7 14 36c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao#define eh_exception_2_7 145 37c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao#define eh_selector_2_7 149 38c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 39c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien#define TYPE_BLOCK_ID_OLD_3_0 10 40c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien#define TYPE_SYMTAB_BLOCK_ID_OLD_3_0 13 41c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien#define TYPE_CODE_STRUCT_OLD_3_0 10 42c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 43c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chiennamespace { 44c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien void FindExnAndSelIntrinsics(BasicBlock *BB, CallInst *&Exn, 45c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *&Sel, 46c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien SmallPtrSet<BasicBlock*, 8> &Visited) { 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()) { 269c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray CallInst *Resume = cast<CallInst>(*EHResume->use_begin()); 270c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BasicBlock *BB = Resume->getParent(); 271c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 272c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien IRBuilder<> Builder(Context); 273c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Builder.SetInsertPoint(BB, Resume); 274c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 275c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Value *LPadVal = 276c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Builder.CreateInsertValue(UndefValue::get(LPadSlotTy), 277c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Resume->getArgOperand(0), 0, "lpad.val"); 278c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LPadVal = Builder.CreateInsertValue(LPadVal, Resume->getArgOperand(1), 279c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 1, "lpad.val"); 280c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Builder.CreateResume(LPadVal); 281c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 282c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // Remove all instructions after the 'resume.' 283c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BasicBlock::iterator I = Resume; 284c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien while (I != BB->end()) { 285c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Instruction *Inst = &*I++; 286c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Inst->eraseFromParent(); 287c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 288c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 289c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 290c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 291c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 292c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray void StripDebugInfoOfFunction(Module* M, const char* name) { 293c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray if (Function* FuncStart = M->getFunction(name)) { 294c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray while (!FuncStart->use_empty()) { 295c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray cast<CallInst>(*FuncStart->use_begin())->eraseFromParent(); 296c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray } 297c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray FuncStart->eraseFromParent(); 298c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray } 299c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray } 300c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray 301c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// This function strips all debug info intrinsics, except for llvm.dbg.declare. 302c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// If an llvm.dbg.declare intrinsic is invalid, then this function simply 303c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// strips that use. 304c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien void CheckDebugInfoIntrinsics(Module *M) { 305c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray StripDebugInfoOfFunction(M, "llvm.dbg.func.start"); 306c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray StripDebugInfoOfFunction(M, "llvm.dbg.stoppoint"); 307c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray StripDebugInfoOfFunction(M, "llvm.dbg.region.start"); 308c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray StripDebugInfoOfFunction(M, "llvm.dbg.region.end"); 309c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 310c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Function *Declare = M->getFunction("llvm.dbg.declare")) { 311c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!Declare->use_empty()) { 312c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray DbgDeclareInst *DDI = cast<DbgDeclareInst>(*Declare->use_begin()); 313c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!isa<MDNode>(DDI->getArgOperand(0)) || 314c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien !isa<MDNode>(DDI->getArgOperand(1))) { 315c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien while (!Declare->use_empty()) { 316c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray CallInst *CI = cast<CallInst>(*Declare->use_begin()); 317c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CI->eraseFromParent(); 318c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 319c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Declare->eraseFromParent(); 320c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 321c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 322c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 323c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 324c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien} // end anonymous namespace 3253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReader::FreeState() { 3273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BufferOwned) 3283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete Buffer; 3293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Buffer = 0; 3303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Type*>().swap(TypeList); 3313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.clear(); 3323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValueList.clear(); 3333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 334b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines std::vector<AttributeSet>().swap(MAttributes); 3353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<BasicBlock*>().swap(FunctionBBs); 3363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Function*>().swap(FunctionsWithBodies); 3373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DeferredFunctionInfo.clear(); 3383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDKindMap.clear(); 3393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 3423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// Helper functions to implement forward reference resolution, etc. 3433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 3443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ConvertToString - Convert a string from a record into an std::string, return 3463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// true on failure. 3473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chientemplate<typename StrTy> 3483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic bool ConvertToString(SmallVector<uint64_t, 64> &Record, unsigned Idx, 3493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien StrTy &Result) { 3503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx > Record.size()) 3513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return true; 3523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = Idx, e = Record.size(); i != e; ++i) 3543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Result += (char)Record[i]; 3553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 3563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) { 3593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 3603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Map unknown/new linkages to external 3613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 0: return GlobalValue::ExternalLinkage; 3623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 1: return GlobalValue::WeakAnyLinkage; 3633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 2: return GlobalValue::AppendingLinkage; 3643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 3: return GlobalValue::InternalLinkage; 3653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 4: return GlobalValue::LinkOnceAnyLinkage; 366c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray case 5: return GlobalValue::ExternalLinkage; // Was DLLImportLinkage; 367c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray case 6: return GlobalValue::ExternalLinkage; // Was DLLExportLinkage; 3683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 7: return GlobalValue::ExternalWeakLinkage; 3693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 8: return GlobalValue::CommonLinkage; 3703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 9: return GlobalValue::PrivateLinkage; 3713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 10: return GlobalValue::WeakODRLinkage; 3723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 11: return GlobalValue::LinkOnceODRLinkage; 3733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 12: return GlobalValue::AvailableExternallyLinkage; 374c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray case 13: return GlobalValue::PrivateLinkage; // Was LinkerPrivateLinkage; 375c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray case 14: return GlobalValue::ExternalWeakLinkage; // Was LinkerPrivateWeakLinkage; 376d724d097437f40a5689464429f948ec41e4a2415Stephen Hines //ANDROID: convert LinkOnceODRAutoHideLinkage -> LinkOnceODRLinkage 377d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case 15: return GlobalValue::LinkOnceODRLinkage; 3783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 3793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) { 3823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 3833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Map unknown visibilities to default. 3843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 0: return GlobalValue::DefaultVisibility; 3853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 1: return GlobalValue::HiddenVisibility; 3863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 2: return GlobalValue::ProtectedVisibility; 3873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 3883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3908b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liaostatic GlobalVariable::ThreadLocalMode GetDecodedThreadLocalMode(unsigned Val) { 3918b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao switch (Val) { 3928b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 0: return GlobalVariable::NotThreadLocal; 3938b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao default: // Map unknown non-zero value to general dynamic. 3948b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 1: return GlobalVariable::GeneralDynamicTLSModel; 3958b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 2: return GlobalVariable::LocalDynamicTLSModel; 3968b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 3: return GlobalVariable::InitialExecTLSModel; 3978b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 4: return GlobalVariable::LocalExecTLSModel; 3988b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao } 3998b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao} 4008b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao 4013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic int GetDecodedCastOpcode(unsigned Val) { 4023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: return -1; 4043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_TRUNC : return Instruction::Trunc; 4053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_ZEXT : return Instruction::ZExt; 4063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_SEXT : return Instruction::SExt; 4073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_FPTOUI : return Instruction::FPToUI; 4083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_FPTOSI : return Instruction::FPToSI; 4093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_UITOFP : return Instruction::UIToFP; 4103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_SITOFP : return Instruction::SIToFP; 4113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_FPTRUNC : return Instruction::FPTrunc; 4123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_FPEXT : return Instruction::FPExt; 4133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_PTRTOINT: return Instruction::PtrToInt; 4143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_INTTOPTR: return Instruction::IntToPtr; 4153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_BITCAST : return Instruction::BitCast; 4163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic int GetDecodedBinaryOpcode(unsigned Val, Type *Ty) { 4193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: return -1; 4213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_ADD: 4223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FAdd : Instruction::Add; 4233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_SUB: 4243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FSub : Instruction::Sub; 4253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_MUL: 4263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FMul : Instruction::Mul; 4273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_UDIV: return Instruction::UDiv; 4283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_SDIV: 4293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FDiv : Instruction::SDiv; 4303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_UREM: return Instruction::URem; 4313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_SREM: 4323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FRem : Instruction::SRem; 4333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_SHL: return Instruction::Shl; 4343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_LSHR: return Instruction::LShr; 4353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_ASHR: return Instruction::AShr; 4363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_AND: return Instruction::And; 4373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_OR: return Instruction::Or; 4383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_XOR: return Instruction::Xor; 4393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 4423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic AtomicRMWInst::BinOp GetDecodedRMWOperation(unsigned Val) { 4433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: return AtomicRMWInst::BAD_BINOP; 4453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_XCHG: return AtomicRMWInst::Xchg; 4463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_ADD: return AtomicRMWInst::Add; 4473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_SUB: return AtomicRMWInst::Sub; 4483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_AND: return AtomicRMWInst::And; 4493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_NAND: return AtomicRMWInst::Nand; 4503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_OR: return AtomicRMWInst::Or; 4513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_XOR: return AtomicRMWInst::Xor; 4523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_MAX: return AtomicRMWInst::Max; 4533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_MIN: return AtomicRMWInst::Min; 4543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_UMAX: return AtomicRMWInst::UMax; 4553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_UMIN: return AtomicRMWInst::UMin; 4563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 4593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic AtomicOrdering GetDecodedOrdering(unsigned Val) { 4603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_NOTATOMIC: return NotAtomic; 4623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_UNORDERED: return Unordered; 4633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_MONOTONIC: return Monotonic; 4643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_ACQUIRE: return Acquire; 4653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_RELEASE: return Release; 4663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_ACQREL: return AcquireRelease; 4673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Map unknown orderings to sequentially-consistent. 4683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_SEQCST: return SequentiallyConsistent; 4693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 4723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic SynchronizationScope GetDecodedSynchScope(unsigned Val) { 4733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::SYNCHSCOPE_SINGLETHREAD: return SingleThread; 4753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Map unknown scopes to cross-thread. 4763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::SYNCHSCOPE_CROSSTHREAD: return CrossThread; 4773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 4803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chiennamespace llvm { 4813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chiennamespace { 4823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// @brief A class for maintaining the slot number definition 4833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// as a placeholder for the actual definition for forward constants defs. 4843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien class ConstantPlaceHolder : public ConstantExpr { 4853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien void operator=(const ConstantPlaceHolder &); // DO NOT IMPLEMENT 4863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien public: 4873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // allocate space for exactly one operand 4883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien void *operator new(size_t s) { 4893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return User::operator new(s, 1); 4903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien explicit ConstantPlaceHolder(Type *Ty, LLVMContext& Context) 4923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) { 4933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Op<0>() = UndefValue::get(Type::getInt32Ty(Context)); 4943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 4963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// @brief Methods to support type inquiry through isa, cast, and dyn_cast. 4973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien //static inline bool classof(const ConstantPlaceHolder *) { return true; } 4983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien static bool classof(const Value *V) { 4993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return isa<ConstantExpr>(V) && 5003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1; 5013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// Provide fast operand accessors 5053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien //DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 5063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien }; 5073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// FIXME: can we inherit this from ConstantExpr? 5103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chientemplate <> 5113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstruct OperandTraits<ConstantPlaceHolder> : 5123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien public FixedNumOperandTraits<ConstantPlaceHolder, 1> { 5133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien}; 5143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) { 5183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx == size()) { 5193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien push_back(V); 5203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 5213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 5243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx+1); 5253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien WeakVH &OldV = ValuePtrs[Idx]; 5273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OldV == 0) { 5283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV = V; 5293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 5303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Handle constants and non-constants (e.g. instrs) differently for 5333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // efficiency. 5343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Constant *PHC = dyn_cast<Constant>(&*OldV)) { 5353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResolveConstants.push_back(std::make_pair(PHC, Idx)); 5363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV = V; 5373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 5383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If there was a forward reference to this value, replace it. 5393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *PrevVal = OldV; 5403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV->replaceAllUsesWith(V); 5413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete PrevVal; 5423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienConstant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, 5473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty) { 5483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 5493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx + 1); 5503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Value *V = ValuePtrs[Idx]) { 5523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(Ty == V->getType() && "Type mismatch in constant table!"); 5533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return cast<Constant>(V); 5543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Create and return a placeholder, which will later be RAUW'd. 5573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *C = new ConstantPlaceHolder(Ty, Context); 5583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValuePtrs[Idx] = C; 5593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return C; 5603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienValue *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty) { 5633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 5643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx + 1); 5653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Value *V = ValuePtrs[Idx]) { 5673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!"); 5683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V; 5693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No type specified, must be invalid reference. 5723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ty == 0) return 0; 5733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Create and return a placeholder, which will later be RAUW'd. 5753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = new Argument(Ty); 5763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValuePtrs[Idx] = V; 5773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V; 5783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ResolveConstantForwardRefs - Once all constants are read, this method bulk 5813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// resolves any forward references. The idea behind this is that we sometimes 5823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// get constants (such as large arrays) which reference *many* forward ref 5833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// constants. Replacing each of these causes a lot of thrashing when 5843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// building/reuniquing the constant. Instead of doing this, we look at all the 5853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// uses and rewrite all the place holders at once for any constant that uses 5863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// a placeholder. 5873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReaderValueList::ResolveConstantForwardRefs() { 5883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Sort the values by-pointer so that they are efficient to look up with a 5893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // binary search. 5903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::sort(ResolveConstants.begin(), ResolveConstants.end()); 5913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Constant*, 64> NewOps; 5933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!ResolveConstants.empty()) { 5953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *RealVal = operator[](ResolveConstants.back().second); 5963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Placeholder = ResolveConstants.back().first; 5973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResolveConstants.pop_back(); 5983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Loop over all users of the placeholder, updating them to reference the 6003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // new value. If they reference more than one placeholder, update them all 6013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // at once. 6023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!Placeholder->use_empty()) { 6033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value::use_iterator UI = Placeholder->use_begin(); 604c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray Use &use = *UI; 605c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray User *U = use.getUser(); 6063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If the using object isn't uniqued, just update the operands. This 6083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // handles instructions and initializers for global variables. 6093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!isa<Constant>(U) || isa<GlobalValue>(U)) { 610c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray use.set(RealVal); 6113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 6123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Otherwise, we have a constant that uses the placeholder. Replace that 6153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // constant with a new constant that has *all* placeholder uses updated. 6163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *UserC = cast<Constant>(U); 6173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (User::op_iterator I = UserC->op_begin(), E = UserC->op_end(); 6183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I != E; ++I) { 6193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *NewOp; 6203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!isa<ConstantPlaceHolder>(*I)) { 6213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Not a placeholder reference. 6223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOp = *I; 6233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (*I == Placeholder) { 6243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Common case is that it just references this one placeholder. 6253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOp = RealVal; 6263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 6273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Otherwise, look up the placeholder in ResolveConstants. 6283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResolveConstantsTy::iterator It = 6293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::lower_bound(ResolveConstants.begin(), ResolveConstants.end(), 6303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::pair<Constant*, unsigned>(cast<Constant>(*I), 6313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 0)); 6323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(It != ResolveConstants.end() && It->first == *I); 6333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOp = operator[](It->second); 6343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOps.push_back(cast<Constant>(NewOp)); 6373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Make the new constant. 6403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *NewC; 6413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) { 6423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewC = ConstantArray::get(UserCA->getType(), NewOps); 6433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) { 6443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewC = ConstantStruct::get(UserCS->getType(), NewOps); 6453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (isa<ConstantVector>(UserC)) { 6463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewC = ConstantVector::get(NewOps); 6473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 6483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr."); 6493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewC = cast<ConstantExpr>(UserC)->getWithOperands(NewOps); 6503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UserC->replaceAllUsesWith(NewC); 6533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UserC->destroyConstant(); 6543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOps.clear(); 6553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Update all ValueHandles, they should be the only users at this point. 6583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Placeholder->replaceAllUsesWith(RealVal); 6593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete Placeholder; 6603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 6623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReaderMDValueList::AssignValue(Value *V, unsigned Idx) { 6643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx == size()) { 6653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien push_back(V); 6663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 6673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 6703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx+1); 6713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien WeakVH &OldV = MDValuePtrs[Idx]; 6733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OldV == 0) { 6743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV = V; 6753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 6763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If there was a forward reference to this value, replace it. 6793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDNode *PrevVal = cast<MDNode>(OldV); 6803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV->replaceAllUsesWith(V); 6813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDNode::deleteTemporary(PrevVal); 6823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Deleting PrevVal sets Idx value in MDValuePtrs to null. Set new 6833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // value for Idx. 6843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValuePtrs[Idx] = V; 6853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 6863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienValue *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { 6883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 6893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx + 1); 6903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Value *V = MDValuePtrs[Idx]) { 6923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(V->getType()->isMetadataTy() && "Type mismatch in value table!"); 6933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V; 6943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Create and return a placeholder, which will later be RAUW'd. 6973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = MDNode::getTemporary(Context, ArrayRef<Value*>()); 6983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValuePtrs[Idx] = V; 6993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V; 7003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 7013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienType *BitcodeReader::getTypeByID(unsigned ID) { 7033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // The type table size is always specified correctly. 7043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ID >= TypeList.size()) 7053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return 0; 706c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 7073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *Ty = TypeList[ID]) 7083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty; 7093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If we have a forward reference, the only possible case is when it is to a 7113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // named struct. Just create a placeholder for now. 7123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return TypeList[ID] = StructType::create(Context); 7133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 7143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// FIXME: Remove in LLVM 3.1, only used by ParseOldTypeTable. 7163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienType *BitcodeReader::getTypeByIDOrNull(unsigned ID) { 7173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ID >= TypeList.size()) 7183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList.resize(ID+1); 719c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 7203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return TypeList[ID]; 7213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 7223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 7253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// Functions for parsing blocks from the bitcode file 7263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 7273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 728d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 729d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// \brief This fills an AttrBuilder object with the LLVM attributes that have 730d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// been decoded from the given integer. This function must stay in sync with 731d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// 'encodeLLVMAttributesForBitcode'. 732d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesstatic void decodeLLVMAttributesForBitcode(AttrBuilder &B, 733d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines uint64_t EncodedAttrs) { 734d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // FIXME: Remove in 4.0. 735d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 736d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The alignment is stored as a 16-bit raw value from bits 31--16. We shift 737d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // the bits above 31 down by 11 bits. 738d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16; 739d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines assert((!Alignment || isPowerOf2_32(Alignment)) && 740d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines "Alignment must be a power of two."); 741d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 742d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Alignment) 743d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines B.addAlignmentAttr(Alignment); 744d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines B.addRawValue(((EncodedAttrs & (0xfffffULL << 32)) >> 11) | 745d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines (EncodedAttrs & 0xffff)); 746d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 747d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 748d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseAttributeBlock() { 7493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) 750d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 7513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!MAttributes.empty()) 753d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidMultipleBlocks); 7543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 7563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 757d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SmallVector<AttributeSet, 8> Attrs; 7583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records. 7603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 761d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 7623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 763d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 764d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 765d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 766d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 767d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 768d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 769d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 770d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 771d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 7723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 7733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 7753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 776d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 7773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: ignore. 7783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 779d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::PARAMATTR_CODE_ENTRY_OLD: { // ENTRY: [paramidx0, attr0, ...] 780d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // FIXME: Remove in 4.0. 7813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() & 1) 782d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 7833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 784b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 785d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines AttrBuilder B; 786d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines decodeLLVMAttributesForBitcode(B, Record[i+1]); 787d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.push_back(AttributeSet::get(Context, Record[i], B)); 7883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 7893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 790d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines MAttributes.push_back(AttributeSet::get(Context, Attrs)); 791d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.clear(); 792d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 793d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 794d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [attrgrp0, attrgrp1, ...] 795d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (unsigned i = 0, e = Record.size(); i != e; ++i) 796d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Attrs.push_back(MAttributeGroups[Record[i]]); 7973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 798b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines MAttributes.push_back(AttributeSet::get(Context, Attrs)); 7993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Attrs.clear(); 8003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 8053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 806d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 807d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseTypeTable() { 8083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW)) 809d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 810c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 8113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return ParseTypeTableBody(); 8123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 8133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 814d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseTypeTableBody() { 8153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!TypeList.empty()) 816d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidMultipleBlocks); 8173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 8193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumRecords = 0; 8203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<64> TypeName; 822c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 8233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this type table. 8243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 825d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 826d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 827d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 828d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 829d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 830d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 831d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 8323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumRecords != TypeList.size()) 833d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 834d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 835d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 836d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 837d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 8383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 8413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 8423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ResultTy = 0; 843d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 844d724d097437f40a5689464429f948ec41e4a2415Stephen Hines default: 845d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 8463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 8473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // TYPE_CODE_NUMENTRY contains a count of the number of types in the 8483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // type list. This allows us to reserve space. 8493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 850d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 8513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList.resize(Record[0]); 8523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 8533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_VOID: // VOID 8543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getVoidTy(Context); 8553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 856d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::TYPE_CODE_HALF: // HALF 857d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ResultTy = Type::getHalfTy(Context); 858d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 8593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FLOAT: // FLOAT 8603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getFloatTy(Context); 8613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_DOUBLE: // DOUBLE 8633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getDoubleTy(Context); 8643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_X86_FP80: // X86_FP80 8663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getX86_FP80Ty(Context); 8673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FP128: // FP128 8693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getFP128Ty(Context); 8703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 8723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getPPC_FP128Ty(Context); 8733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_LABEL: // LABEL 8753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getLabelTy(Context); 8763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_METADATA: // METADATA 8783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getMetadataTy(Context); 8793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_X86_MMX: // X86_MMX 8813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getX86_MMXTy(Context); 8823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 8843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 885d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 8863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = IntegerType::get(Context, Record[0]); 8883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 8903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // [pointee type, address space] 8913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 892d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 8933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned AddressSpace = 0; 8943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() == 2) 8953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AddressSpace = Record[1]; 8963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = getTypeByID(Record[0]); 897d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (ResultTy == 0) 898d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 8993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = PointerType::get(ResultTy, AddressSpace); 9003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FUNCTION_OLD: { 903b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // FIXME: attrid is dead, remove it in LLVM 4.0 9043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [vararg, attrid, retty, paramty x N] 9053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 906d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 907b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Type*, 8> ArgTys; 9083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 3, e = Record.size(); i != e; ++i) { 9093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *T = getTypeByID(Record[i])) 9103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArgTys.push_back(T); 9113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 9123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 914c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 9153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = getTypeByID(Record[2]); 9163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ResultTy == 0 || ArgTys.size() < Record.size()-3) 917d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 9183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 9193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 9203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FUNCTION: { 9233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [vararg, retty, paramty x N] 9243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 925d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 926d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SmallVector<Type*, 8> ArgTys; 9273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 2, e = Record.size(); i != e; ++i) { 9283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *T = getTypeByID(Record[i])) 9293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArgTys.push_back(T); 9303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 9313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 933c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 9343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = getTypeByID(Record[1]); 9353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ResultTy == 0 || ArgTys.size() < Record.size()-2) 936d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 9373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 9383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 9393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N] 9423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 943d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 944b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Type*, 8> EltTys; 9453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1, e = Record.size(); i != e; ++i) { 9463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *T = getTypeByID(Record[i])) 9473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien EltTys.push_back(T); 9483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 9493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (EltTys.size() != Record.size()-1) 952d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 9533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = StructType::get(Context, EltTys, Record[0]); 9543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N] 9573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, TypeName)) 958d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 9593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 9603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 9613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N] 9623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 963d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 964c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 9653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumRecords >= TypeList.size()) 966d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 967c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 9683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check to see if this was forward referenced, if so fill in the temp. 9693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 9703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Res) { 9713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res->setName(TypeName); 9723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList[NumRecords] = 0; 9733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else // Otherwise, create a new struct. 9743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res = StructType::create(Context, TypeName); 9753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeName.clear(); 976c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 9773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Type*, 8> EltTys; 9783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1, e = Record.size(); i != e; ++i) { 9793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *T = getTypeByID(Record[i])) 9803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien EltTys.push_back(T); 9813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 9823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (EltTys.size() != Record.size()-1) 985d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 9863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res->setBody(EltTys, Record[0]); 9873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Res; 9883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: [] 9913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() != 1) 992d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 9933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 9943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumRecords >= TypeList.size()) 995d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 996c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 9973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check to see if this was forward referenced, if so fill in the temp. 9983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 9993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Res) { 10003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res->setName(TypeName); 10013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList[NumRecords] = 0; 10023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else // Otherwise, create a new struct with no body. 10033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res = StructType::create(Context, TypeName); 10043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeName.clear(); 10053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Res; 10063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1007c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 10083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 10093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 1010d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 10113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByID(Record[1]))) 10123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = ArrayType::get(ResultTy, Record[0]); 10133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 1014d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 10153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 10163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 10173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 1018d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 10193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByID(Record[1]))) 10203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = VectorType::get(ResultTy, Record[0]); 10213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 1022d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidType); 10233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 10243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 10253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 10263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumRecords >= TypeList.size()) 1027d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 10283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(ResultTy && "Didn't read a type?"); 10293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(TypeList[NumRecords] == 0 && "Already read type?"); 10303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList[NumRecords++] = ResultTy; 10313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 10323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 10333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 10343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// FIXME: Remove in LLVM 3.1 1035d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseOldTypeTable() { 1036c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Stream.EnterSubBlock(TYPE_BLOCK_ID_OLD_3_0)) 1037d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 10383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 10393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!TypeList.empty()) 1040d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 1041c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 1042c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // While horrible, we have no good ordering of types in the bc file. Just 10443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // iteratively parse types out of the bc file in multiple passes until we get 10453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // them all. Do this by saving a cursor for the start of the type block. 10463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BitstreamCursor StartOfTypeBlockCursor(Stream); 1047c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumTypesRead = 0; 1049c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 10513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienRestartScan: 10523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NextTypeID = 0; 10533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool ReadAnyTypes = false; 1054c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this type table. 10563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 10573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 10583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 10593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextTypeID != TypeList.size()) 1060d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 1061c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If we haven't read all of the types yet, iterate again. 10633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumTypesRead != TypeList.size()) { 10643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If we didn't successfully read any types in this pass, then we must 10653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // have an unhandled forward reference. 10663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!ReadAnyTypes) 1067d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 1068c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream = StartOfTypeBlockCursor; 10703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien goto RestartScan; 10713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1072c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 1074d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 1075d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 10763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1077c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 10793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No known subblocks, always skip them. 10803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadSubBlockID(); 10813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 1082d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 10833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 10843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1085c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 10873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 10883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 10893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1090c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 10923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 10933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ResultTy = 0; 1094d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 1095d724d097437f40a5689464429f948ec41e4a2415Stephen Hines default: return Error(InvalidTYPETable); 10963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 10973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // TYPE_CODE_NUMENTRY contains a count of the number of types in the 10983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // type list. This allows us to reserve space. 10993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 1100d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 11013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList.resize(Record[0]); 11023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 11033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_VOID: // VOID 11043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getVoidTy(Context); 11053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FLOAT: // FLOAT 11073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getFloatTy(Context); 11083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_DOUBLE: // DOUBLE 11103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getDoubleTy(Context); 11113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_X86_FP80: // X86_FP80 11133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getX86_FP80Ty(Context); 11143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FP128: // FP128 11163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getFP128Ty(Context); 11173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 11193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getPPC_FP128Ty(Context); 11203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_LABEL: // LABEL 11223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getLabelTy(Context); 11233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_METADATA: // METADATA 11253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getMetadataTy(Context); 11263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_X86_MMX: // X86_MMX 11283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getX86_MMXTy(Context); 11293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 11313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 1132d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 11333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = IntegerType::get(Context, Record[0]); 11343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_OPAQUE: // OPAQUE 11363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextTypeID < TypeList.size() && TypeList[NextTypeID] == 0) 1137b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines ResultTy = StructType::create(Context, ""); 11383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1139c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien case TYPE_CODE_STRUCT_OLD_3_0: {// STRUCT_OLD 11403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextTypeID >= TypeList.size()) break; 11413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If we already read it, don't reprocess. 11423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (TypeList[NextTypeID] && 11433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien !cast<StructType>(TypeList[NextTypeID])->isOpaque()) 11443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 11463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Set a type. 11473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (TypeList[NextTypeID] == 0) 1148b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines TypeList[NextTypeID] = StructType::create(Context, ""); 11493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 11503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Type*> EltTys; 11513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1, e = Record.size(); i != e; ++i) { 11523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *Elt = getTypeByIDOrNull(Record[i])) 11533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien EltTys.push_back(Elt); 11543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 11553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 11573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 11583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (EltTys.size() != Record.size()-1) 11593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; // Not all elements are ready. 1160c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 11613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<StructType>(TypeList[NextTypeID])->setBody(EltTys, Record[0]); 11623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = TypeList[NextTypeID]; 11633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList[NextTypeID] = 0; 11643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 11663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 11673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // [pointee type, address space] 11683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 1169d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 11703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned AddressSpace = 0; 11713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() == 2) 11723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AddressSpace = Record[1]; 11733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[0]))) 11743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = PointerType::get(ResultTy, AddressSpace); 11753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 11773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FUNCTION_OLD: { 11783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FIXME: attrid is dead, remove it in LLVM 3.0 11793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [vararg, attrid, retty, paramty x N] 11803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 1181d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 11823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Type*> ArgTys; 11833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 3, e = Record.size(); i != e; ++i) { 11843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *Elt = getTypeByIDOrNull(Record[i])) 11853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArgTys.push_back(Elt); 11863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 11873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 11893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ArgTys.size()+3 != Record.size()) 11903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; // Something was null. 11913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[2]))) 11923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 11933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 11953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FUNCTION: { 11963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [vararg, retty, paramty x N] 11973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 1198d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 11993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Type*> ArgTys; 12003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 2, e = Record.size(); i != e; ++i) { 12013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *Elt = getTypeByIDOrNull(Record[i])) 12023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArgTys.push_back(Elt); 12033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 12043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ArgTys.size()+2 != Record.size()) 12073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; // Something was null. 12083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[1]))) 12093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 12103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 12133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 1214d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 12153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[1]))) 12163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = ArrayType::get(ResultTy, Record[0]); 12173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 12193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 1220d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 12213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[1]))) 12223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = VectorType::get(ResultTy, Record[0]); 12233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1225c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 12263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextTypeID >= TypeList.size()) 1227d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTYPETable); 1228c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 12293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ResultTy && TypeList[NextTypeID] == 0) { 12303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ++NumTypesRead; 12313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ReadAnyTypes = true; 1232c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 12333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList[NextTypeID] = ResultTy; 12343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1235c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 12363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ++NextTypeID; 12373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 12393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1241d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseOldTypeSymbolTable() { 1242c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Stream.EnterSubBlock(TYPE_SYMTAB_BLOCK_ID_OLD_3_0)) 1243d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 12443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 12463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this type table. 12483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string TypeName; 12493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 12503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 12513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 12523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 1253d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1254d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 12553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 12583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No known subblocks, always skip them. 12593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadSubBlockID(); 12603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 1261d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 12623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 12633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 12663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 12673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 12683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 12713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 1272d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 12733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: unknown type. 12743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TST_CODE_ENTRY: // TST_ENTRY: [typeid, namechar x N] 12763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 1, TypeName)) 1277d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 12783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned TypeID = Record[0]; 12793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (TypeID >= TypeList.size()) 1280d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 12813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Only apply the type name to a struct type with no name. 12833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (StructType *STy = dyn_cast<StructType>(TypeList[TypeID])) 12843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!STy->isLiteral() && !STy->hasName()) 12853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien STy->setName(TypeName); 12863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeName.clear(); 12873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 12913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1292d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseValueSymbolTable() { 12933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) 1294d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 12953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 12973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this value table. 12993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<128> ValueName; 13003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 13013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 13023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 13033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 1304d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1305d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 13063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 13083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No known subblocks, always skip them. 13093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadSubBlockID(); 13103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 1311d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 13123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 13133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 13163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 13173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 13183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 13213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 1322d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Code, Record)) { 13233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: unknown type. 13243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 13253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N] 13263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 1, ValueName)) 1327d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 13283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ValueID = Record[0]; 13293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ValueID >= ValueList.size()) 1330d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 13313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = ValueList[ValueID]; 13323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V->setName(StringRef(ValueName.data(), ValueName.size())); 13343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueName.clear(); 13353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 13363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::VST_CODE_BBENTRY: { 13383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 1, ValueName)) 1339d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 13403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *BB = getBasicBlock(Record[0]); 13413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BB == 0) 1342d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 13433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BB->setName(StringRef(ValueName.data(), ValueName.size())); 13453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueName.clear(); 13463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 13473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 13513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1352d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseMetadata() { 13533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NextMDValueNo = MDValueList.size(); 13543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) 1356d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 13573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 13593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records. 13613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 13623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 13633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 13643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 1365d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1366d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 13673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 13703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No known subblocks, always skip them. 13713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadSubBlockID(); 13723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 1373d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 13743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 13753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 13783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 13793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 13803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool IsFunctionLocal = false; 13833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 13843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 1385d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Code = Stream.readRecord(Code, Record); 13863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Code) { 13873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: ignore. 13883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 13893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_NAME: { 13903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read named of the named metadata. 13913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NameLength = Record.size(); 13923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<8> Name; 13933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Name.resize(NameLength); 13943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != NameLength; ++i) 13953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Name[i] = Record[i]; 13963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 13973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Code = Stream.ReadCode(); 13983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // METADATA_NAME is always followed by METADATA_NAMED_NODE. 1400d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned NextBitCode = Stream.readRecord(Code, Record); 14013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(NextBitCode == bitc::METADATA_NAMED_NODE); (void)NextBitCode; 14023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 14033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read named metadata elements. 14043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 14053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NamedMDNode *NMD = TheModule->getOrInsertNamedMetadata(Name); 14063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) { 14073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDNode *MD = dyn_cast<MDNode>(MDValueList.getValueFwdRef(Record[i])); 14083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (MD == 0) 1409d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 14103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NMD->addOperand(MD); 14113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 14133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_FN_NODE: 14153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien IsFunctionLocal = true; 14163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // fall-through 14173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_NODE: { 14183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() % 2 == 1) 1419d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 14203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 14213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 14223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Value*, 8> Elts; 14233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; i += 2) { 14243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[i]); 1425d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 1426d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 14273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ty->isMetadataTy()) 14283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); 14293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (!Ty->isVoidTy()) 14303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty)); 14313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 14323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(NULL); 14333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = MDNode::getWhenValsUnresolved(Context, Elts, IsFunctionLocal); 14353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien IsFunctionLocal = false; 14363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValueList.AssignValue(V, NextMDValueNo++); 14373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 14383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_STRING: { 14403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned MDStringLength = Record.size(); 14413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<8> String; 14423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien String.resize(MDStringLength); 14433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != MDStringLength; ++i) 14443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien String[i] = Record[i]; 14453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = MDString::get(Context, 14463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien StringRef(String.data(), String.size())); 14473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValueList.AssignValue(V, NextMDValueNo++); 14483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 14493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_KIND: { 14513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned RecordLength = Record.size(); 14523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty() || RecordLength < 2) 1453d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 14543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<8> Name; 14553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Name.resize(RecordLength-1); 14563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Kind = Record[0]; 14573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1; i != RecordLength; ++i) 14583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Name[i-1] = Record[i]; 1459c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 14603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NewKind = TheModule->getMDKindID(Name.str()); 14613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) 1462d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(ConflictingMETADATA_KINDRecords); 14633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 14643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 14683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1469d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines/// decodeSignRotatedValue - Decode a signed value stored with the sign bit in 14703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// the LSB for dense VBR encoding. 1471d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesuint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) { 14723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((V & 1) == 0) 14733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V >> 1; 14743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (V != 1) 14753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return -(V >> 1); 14763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // There is no such thing as -0 with integers. "-0" really means MININT. 14773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return 1ULL << 63; 14783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 14793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 14803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ResolveGlobalAndAliasInits - Resolve all of the initializers for global 14813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// values and aliases that we can. 1482d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ResolveGlobalAndAliasInits() { 14833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist; 14843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist; 14853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 14863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInitWorklist.swap(GlobalInits); 14873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AliasInitWorklist.swap(AliasInits); 14883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 14893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!GlobalInitWorklist.empty()) { 14903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ValID = GlobalInitWorklist.back().second; 14913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ValID >= ValueList.size()) { 14923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Not ready to resolve this yet, it requires something later in the file. 14933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInits.push_back(GlobalInitWorklist.back()); 14943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 14953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 14963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInitWorklist.back().first->setInitializer(C); 14973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 1498d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(ExpectedConstant); 14993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInitWorklist.pop_back(); 15013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!AliasInitWorklist.empty()) { 15043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ValID = AliasInitWorklist.back().second; 15053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ValID >= ValueList.size()) { 15063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AliasInits.push_back(AliasInitWorklist.back()); 15073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 15083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 15093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AliasInitWorklist.back().first->setAliasee(C); 15103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 1511d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(ExpectedConstant); 15123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AliasInitWorklist.pop_back(); 15143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1515d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 15163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 15173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1518d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hinesstatic APInt ReadWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) { 1519d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SmallVector<uint64_t, 8> Words(Vals.size()); 1520d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::transform(Vals.begin(), Vals.end(), Words.begin(), 1521d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitcodeReader::decodeSignRotatedValue); 1522d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1523d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return APInt(TypeBits, Words); 1524d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 1525d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1526d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseConstants() { 15273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) 1528d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 15293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 15313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this value table. 15333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *CurTy = Type::getInt32Ty(Context); 15343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NextCstNo = ValueList.size(); 15353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 1536d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 1537d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1538d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 1539d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 1540d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 1541d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1542d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 1543d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (NextCstNo != ValueList.size()) 1544d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidConstantReference); 1545d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1546d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Once all the constants have been read, go through and resolve forward 1547d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // references. 1548d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ValueList.ResolveConstantForwardRefs(); 1549d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1550d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 1551d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 15523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 15533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 15563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 15573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = 0; 1558d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned BitCode = Stream.readRecord(Entry.ID, Record); 15593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (BitCode) { 15603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: unknown constant 15613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_UNDEF: // UNDEF 15623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); 15633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 15643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] 15653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 1566d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 15673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[0] >= TypeList.size()) 1568d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 15693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CurTy = TypeList[Record[0]]; 15703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; // Skip the ValueList manipulation. 15713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_NULL: // NULL 15723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = Constant::getNullValue(CurTy); 15733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 15743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_INTEGER: // INTEGER: [intval] 15753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!CurTy->isIntegerTy() || Record.empty()) 1576d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1577d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0])); 15783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 15793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval] 15803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!CurTy->isIntegerTy() || Record.empty()) 1581d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 15823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1583d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt VInt = ReadWideAPInt(Record, 1584d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines cast<IntegerType>(CurTy)->getBitWidth()); 1585d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantInt::get(Context, VInt); 1586d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 15873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 15883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] 15903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 1591d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1592d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (CurTy->isHalfTy()) 1593d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf, 1594d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(16, (uint16_t)Record[0]))); 1595d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else if (CurTy->isFloatTy()) 1596d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEsingle, 1597d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(32, (uint32_t)Record[0]))); 15983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (CurTy->isDoubleTy()) 1599d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEdouble, 1600d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(64, Record[0]))); 16013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (CurTy->isX86_FP80Ty()) { 16023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Bits are not stored the same way as a normal i80 APInt, compensate. 16033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien uint64_t Rearrange[2]; 16043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16); 16053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Rearrange[1] = Record[0] >> 48; 1606d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::x87DoubleExtended, 1607d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(80, Rearrange))); 16083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (CurTy->isFP128Ty()) 1609d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::IEEEquad, 1610d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(128, Record))); 16113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (CurTy->isPPC_FP128Ty()) 1612d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines V = ConstantFP::get(Context, APFloat(APFloat::PPCDoubleDouble, 1613d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines APInt(128, Record))); 16143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 16153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); 16163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] 16203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 1621d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 16223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 1624b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines SmallVector<Constant*, 16> Elts; 16253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (StructType *STy = dyn_cast<StructType>(CurTy)) { 16273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 16283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getConstantFwdRef(Record[i], 16293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien STy->getElementType(i))); 16303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantStruct::get(STy, Elts); 16313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) { 16323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *EltTy = ATy->getElementType(); 16333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 16343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 16353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantArray::get(ATy, Elts); 16363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) { 16373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *EltTy = VTy->getElementType(); 16383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 16393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 16403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantVector::get(Elts); 16413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 16423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); 16433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_STRING: { // STRING: [values] 16473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 1648d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 16493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArrayType *ATy = cast<ArrayType>(CurTy); 16513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *EltTy = ATy->getElementType(); 16523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 16543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Constant*> Elts; 16553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 16563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ConstantInt::get(EltTy, Record[i])); 16573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantArray::get(ATy, Elts); 16583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CSTRING: { // CSTRING: [values] 16613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 1662d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 16633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArrayType *ATy = cast<ArrayType>(CurTy); 16653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *EltTy = ATy->getElementType(); 16663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 16683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Constant*> Elts; 16693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 16703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ConstantInt::get(EltTy, Record[i])); 16713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(Constant::getNullValue(EltTy)); 16723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantArray::get(ATy, Elts); 16733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] 1676d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1677d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 16783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien int Opc = GetDecodedBinaryOpcode(Record[0], CurTy); 16793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc < 0) { 16803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); // Unknown binop. 16813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 16823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy); 16833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy); 16843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Flags = 0; 16853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() >= 4) { 16863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc == Instruction::Add || 16873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Sub || 16883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Mul || 16893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Shl) { 16903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 16913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Flags |= OverflowingBinaryOperator::NoSignedWrap; 16923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 16933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Flags |= OverflowingBinaryOperator::NoUnsignedWrap; 16943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (Opc == Instruction::SDiv || 16953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::UDiv || 16963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::LShr || 16973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::AShr) { 16983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[3] & (1 << bitc::PEO_EXACT)) 16993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Flags |= SDivOperator::IsExact; 17003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::get(Opc, LHS, RHS, Flags); 17033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] 1707d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1708d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien int Opc = GetDecodedCastOpcode(Record[0]); 17103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc < 0) { 17113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); // Unknown cast. 17123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 17133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[1]); 1714d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!OpTy) 1715d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); 17173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getCast(Opc, Op, CurTy); 17183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_INBOUNDS_GEP: 17223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands] 1723d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() & 1) 1724d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Constant*, 16> Elts; 17263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 17273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ElTy = getTypeByID(Record[i]); 1728d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!ElTy) 1729d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); 17313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end()); 17333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getGetElementPtr(Elts[0], Indices, 17343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BitCode == 17353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bitc::CST_CODE_CE_INBOUNDS_GEP); 17363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_SELECT: // CE_SELECT: [opval#, opval#, opval#] 1739d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1740d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0], 17423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type::getInt1Ty(Context)), 17433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.getConstantFwdRef(Record[1],CurTy), 17443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.getConstantFwdRef(Record[2],CurTy)); 17453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval] 1747d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1748d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *OpTy = 17503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1751d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (OpTy == 0) 1752d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 17543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 17553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getExtractElement(Op0, Op1); 17563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval] 17593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *OpTy = dyn_cast<VectorType>(CurTy); 17603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3 || OpTy == 0) 1761d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 17633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[1], 17643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpTy->getElementType()); 17653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 17663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getInsertElement(Op0, Op1, Op2); 17673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] 17703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *OpTy = dyn_cast<VectorType>(CurTy); 17713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3 || OpTy == 0) 1772d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 17743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); 17753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 17763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpTy->getNumElements()); 17773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy); 17783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 17793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval] 17823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *RTy = dyn_cast<VectorType>(CurTy); 17833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *OpTy = 17843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 17853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 4 || RTy == 0 || OpTy == 0) 1786d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 17883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 17893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 17903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien RTy->getNumElements()); 17913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy); 17923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 17933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] 1796d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 4) 1797d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 17983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[0]); 1799d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (OpTy == 0) 1800d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 18013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 18023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 18033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpTy->isFPOrFPVectorTy()) 18053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getFCmp(Record[3], Op0, Op1); 18063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 18073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getICmp(Record[3], Op0, Op1); 18083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 18093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_INLINEASM: { 1811d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 2) 1812d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 18133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string AsmStr, ConstrStr; 18143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool HasSideEffects = Record[0] & 1; 18153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool IsAlignStack = Record[0] >> 1; 18163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned AsmStrSize = Record[1]; 18173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (2+AsmStrSize >= Record.size()) 1818d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 18193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ConstStrSize = Record[2+AsmStrSize]; 18203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (3+AsmStrSize+ConstStrSize > Record.size()) 1821d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 18223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != AsmStrSize; ++i) 18243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AsmStr += (char)Record[2+i]; 18253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != ConstStrSize; ++i) 18263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ConstrStr += (char)Record[3+AsmStrSize+i]; 18273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PointerType *PTy = cast<PointerType>(CurTy); 18283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), 18293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AsmStr, ConstrStr, HasSideEffects, IsAlignStack); 18303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 18313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_BLOCKADDRESS:{ 1833d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 3) 1834d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 18353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *FnTy = getTypeByID(Record[0]); 1836d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (FnTy == 0) 1837d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 18383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *Fn = 18393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy)); 1840d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Fn == 0) 1841d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1842c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 18433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalVariable *FwdRef = new GlobalVariable(*Fn->getParent(), 18443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type::getInt8Ty(Context), 18453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien false, GlobalValue::InternalLinkage, 18463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 0, ""); 18473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BlockAddrFwdRefs[Fn].push_back(std::make_pair(Record[2], FwdRef)); 18483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = FwdRef; 18493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1850c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 18513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.AssignValue(V, NextCstNo); 18543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ++NextCstNo; 18553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextCstNo != ValueList.size()) 1858d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidConstantReference); 18593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 1861d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(ExpectedConstant); 18623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Once all the constants have been read, go through and resolve forward 18643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // references. 18653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.ResolveConstantForwardRefs(); 1866d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 18673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 18683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// RememberAndSkipFunctionBody - When we see the block for a function body, 18703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// remember where it is and then skip it. This lets us lazily deserialize the 18713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// functions. 1872d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::RememberAndSkipFunctionBody() { 18733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Get the function we are talking about. 18743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (FunctionsWithBodies.empty()) 1875d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InsufficientFunctionProtos); 18763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *Fn = FunctionsWithBodies.back(); 18783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionsWithBodies.pop_back(); 18793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Save the current stream state. 18813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien uint64_t CurBit = Stream.GetCurrentBitNo(); 18823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DeferredFunctionInfo[Fn] = CurBit; 18833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Skip over the function block for now. 18853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 1886d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 1887d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 18883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 18893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1890d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::GlobalCleanup() { 1891d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Patch the initializers for globals and aliases up. 1892d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines ResolveGlobalAndAliasInits(); 1893d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!GlobalInits.empty() || !AliasInits.empty()) 1894d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedGlobalInitializerSet); 1895d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1896d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Look for intrinsic functions which need to be upgraded at some point 1897d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); 1898d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines FI != FE; ++FI) { 1899d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Function *NewFn; 1900d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (UpgradeIntrinsicFunction(FI, NewFn)) 1901d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn)); 1902d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 1903d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1904d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Look for global variables which need to be renamed. 1905d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines for (Module::global_iterator 1906d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines GI = TheModule->global_begin(), GE = TheModule->global_end(); 1907d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines GI != GE; ++GI) 1908d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines UpgradeGlobalVariable(GI); 1909d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Force deallocation of memory for these vectors to favor the client that 1910d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // want lazy deserialization. 1911d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); 1912d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); 1913d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1914d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 1915d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 1916d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseModule(bool Resume) { 1917d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Resume) 1918d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.JumpToBit(NextUnreadBit); 1919d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 1920d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 19213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 19233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::string> SectionTable; 19243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::string> GCTable; 19253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this module. 1927d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 1928d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advance(); 19293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1930d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 1931d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 1932d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 1933d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 1934d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return GlobalCleanup(); 19353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1936d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: 1937d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.ID) { 19383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Skip unknown content. 19393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 1940d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 19413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BLOCKINFO_BLOCK_ID: 19433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockInfoBlock()) 1944d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 19453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::PARAMATTR_BLOCK_ID: 1947d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseAttributeBlock()) 1948d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 19493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_BLOCK_ID_NEW: 1951d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseTypeTable()) 1952d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 19533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1954c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien case TYPE_BLOCK_ID_OLD_3_0: 1955d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseOldTypeTable()) 1956d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 19573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1958c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien case TYPE_SYMTAB_BLOCK_ID_OLD_3_0: 1959d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseOldTypeSymbolTable()) 1960d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 19613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::VALUE_SYMTAB_BLOCK_ID: 1963d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseValueSymbolTable()) 1964d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1965d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SeenValueSymbolTable = true; 19663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CONSTANTS_BLOCK_ID: 1968d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseConstants()) 1969d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1970d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ResolveGlobalAndAliasInits()) 1971d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 19723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_BLOCK_ID: 1974d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseMetadata()) 1975d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 19763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNCTION_BLOCK_ID: 19783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If this is the first function body we've seen, reverse the 19793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FunctionsWithBodies list. 1980d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!SeenFirstFunctionBody) { 19813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end()); 1982d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = GlobalCleanup()) 1983d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1984d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SeenFirstFunctionBody = true; 19853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 19863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 1987d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = RememberAndSkipFunctionBody()) 1988d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 1989d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // For streaming bitcode, suspend parsing when we reach the function 1990d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // bodies. Subsequent materialization calls will resume it when 1991d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // necessary. For streaming, the function bodies must be at the end of 1992d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // the bitcode. If the bitcode file is old, the symbol table will be 1993d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // at the end instead and will not have been seen yet. In this case, 1994d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // just finish the parse now. 1995d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (LazyStreamer && SeenValueSymbolTable) { 1996d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines NextUnreadBit = Stream.GetCurrentBitNo(); 1997d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 1998d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 1999d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 20003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 20033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2004d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2005d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 2006d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 20073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2009d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 20103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 2011d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 20123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: break; // Default behavior, ignore unknown content. 2013b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines case bitc::MODULE_CODE_VERSION: { // VERSION: [version#] 20143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 2015d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 20163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Only version #0 is supported so far. 20173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[0] != 0) 2018d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 20193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 2020b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines } 20213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 20223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2024d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 20253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TheModule->setTargetTriple(S); 20263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] 20293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2031d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 20323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TheModule->setDataLayout(S); 20333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] 20363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2038d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 20393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TheModule->setModuleInlineAsm(S); 20403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N] 20433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2045d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2046b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // ANDROID: Ignore value, since we never used it anyways. 2047b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines // TheModule->addLibrary(S); 20483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] 20513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2053d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 20543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SectionTable.push_back(S); 20553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N] 20583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2060d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 20613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GCTable.push_back(S); 20623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // GLOBALVAR: [pointer type, isconst, initid, 20653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // linkage, alignment, section, visibility, threadlocal, 20663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // unnamed_addr] 20673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_GLOBALVAR: { 20683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 6) 2069d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 20703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[0]); 2071d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 2072d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 20733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Ty->isPointerTy()) 2074d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 20753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); 20763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ty = cast<PointerType>(Ty)->getElementType(); 20773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 20783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool isConstant = Record[1]; 20793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]); 20803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Alignment = (1 << Record[4]) >> 1; 20813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string Section; 20823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[5]) { 20833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[5]-1 >= SectionTable.size()) 2084d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 20853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Section = SectionTable[Record[5]-1]; 20863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; 20883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 6) 20893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Visibility = GetDecodedVisibility(Record[6]); 20908b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao 20918b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal; 20923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 7) 20938b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao TLM = GetDecodedThreadLocalMode(Record[7]); 20943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 20953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool UnnamedAddr = false; 20963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 8) 20973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UnnamedAddr = Record[8]; 20983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 20993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalVariable *NewGV = 21003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien new GlobalVariable(*TheModule, Ty, isConstant, Linkage, 0, "", 0, 21018b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao TLM, AddressSpace); 21023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGV->setAlignment(Alignment); 21033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Section.empty()) 21043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGV->setSection(Section); 21053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGV->setVisibility(Visibility); 21063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGV->setUnnamedAddr(UnnamedAddr); 21073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.push_back(NewGV); 21093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Remember which value to use for the global initializer. 21113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (unsigned InitID = Record[2]) 21123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInits.push_back(std::make_pair(NewGV, InitID-1)); 21133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 21143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [type, callingconv, isproto, linkage, paramattr, 21163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // alignment, section, visibility, gc, unnamed_addr] 21173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_FUNCTION: { 21183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 8) 2119d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 21203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[0]); 2121d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 2122d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 21233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Ty->isPointerTy()) 2124d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 21253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionType *FTy = 21263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType()); 21273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!FTy) 2128d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 21293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, 21313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien "", TheModule); 21323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setCallingConv(static_cast<CallingConv::ID>(Record[1])); 21343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool isProto = Record[2]; 21353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setLinkage(GetDecodedLinkage(Record[3])); 21363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setAttributes(getAttributes(Record[4])); 21373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setAlignment((1 << Record[5]) >> 1); 21393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[6]) { 21403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[6]-1 >= SectionTable.size()) 2141d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 21423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setSection(SectionTable[Record[6]-1]); 21433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setVisibility(GetDecodedVisibility(Record[7])); 21453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 8 && Record[8]) { 21463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[8]-1 > GCTable.size()) 2147d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 21483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setGC(GCTable[Record[8]-1].c_str()); 21493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool UnnamedAddr = false; 21513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 9) 21523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UnnamedAddr = Record[9]; 21533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setUnnamedAddr(UnnamedAddr); 21543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.push_back(Func); 21553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If this is a function with a body, remember the prototype we are 21573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // creating now, so that we can match up the body with them later. 2158d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isProto) { 21593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionsWithBodies.push_back(Func); 2160d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (LazyStreamer) DeferredFunctionInfo[Func] = 0; 2161d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 21623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 21633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // ALIAS: [alias type, aliasee val#, linkage] 21653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // ALIAS: [alias type, aliasee val#, linkage, visibility] 21663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_ALIAS: { 21673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 2168d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 21693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[0]); 2170d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 2171d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 21723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Ty->isPointerTy()) 2173d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 21743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]), 21763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien "", 0, TheModule); 21773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Old bitcode files didn't have visibility field. 21783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 3) 21793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGA->setVisibility(GetDecodedVisibility(Record[3])); 21803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.push_back(NewGA); 21813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AliasInits.push_back(std::make_pair(NewGA, Record[1])); 21823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 21833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// MODULE_CODE_PURGEVALS: [numvals] 21853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_PURGEVALS: 21863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Trim down the value list to the specified size. 21873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1 || Record[0] > ValueList.size()) 2188d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 21893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.shrinkTo(Record[0]); 21903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 21913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 21933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 21953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2196d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseBitcodeInto(Module *M) { 21973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TheModule = 0; 21983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2199d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = InitStream()) 2200d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 22013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Sniff for the signature. 22033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.Read(8) != 'B' || 22043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(8) != 'C' || 22053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0x0 || 22063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xC || 22073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xE || 22083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xD) 2209d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 22103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // We expect a number of well-defined blocks, though we don't necessarily 22123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // need to understand them all. 2213d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2214d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.AtEndOfStream()) 2215d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2216d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2217d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = 2218d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs); 2219d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2220d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2221d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2222d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2223d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2224d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 22253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2226d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: 2227d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.ID) { 2228d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::BLOCKINFO_BLOCK_ID: 2229d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.ReadBlockInfoBlock()) 2230d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2231d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 2232d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case bitc::MODULE_BLOCK_ID: 2233d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Reject multiple MODULE_BLOCK's in a single bitstream. 2234d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (TheModule) 2235d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidMultipleBlocks); 2236d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines TheModule = M; 2237d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseModule(false)) 2238d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 2239d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (LazyStreamer) 2240d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2241d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 2242d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines default: 2243d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.SkipBlock()) 2244d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2245d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 2246d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 2247d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 2248d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2249d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // There should be no records in the top-level of blocks. 22503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2251d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The ranlib in Xcode 4 will align archive members by appending newlines 22523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // to the end of them. If this file size is a multiple of 4 but not 8, we 22533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // have to read and ignore these final 4 bytes :-( 2254d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Stream.getAbbrevIDWidth() == 2 && Entry.ID == 2 && 22553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a && 2256b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines Stream.AtEndOfStream()) 2257d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 22583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2259d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 22603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 22633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2264d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseModuleTriple(std::string &Triple) { 22653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 2266d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 22673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 22693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this module. 2271d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2272d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 22733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2274d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2275d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 2276d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2277d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2278d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2279d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2280d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2281d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 2282d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines break; 22833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 2286d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 22873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: break; // Default behavior, ignore unknown content. 22883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 22893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 22903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 2291d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 22923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Triple = S; 22933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 22943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 22973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 22993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2300d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseTriple(std::string &Triple) { 2301d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = InitStream()) 2302d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 23033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Sniff for the signature. 23053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.Read(8) != 'B' || 23063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(8) != 'C' || 23073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0x0 || 23083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xC || 23093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xE || 23103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xD) 2311d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 23123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // We expect a number of well-defined blocks, though we don't necessarily 23143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // need to understand them all. 2315d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2316d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advance(); 23173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2318d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2319d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2320d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2321d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2322d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 23233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2324d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: 2325d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Entry.ID == bitc::MODULE_BLOCK_ID) 2326d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return ParseModuleTriple(Triple); 23273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2328d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Ignore other sub-blocks. 2329d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Stream.SkipBlock()) 2330d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2331d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 2332d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2333d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2334d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.skipRecord(Entry.ID); 2335d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines continue; 23363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 23393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ParseMetadataAttachment - Parse metadata attachments. 2341d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseMetadataAttachment() { 23423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) 2343d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 23443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 2346d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines while (1) { 2347d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 2348d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 2349d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Entry.Kind) { 2350d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::SubBlock: // Handled for us already. 2351d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Error: 2352d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 2353d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::EndBlock: 2354d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 2355d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines case BitstreamEntry::Record: 2356d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The interesting case. 23573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 23583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 2359d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 23603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a metadata attachment record. 23613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 2362d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines switch (Stream.readRecord(Entry.ID, Record)) { 23633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: ignore. 23643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 23653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_ATTACHMENT: { 23663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned RecordLength = Record.size(); 23673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty() || (RecordLength - 1) % 2 == 1) 2368d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 23693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Instruction *Inst = InstructionList[Record[0]]; 23703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1; i != RecordLength; i = i+2) { 23713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Kind = Record[i]; 23723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DenseMap<unsigned, unsigned>::iterator I = 23733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDKindMap.find(Kind); 23743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I == MDKindMap.end()) 2375d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 23763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Node = MDValueList.getValueFwdRef(Record[i+1]); 23773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Inst->setMetadata(I->second, cast<MDNode>(Node)); 23783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 23803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 23843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ParseFunctionBody - Lazily parse the specified function body block. 2386d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::ParseFunctionBody(Function *F) { 23873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) 2388d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 23893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.clear(); 23913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ModuleValueListSize = ValueList.size(); 23923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ModuleMDValueListSize = MDValueList.size(); 23933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Add all the function arguments to the value table. 23953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) 23963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.push_back(I); 23973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NextValueNo = ValueList.size(); 23993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *CurBB = 0; 24003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned CurBBNo = 0; 24013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DebugLoc LastLoc; 2403c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 24043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records. 24053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 24063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 24073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 24083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 24093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 2410d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(MalformedBlock); 24113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 24153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Stream.ReadSubBlockID()) { 24163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Skip unknown content. 24173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 2418d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 24193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CONSTANTS_BLOCK_ID: 2421d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseConstants()) 2422d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 24233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NextValueNo = ValueList.size(); 24243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::VALUE_SYMTAB_BLOCK_ID: 2426d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseValueSymbolTable()) 2427d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 24283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_ATTACHMENT_ID: 2430d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseMetadataAttachment()) 2431d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 24323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_BLOCK_ID: 2434d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseMetadata()) 2435d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 24363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 24393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 24423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 24433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 24443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 24473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 24483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Instruction *I = 0; 2449d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned BitCode = Stream.readRecord(Code, Record); 24503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (BitCode) { 24513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: reject 2452d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 24533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks] 24543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1 || Record[0] == 0) 2455d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 24563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Create all the basic blocks for the function. 24573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionBBs.resize(Record[0]); 24583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) 24593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionBBs[i] = BasicBlock::Create(Context, "", F); 24603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CurBB = FunctionBBs[0]; 24613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 2462c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 24633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN 24643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // This record indicates that the last instruction is at the same 24653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // location as the previous instruction with a location. 24663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = 0; 2467c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 24683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Get the last instruction emitted. 24693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CurBB && !CurBB->empty()) 24703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = &CurBB->back(); 24713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (CurBBNo && FunctionBBs[CurBBNo-1] && 24723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien !FunctionBBs[CurBBNo-1]->empty()) 24733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = &FunctionBBs[CurBBNo-1]->back(); 2474c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 2475d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (I == 0) 2476d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 24773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I->setDebugLoc(LastLoc); 24783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = 0; 24793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 2480c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 24813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia] 24823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = 0; // Get the last instruction emitted. 24833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CurBB && !CurBB->empty()) 24843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = &CurBB->back(); 24853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (CurBBNo && FunctionBBs[CurBBNo-1] && 24863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien !FunctionBBs[CurBBNo-1]->empty()) 24873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = &FunctionBBs[CurBBNo-1]->back(); 24883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I == 0 || Record.size() < 4) 2489d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2490c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 24913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Line = Record[0], Col = Record[1]; 24923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ScopeID = Record[2], IAID = Record[3]; 2493c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 24943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDNode *Scope = 0, *IA = 0; 24953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ScopeID) Scope = cast<MDNode>(MDValueList.getValueFwdRef(ScopeID-1)); 24963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (IAID) IA = cast<MDNode>(MDValueList.getValueFwdRef(IAID-1)); 24973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LastLoc = DebugLoc::get(Line, Col, Scope, IA); 24983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I->setDebugLoc(LastLoc); 24993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = 0; 25003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 25013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode] 25043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 25053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *LHS, *RHS; 25063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 25073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, LHS->getType(), RHS) || 25083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+1 > Record.size()) 2509d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 25103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); 2512d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Opc == -1) 2513d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 25143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); 25153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 25163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpNum < Record.size()) { 25173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc == Instruction::Add || 25183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Sub || 25193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Mul || 25203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Shl) { 25213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 25223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<BinaryOperator>(I)->setHasNoSignedWrap(true); 25233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 25243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true); 25253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (Opc == Instruction::SDiv || 25263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::UDiv || 25273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::LShr || 25283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::AShr) { 25293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[OpNum] & (1 << bitc::PEO_EXACT)) 25303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<BinaryOperator>(I)->setIsExact(true); 25313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 25343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc] 25363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 25373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 25383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 25393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+2 != Record.size()) 2540d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 25413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ResTy = getTypeByID(Record[OpNum]); 25433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien int Opc = GetDecodedCastOpcode(Record[OpNum+1]); 25443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc == -1 || ResTy == 0) 2545d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 25463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy); 25473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 25483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 25493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INBOUNDS_GEP: 25513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands] 25523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 25533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *BasePtr; 25543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) 2555d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 25563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Value*, 16> GEPIdx; 25583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (OpNum != Record.size()) { 25593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 25603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2561d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 25623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GEPIdx.push_back(Op); 25633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = GetElementPtrInst::Create(BasePtr, GEPIdx); 25663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 25673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP) 25683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<GetElementPtrInst>(I)->setIsInBounds(true); 25693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 25703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_EXTRACTVAL: { 25733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // EXTRACTVAL: [opty, opval, n x indices] 25743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 25753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Agg; 25763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2577d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 25783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<unsigned, 4> EXTRACTVALIdx; 25803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned RecSize = Record.size(); 25813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum != RecSize; ++OpNum) { 25823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien uint64_t Index = Record[OpNum]; 25833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((unsigned)Index != Index) 2584d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 25853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien EXTRACTVALIdx.push_back((unsigned)Index); 25863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ExtractValueInst::Create(Agg, EXTRACTVALIdx); 25893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 25903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 25913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INSERTVAL: { 25943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // INSERTVAL: [opty, opval, opty, opval, n x indices] 25953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 25963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Agg; 25973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2598d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 25993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Val; 26003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Val)) 2601d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 26023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<unsigned, 4> INSERTVALIdx; 26043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned RecSize = Record.size(); 26053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum != RecSize; ++OpNum) { 26063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien uint64_t Index = Record[OpNum]; 26073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((unsigned)Index != Index) 2608d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidValue); 26093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien INSERTVALIdx.push_back((unsigned)Index); 26103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = InsertValueInst::Create(Agg, Val, INSERTVALIdx); 26133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval] 26183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // obsolete form of select 26193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // handles select i1 ... in old bitcode 26203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *TrueVal, *FalseVal, *Cond; 26223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 26233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 26243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, Type::getInt1Ty(Context), Cond)) 2625d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 26263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = SelectInst::Create(Cond, TrueVal, FalseVal); 26283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred] 26333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // new form of select 26343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // handles select i1 or select [N x i1] 26353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *TrueVal, *FalseVal, *Cond; 26373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 26383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 26393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValueTypePair(Record, OpNum, NextValueNo, Cond)) 2640d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 26413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // select condition can be either i1 or [N x i1] 26433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (VectorType* vector_type = 26443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast<VectorType>(Cond->getType())) { 26453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // expect <n x i1> 26463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (vector_type->getElementType() != Type::getInt1Ty(Context)) 2647d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 26483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 26493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // expect i1 26503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Cond->getType() != Type::getInt1Ty(Context)) 2651d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidTypeForValue); 26523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = SelectInst::Create(Cond, TrueVal, FalseVal); 26553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval] 26603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Vec, *Idx; 26623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 26633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 2664d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 26653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ExtractElementInst::Create(Vec, Idx); 26663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval] 26713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Vec, *Elt, *Idx; 26733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 26743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 26753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<VectorType>(Vec->getType())->getElementType(), Elt) || 26763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 2677d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 26783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = InsertElementInst::Create(Vec, Elt, Idx); 26793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval] 26843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Vec1, *Vec2, *Mask; 26863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) || 26873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, Vec1->getType(), Vec2)) 2688d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 26893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) 2691d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 26923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new ShuffleVectorInst(Vec1, Vec2, Mask); 26933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred] 26983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Old form of ICmp/FCmp returning bool 26993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were 27003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // both legal on vectors but had different behaviour. 27013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred] 27023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FCmp/ICmp returning bool or vector of bool 27033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 27053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *LHS, *RHS; 27063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 27073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, LHS->getType(), RHS) || 27083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+1 != Record.size()) 2709d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (LHS->getType()->isFPOrFPVectorTy()) 27123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); 27133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 27143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS); 27153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>] 27203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien { 27213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 27223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Size == 0) { 27233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ReturnInst::Create(Context); 27243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 27293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op = NULL; 27303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2731d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpNum != Record.size()) 2733d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ReturnInst::Create(Context, Op); 27363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] 27403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() != 1 && Record.size() != 3) 2741d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *TrueDest = getBasicBlock(Record[0]); 27433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (TrueDest == 0) 2744d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() == 1) { 27473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = BranchInst::Create(TrueDest); 27483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else { 27513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *FalseDest = getBasicBlock(Record[1]); 27523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Cond = getFnValueByID(Record[2], Type::getInt1Ty(Context)); 27533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (FalseDest == 0 || Cond == 0) 2754d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = BranchInst::Create(TrueDest, FalseDest, Cond); 27563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...] 27613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3 || (Record.size() & 1) == 0) 2762d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[0]); 27643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Cond = getFnValueByID(Record[1], OpTy); 27653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *Default = getBasicBlock(Record[2]); 27663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpTy == 0 || Cond == 0 || Default == 0) 2767d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumCases = (Record.size()-3)/2; 27693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); 27703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(SI); 27713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = NumCases; i != e; ++i) { 27723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ConstantInt *CaseVal = 27733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy)); 27743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); 27753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CaseVal == 0 || DestBB == 0) { 27763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete SI; 2777d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SI->addCase(CaseVal, DestBB); 27803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = SI; 27823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] 27853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 2786d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[0]); 27883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Address = getFnValueByID(Record[1], OpTy); 27893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpTy == 0 || Address == 0) 2790d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 27913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumDests = Record.size()-2; 27923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); 27933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(IBI); 27943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = NumDests; i != e; ++i) { 27953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) { 27963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien IBI->addDestination(DestBB); 27973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 27983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete IBI; 2799d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 28003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = IBI; 28033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 28043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 2805c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 28063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INVOKE: { 28073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] 2808d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Record.size() < 4) 2809d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2810b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines AttributeSet PAL = getAttributes(Record[0]); 28113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned CCInfo = Record[1]; 28123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *NormalBB = getBasicBlock(Record[2]); 28133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *UnwindBB = getBasicBlock(Record[3]); 28143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 4; 28163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Callee; 28173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 2818d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 28193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); 28213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionType *FTy = !CalleeTy ? 0 : 28223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast<FunctionType>(CalleeTy->getElementType()); 28233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check that the right number of fixed parameters are here. 28253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (FTy == 0 || NormalBB == 0 || UnwindBB == 0 || 28263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.size() < OpNum+FTy->getNumParams()) 2827d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 28283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Value*, 16> Ops; 28303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 28313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ops.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 2832d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Ops.back() == 0) 2833d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 28343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!FTy->isVarArg()) { 28373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() != OpNum) 2838d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 28393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 28403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read type/value pairs for varargs params. 28413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (OpNum != Record.size()) { 28423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 28433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2844d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 28453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ops.push_back(Op); 28463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops); 28503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 28513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<InvokeInst>(I)->setCallingConv( 28523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien static_cast<CallingConv::ID>(CCInfo)); 28533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<InvokeInst>(I)->setAttributes(PAL); 28543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 28553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_RESUME: { // RESUME: [opval] 28573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Idx = 0; 28583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Val = 0; 28593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, Idx, NextValueNo, Val)) 2860d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 28613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ResumeInst::Create(Val); 28623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 28633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 28643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 2865c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao case FUNC_CODE_INST_UNWIND_2_7: { // UNWIND_OLD 2866c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao // 'unwind' instruction has been removed in LLVM 3.1 2867c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao // Replace 'unwind' with 'landingpad' and 'resume'. 2868c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Type *ExnTy = StructType::get(Type::getInt8PtrTy(Context), 2869c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Type::getInt32Ty(Context), NULL); 2870c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Constant *PersFn = 2871c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao F->getParent()-> 2872c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao getOrInsertFunction("__gcc_personality_v0", 2873c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao FunctionType::get(Type::getInt32Ty(Context), true)); 2874c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 2875c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao LandingPadInst *LP = LandingPadInst::Create(ExnTy, PersFn, 1); 2876c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao LP->setCleanup(true); 2877c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 2878c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao CurBB->getInstList().push_back(LP); 2879c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao I = ResumeInst::Create(LP); 28803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 28813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 2882c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao } 28833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE 28843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new UnreachableInst(Context); 28853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 28863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 28873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...] 28883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1 || ((Record.size()-1)&1)) 2889d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 28903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[0]); 2891d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 2892d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 28933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2); 28953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(PN); 28963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) { 28983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = getFnValueByID(Record[1+i], Ty); 28993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *BB = getBasicBlock(Record[2+i]); 2900d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!V || !BB) 2901d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PN->addIncoming(V, BB); 29033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = PN; 29053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 29063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_LANDINGPAD: { 29093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?] 29103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Idx = 0; 29113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 4) 2912d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[Idx++]); 2914d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty) 2915d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *PersFn = 0; 29173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, Idx, NextValueNo, PersFn)) 2918d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool IsCleanup = !!Record[Idx++]; 29213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumClauses = Record[Idx++]; 29223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LandingPadInst *LP = LandingPadInst::Create(Ty, PersFn, NumClauses); 29233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LP->setCleanup(IsCleanup); 29243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned J = 0; J != NumClauses; ++J) { 29253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LandingPadInst::ClauseType CT = 29263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LandingPadInst::ClauseType(Record[Idx++]); (void)CT; 29273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Val; 29283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, Idx, NextValueNo, Val)) { 29303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete LP; 2931d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert((CT != LandingPadInst::Catch || 29353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien !isa<ArrayType>(Val->getType())) && 29363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien "Catch clause has a invalid type!"); 29373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert((CT != LandingPadInst::Filter || 29383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien isa<ArrayType>(Val->getType())) && 29393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien "Filter clause has invalid type!"); 29403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LP->addClause(Val); 29413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = LP; 29443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 29453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 29463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align] 29493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() != 4) 2950d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PointerType *Ty = 29523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<PointerType>(getTypeByID(Record[0])); 29533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[1]); 29543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Size = getFnValueByID(Record[2], OpTy); 29553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Align = Record[3]; 2956d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!Ty || !Size) 2957d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); 29593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 29603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 29613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol] 29633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 29643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 29653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 29663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+2 != Record.size()) 2967d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); 29703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 29713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 29723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_LOADATOMIC: { 29743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // LOADATOMIC: [opty, op, align, vol, ordering, synchscope] 29753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 29763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 29773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 29783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+4 != Record.size()) 2979d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 2980c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 29813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); 29833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Release || 29843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering == AcquireRelease) 2985d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering != NotAtomic && Record[OpNum] == 0) 2987d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 29883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); 29893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1, 29913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering, SynchScope); 29923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 29933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 29943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_STORE: { // STORE2:[ptrty, ptr, val, align, vol] 29963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 29973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Val, *Ptr; 29983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 29993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), Val) || 30013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+2 != Record.size()) 3002d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 30043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 30053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_STOREATOMIC: { 30093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // STOREATOMIC: [ptrty, ptr, val, align, vol, ordering, synchscope] 30103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 30113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Val, *Ptr; 30123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 30133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), Val) || 30153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+4 != Record.size()) 3016d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 30183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); 30193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Acquire || 30203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering == AcquireRelease) 3021d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); 30233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering != NotAtomic && Record[OpNum] == 0) 3024d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 30263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1, 30273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering, SynchScope); 30283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CMPXCHG: { 30323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // CMPXCHG:[ptrty, ptr, cmp, new, vol, ordering, synchscope] 30333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 30343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Ptr, *Cmp, *New; 30353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 30363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), Cmp) || 30383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), New) || 30403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+3 != Record.size()) 3041d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+1]); 30433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Unordered) 3044d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+2]); 3046c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray I = new AtomicCmpXchgInst(Ptr, Cmp, New, Ordering, Ordering, SynchScope); 30473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]); 30483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_ATOMICRMW: { 30523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // ATOMICRMW:[ptrty, ptr, val, op, vol, ordering, synchscope] 30533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 30543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Ptr, *Val; 30553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 30563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), Val) || 30583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+4 != Record.size()) 3059d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicRMWInst::BinOp Operation = GetDecodedRMWOperation(Record[OpNum]); 30613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Operation < AtomicRMWInst::FIRST_BINOP || 30623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Operation > AtomicRMWInst::LAST_BINOP) 3063d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); 30653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Unordered) 3066d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); 30683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SynchScope); 30693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]); 30703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, synchscope] 30743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (2 != Record.size()) 3075d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[0]); 30773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Unordered || 30783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering == Monotonic) 3079d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[1]); 30813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new FenceInst(Context, Ordering, SynchScope); 30823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CALL: { 30863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] 30873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 3088d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3090b730e239619a546d93e5926ea92d698ab77ec7f6Stephen Hines AttributeSet PAL = getAttributes(Record[0]); 30913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned CCInfo = Record[1]; 30923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 30933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 2; 30943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Callee; 30953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 3096d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 30973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 30983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); 30993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionType *FTy = 0; 31003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType()); 31013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!FTy || Record.size() < FTy->getNumParams()+OpNum) 3102d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 31033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Value*, 16> Args; 31053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read the fixed params. 31063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 31073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (FTy->getParamType(i)->isLabelTy()) 31083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Args.push_back(getBasicBlock(Record[OpNum])); 31093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 31103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Args.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 3111d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (Args.back() == 0) 3112d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 31133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read type/value pairs for varargs params. 31163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!FTy->isVarArg()) { 31173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpNum != Record.size()) 3118d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 31193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 31203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (OpNum != Record.size()) { 31213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 31223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 3123d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 31243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Args.push_back(Op); 31253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = CallInst::Create(Callee, Args); 31293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 31303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<CallInst>(I)->setCallingConv( 31313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien static_cast<CallingConv::ID>(CCInfo>>1)); 31323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<CallInst>(I)->setTailCall(CCInfo & 1); 31333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<CallInst>(I)->setAttributes(PAL); 31343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 31353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] 31373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 3138d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 31393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[0]); 31403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op = getFnValueByID(Record[1], OpTy); 31413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ResTy = getTypeByID(Record[2]); 31423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!OpTy || !Op || !ResTy) 3143d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidRecord); 31443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new VAArgInst(Op, ResTy); 31453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 31463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 31473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Add instruction to end of current BB. If there is no current BB, reject 31513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // this file. 31523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CurBB == 0) { 31533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete I; 3154d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidInstructionWithNoBB); 31553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CurBB->getInstList().push_back(I); 31573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If this was a terminator instruction, move to the next block. 31593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (isa<TerminatorInst>(I)) { 31603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ++CurBBNo; 31613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0; 31623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Non-void values get registered in the value table for future use. 31653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I && !I->getType()->isVoidTy()) 31663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.AssignValue(I, NextValueNo++); 31673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check the function list for unresolved values. 31703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Argument *A = dyn_cast<Argument>(ValueList.back())) { 31713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (A->getParent() == 0) { 31723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // We found at least one unresolved value. Nuke them all to avoid leaks. 31733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){ 31743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((A = dyn_cast<Argument>(ValueList[i])) && A->getParent() == 0) { 31753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien A->replaceAllUsesWith(UndefValue::get(A->getType())); 31763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete A; 31773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 3179d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(NeverResolvedValueFoundInFunction); 31803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FIXME: Check for unresolved forward-declared metadata references 31843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // and clean up leaks. 31853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // See if anything took the address of blocks in this function. If so, 31873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // resolve them now. 31883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DenseMap<Function*, std::vector<BlockAddrRefTy> >::iterator BAFRI = 31893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BlockAddrFwdRefs.find(F); 31903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BAFRI != BlockAddrFwdRefs.end()) { 31913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<BlockAddrRefTy> &RefList = BAFRI->second; 31923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = RefList.size(); i != e; ++i) { 31933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned BlockIdx = RefList[i].first; 31943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BlockIdx >= FunctionBBs.size()) 3195d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidID); 3196c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 31973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalVariable *FwdRef = RefList[i].second; 31983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx])); 31993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FwdRef->eraseFromParent(); 32003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 3201c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 32023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BlockAddrFwdRefs.erase(BAFRI); 32033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 3204c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 32053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Trim the value list down to the size it was before we parsed this function. 32063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.shrinkTo(ModuleValueListSize); 32073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValueList.shrinkTo(ModuleMDValueListSize); 32083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<BasicBlock*>().swap(FunctionBBs); 3209d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 32103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 32113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 32133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// GVMaterializer implementation 32143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 32153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::isMaterializable(const GlobalValue *GV) const { 32183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (const Function *F = dyn_cast<Function>(GV)) { 32193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return F->isDeclaration() && 32203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DeferredFunctionInfo.count(const_cast<Function*>(F)); 32213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 32233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 32243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3225d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::Materialize(GlobalValue *GV) { 32263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *F = dyn_cast<Function>(GV); 32273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If it's not a function or is already material, ignore the request. 3228d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (!F || !F->isMaterializable()) 3229d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 32303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F); 32323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!"); 32333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Move the bit stream to the saved position of the deferred function body. 32353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.JumpToBit(DFII->second); 32363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3237d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = ParseFunctionBody(F)) 3238d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 32393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Upgrade any old intrinsic calls in the function. 32413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(), 32423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien E = UpgradedIntrinsics.end(); I != E; ++I) { 32433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I->first != I->second) { 32443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (Value::use_iterator UI = I->first->use_begin(), 32453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UE = I->first->use_end(); UI != UE; ) { 32463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 32473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UpgradeIntrinsicCall(CI, I->second); 32483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3252d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 32533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 32543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::isDematerializable(const GlobalValue *GV) const { 32563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien const Function *F = dyn_cast<Function>(GV); 32573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!F || F->isDeclaration()) 32583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 32593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return DeferredFunctionInfo.count(const_cast<Function*>(F)); 32603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 32613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReader::Dematerialize(GlobalValue *GV) { 32633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *F = dyn_cast<Function>(GV); 32643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If this function isn't dematerializable, this is a noop. 32653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!F || !isDematerializable(F)) 32663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 32673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(DeferredFunctionInfo.count(F) && "No info to read function later?"); 32693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Just forget the function body, we can remat it later. 32713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien F->deleteBody(); 32723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 32733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3275d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::MaterializeModule(Module *M) { 32763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(M == TheModule && 32773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien "Can only Materialize the Module this BitcodeReader is attached to."); 32783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Iterate over the module, deserializing any functions that are still on 32793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // disk. 32803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (Module::iterator F = TheModule->begin(), E = TheModule->end(); 3281d724d097437f40a5689464429f948ec41e4a2415Stephen Hines F != E; ++F) { 3282d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (F->isMaterializable()) { 3283d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = Materialize(F)) 3284d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return EC; 3285d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3286d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 32873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Upgrade any intrinsic calls that slipped through (should not happen!) and 32893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // delete the old functions to clean up. We can't do this unless the entire 32903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // module is materialized because there could always be another function body 32913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // with calls to the old function. 32923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (std::vector<std::pair<Function*, Function*> >::iterator I = 32933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) { 32943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I->first != I->second) { 32953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (Value::use_iterator UI = I->first->use_begin(), 32963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UE = I->first->use_end(); UI != UE; ) { 32973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 32983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UpgradeIntrinsicCall(CI, I->second); 32993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 33003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!I->first->use_empty()) 33013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I->first->replaceAllUsesWith(I->second); 33023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I->first->eraseFromParent(); 33033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 33043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 33053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics); 33063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Upgrade to new EH scheme. N.B. This will go away in 3.1. 33083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UpgradeExceptionHandling(M); 33093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check debug info intrinsics. 33113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CheckDebugInfoIntrinsics(TheModule); 33123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3313d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 33143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 33153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3316d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::InitStream() { 3317d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (LazyStreamer) 3318d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return InitLazyStream(); 3319d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines return InitStreamFromBuffer(); 3320d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 3321d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3322d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::InitStreamFromBuffer() { 3323d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *BufPtr = (const unsigned char*)Buffer->getBufferStart(); 3324d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); 3325d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3326d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (Buffer->getBufferSize() & 3) { 3327d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isRawBitcode(BufPtr, BufEnd) && !isBitcodeWrapper(BufPtr, BufEnd)) 3328d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 3329d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines else 3330d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(BitcodeStreamInvalidSize); 3331d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 3332d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3333d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // If we have a wrapper header, parse it and ignore the non-bc file contents. 3334d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // The magic number is 0x0B17C0DE stored in little endian. 3335d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (isBitcodeWrapper(BufPtr, BufEnd)) 3336d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true)) 3337d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeWrapperHeader); 3338d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3339d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamFile.reset(new BitstreamReader(BufPtr, BufEnd)); 3340d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.init(*StreamFile); 3341d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3342d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 3343d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 3344d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3345d724d097437f40a5689464429f948ec41e4a2415Stephen Hineserror_code BitcodeReader::InitLazyStream() { 3346d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // Check and strip off the bitcode wrapper; BitstreamReader expects never to 3347d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines // see it. 3348d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamingMemoryObject *Bytes = new StreamingMemoryObject(LazyStreamer); 3349d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines StreamFile.reset(new BitstreamReader(Bytes)); 3350d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Stream.init(*StreamFile); 3351d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3352d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines unsigned char buf[16]; 335388f8c52abea50f411c3774c935a6a1e04d17c182Stephen Hines if (Bytes->readBytes(0, 16, buf) == -1) 3354d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(BitcodeStreamInvalidSize); 3355d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3356d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (!isBitcode(buf, buf + 16)) 3357d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return Error(InvalidBitcodeSignature); 3358d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines 3359d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines if (isBitcodeWrapper(buf, buf + 4)) { 3360d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *bitcodeStart = buf; 3361d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines const unsigned char *bitcodeEnd = buf + 16; 3362d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false); 3363d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Bytes->dropLeadingBytes(bitcodeStart - buf); 3364d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines Bytes->setKnownObjectSize(bitcodeEnd - bitcodeStart); 3365d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines } 3366d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return error_code::success(); 3367d724d097437f40a5689464429f948ec41e4a2415Stephen Hines} 3368d724d097437f40a5689464429f948ec41e4a2415Stephen Hines 3369d724d097437f40a5689464429f948ec41e4a2415Stephen Hinesnamespace { 3370d724d097437f40a5689464429f948ec41e4a2415Stephen Hinesclass BitcodeErrorCategoryType : public _do_message { 3371c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray const char *name() const override { 3372d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "llvm.bitcode"; 3373d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3374c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray std::string message(int IE) const override { 3375d724d097437f40a5689464429f948ec41e4a2415Stephen Hines BitcodeReader::ErrorType E = static_cast<BitcodeReader::ErrorType>(IE); 3376d724d097437f40a5689464429f948ec41e4a2415Stephen Hines switch (E) { 3377d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::BitcodeStreamInvalidSize: 3378d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Bitcode stream length should be >= 16 bytes and a multiple of 4"; 3379d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::ConflictingMETADATA_KINDRecords: 3380d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Conflicting METADATA_KIND records"; 3381d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::CouldNotFindFunctionInStream: 3382d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Could not find function in stream"; 3383d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::ExpectedConstant: 3384d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Expected a constant"; 3385d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InsufficientFunctionProtos: 3386d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Insufficient function protos"; 3387d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidBitcodeSignature: 3388d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid bitcode signature"; 3389d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidBitcodeWrapperHeader: 3390d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid bitcode wrapper header"; 3391d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidConstantReference: 3392d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid ronstant reference"; 3393d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidID: 3394d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid ID"; 3395d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidInstructionWithNoBB: 3396d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid instruction with no BB"; 3397d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidRecord: 3398d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid record"; 3399d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidTypeForValue: 3400d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid type for value"; 3401d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidTYPETable: 3402d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid TYPE table"; 3403d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidType: 3404d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid type"; 3405d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::MalformedBlock: 3406d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Malformed block"; 3407d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::MalformedGlobalInitializerSet: 3408d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Malformed global initializer set"; 3409d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidMultipleBlocks: 3410d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid multiple blocks"; 3411d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::NeverResolvedValueFoundInFunction: 3412d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Never resolved value found in function"; 3413d724d097437f40a5689464429f948ec41e4a2415Stephen Hines case BitcodeReader::InvalidValue: 3414d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return "Invalid value"; 3415d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3416d724d097437f40a5689464429f948ec41e4a2415Stephen Hines llvm_unreachable("Unknown error type!"); 3417d724d097437f40a5689464429f948ec41e4a2415Stephen Hines } 3418d724d097437f40a5689464429f948ec41e4a2415Stephen Hines}; 3419d724d097437f40a5689464429f948ec41e4a2415Stephen Hines} 3420d724d097437f40a5689464429f948ec41e4a2415Stephen Hines 3421d724d097437f40a5689464429f948ec41e4a2415Stephen Hinesconst error_category &BitcodeReader::BitcodeErrorCategory() { 3422d724d097437f40a5689464429f948ec41e4a2415Stephen Hines static BitcodeErrorCategoryType O; 3423d724d097437f40a5689464429f948ec41e4a2415Stephen Hines return O; 3424d9216ebb9c114242b713cd4dad33b3a83eb86761Stephen Hines} 34253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 34273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// External interface 34283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 34293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// getLazyBitcodeModule - lazy function-at-a-time loading from a file. 34313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// 3432c7d67a701663191bcdab2416c11b69fae16d49fbLogan ChienModule *llvm_3_0::getLazyBitcodeModule(MemoryBuffer *Buffer, 3433c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LLVMContext& Context, 3434c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien std::string *ErrMsg) { 34353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Module *M = new Module(Buffer->getBufferIdentifier(), Context); 34363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BitcodeReader *R = new BitcodeReader(Buffer, Context); 34373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien M->setMaterializer(R); 3438d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = R->ParseBitcodeInto(M)) { 34393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ErrMsg) 3440d724d097437f40a5689464429f948ec41e4a2415Stephen Hines *ErrMsg = EC.message(); 34413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete M; // Also deletes R. 34433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return 0; 34443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 34453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Have the BitcodeReader dtor delete 'Buffer'. 34463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien R->setBufferOwned(true); 34473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return M; 34483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 34493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ParseBitcodeFile - Read the specified bitcode file, returning the module. 34513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// If an error occurs, return null and fill in *ErrMsg if non-null. 3452c7d67a701663191bcdab2416c11b69fae16d49fbLogan ChienModule *llvm_3_0::ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext& Context, 3453c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien std::string *ErrMsg){ 3454c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Module *M = llvm_3_0::getLazyBitcodeModule(Buffer, Context, ErrMsg); 34553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!M) return 0; 34563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether 34583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // there was an error. 34593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien static_cast<BitcodeReader*>(M->getMaterializer())->setBufferOwned(false); 34603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read in the entire module, and destroy the BitcodeReader. 3462c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray if (llvm::error_code ec = M->materializeAllPermanently()) { 3463c2074caf075818abb6d3689ad924ca09f4a5ba1fTim Murray *ErrMsg = ec.message(); 34643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete M; 34653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return 0; 34663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 34673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return M; 34693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 34703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3471c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chienstd::string llvm_3_0::getBitcodeTargetTriple(MemoryBuffer *Buffer, 3472c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LLVMContext& Context, 3473c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien std::string *ErrMsg) { 34743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BitcodeReader *R = new BitcodeReader(Buffer, Context); 34753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Don't let the BitcodeReader dtor delete 'Buffer'. 34763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien R->setBufferOwned(false); 34773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string Triple(""); 3479d724d097437f40a5689464429f948ec41e4a2415Stephen Hines if (error_code EC = R->ParseTriple(Triple)) 34803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ErrMsg) 3481d724d097437f40a5689464429f948ec41e4a2415Stephen Hines *ErrMsg = EC.message(); 34823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 34833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete R; 34843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Triple; 34853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3486