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/Constants.h" 183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/DerivedTypes.h" 193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/InlineAsm.h" 203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/IntrinsicInst.h" 218b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao#include "llvm/IRBuilder.h" 223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/Module.h" 233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/Operator.h" 243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/AutoUpgrade.h" 25c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien#include "llvm/ADT/SmallPtrSet.h" 263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/ADT/SmallString.h" 273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/ADT/SmallVector.h" 28c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien#include "llvm/Support/CFG.h" 293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/Support/MathExtras.h" 303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/Support/MemoryBuffer.h" 313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien#include "llvm/OperandTraits.h" 323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienusing namespace llvm; 33c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chienusing namespace llvm_3_0; 34c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 35c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao#define FUNC_CODE_INST_UNWIND_2_7 14 36c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao#define eh_exception_2_7 145 37c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao#define eh_selector_2_7 149 38c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 39c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien#define TYPE_BLOCK_ID_OLD_3_0 10 40c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien#define TYPE_SYMTAB_BLOCK_ID_OLD_3_0 13 41c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien#define TYPE_CODE_STRUCT_OLD_3_0 10 42c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 43c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chiennamespace { 44c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien void FindExnAndSelIntrinsics(BasicBlock *BB, CallInst *&Exn, 45c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *&Sel, 46c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien SmallPtrSet<BasicBlock*, 8> &Visited) { 47c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!Visited.insert(BB)) return; 48c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 49c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (BasicBlock::iterator 50c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien I = BB->begin(), E = BB->end(); I != E; ++I) { 51c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (CallInst *CI = dyn_cast<CallInst>(I)) { 52c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien switch (CI->getCalledFunction()->getIntrinsicID()) { 53c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien default: break; 54c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao case eh_exception_2_7: 55c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien assert(!Exn && "Found more than one eh.exception call!"); 56c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Exn = CI; 57c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien break; 58c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao case eh_selector_2_7: 59c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien assert(!Sel && "Found more than one eh.selector call!"); 60c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Sel = CI; 61c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien break; 62c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 63c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 64c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Exn && Sel) return; 65c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 66c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 67c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 68c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Exn && Sel) return; 69c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 70c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (succ_iterator I = succ_begin(BB), E = succ_end(BB); I != E; ++I) { 71c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien FindExnAndSelIntrinsics(*I, Exn, Sel, Visited); 72c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Exn && Sel) return; 73c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 74c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 75c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 76c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 77c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 78c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// TransferClausesToLandingPadInst - Transfer the exception handling clauses 79c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// from the eh_selector call to the new landingpad instruction. 80c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien void TransferClausesToLandingPadInst(LandingPadInst *LPI, 81c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *EHSel) { 82c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LLVMContext &Context = LPI->getContext(); 83c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien unsigned N = EHSel->getNumArgOperands(); 84c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 85c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (unsigned i = N - 1; i > 1; --i) { 86c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (const ConstantInt *CI = dyn_cast<ConstantInt>(EHSel->getArgOperand(i))){ 87c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien unsigned FilterLength = CI->getZExtValue(); 88c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien unsigned FirstCatch = i + FilterLength + !FilterLength; 89c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien assert(FirstCatch <= N && "Invalid filter length"); 90c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 91c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (FirstCatch < N) 92c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (unsigned j = FirstCatch; j < N; ++j) { 93c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Value *Val = EHSel->getArgOperand(j); 94c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!Val->hasName() || Val->getName() != "llvm.eh.catch.all.value") { 95c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LPI->addClause(EHSel->getArgOperand(j)); 96c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } else { 97c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien GlobalVariable *GV = cast<GlobalVariable>(Val); 98c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LPI->addClause(GV->getInitializer()); 99c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 100c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 101c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 102c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!FilterLength) { 103c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // Cleanup. 104c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LPI->setCleanup(true); 105c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } else { 106c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // Filter. 107c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien SmallVector<Constant *, 4> TyInfo; 108c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien TyInfo.reserve(FilterLength - 1); 109c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (unsigned j = i + 1; j < FirstCatch; ++j) 110c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien TyInfo.push_back(cast<Constant>(EHSel->getArgOperand(j))); 111c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien ArrayType *AType = 112c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien ArrayType::get(!TyInfo.empty() ? TyInfo[0]->getType() : 113c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien PointerType::getUnqual(Type::getInt8Ty(Context)), 114c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien TyInfo.size()); 115c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LPI->addClause(ConstantArray::get(AType, TyInfo)); 116c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 117c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 118c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien N = i; 119c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 120c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 121c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 122c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (N > 2) 123c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (unsigned j = 2; j < N; ++j) { 124c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Value *Val = EHSel->getArgOperand(j); 125c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!Val->hasName() || Val->getName() != "llvm.eh.catch.all.value") { 126c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LPI->addClause(EHSel->getArgOperand(j)); 127c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } else { 128c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien GlobalVariable *GV = cast<GlobalVariable>(Val); 129c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LPI->addClause(GV->getInitializer()); 130c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 131c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 132c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 133c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 134c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 135c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// This function upgrades the old pre-3.0 exception handling system to the new 136c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// one. N.B. This will be removed in 3.1. 137c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien void UpgradeExceptionHandling(Module *M) { 138c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Function *EHException = M->getFunction("llvm.eh.exception"); 139c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Function *EHSelector = M->getFunction("llvm.eh.selector"); 140c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!EHException || !EHSelector) 141c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien return; 142c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 143c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LLVMContext &Context = M->getContext(); 144c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Type *ExnTy = PointerType::getUnqual(Type::getInt8Ty(Context)); 145c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Type *SelTy = Type::getInt32Ty(Context); 146c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Type *LPadSlotTy = StructType::get(ExnTy, SelTy, NULL); 147c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 148c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // This map links the invoke instruction with the eh.exception and eh.selector 149c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // calls associated with it. 150c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien DenseMap<InvokeInst*, std::pair<Value*, Value*> > InvokeToIntrinsicsMap; 151c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (Module::iterator 152c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien I = M->begin(), E = M->end(); I != E; ++I) { 153c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Function &F = *I; 154c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 155c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (Function::iterator 156c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien II = F.begin(), IE = F.end(); II != IE; ++II) { 157c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BasicBlock *BB = &*II; 158c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien InvokeInst *Inst = dyn_cast<InvokeInst>(BB->getTerminator()); 159c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!Inst) continue; 160c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BasicBlock *UnwindDest = Inst->getUnwindDest(); 161c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (UnwindDest->isLandingPad()) continue; // Already converted. 162c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 163c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien SmallPtrSet<BasicBlock*, 8> Visited; 164c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *Exn = 0; 165c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *Sel = 0; 166c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien FindExnAndSelIntrinsics(UnwindDest, Exn, Sel, Visited); 167c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien assert(Exn && Sel && "Cannot find eh.exception and eh.selector calls!"); 168c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien InvokeToIntrinsicsMap[Inst] = std::make_pair(Exn, Sel); 169c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 170c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 171c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 172c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // This map stores the slots where the exception object and selector value are 173c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // stored within a function. 174c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien DenseMap<Function*, std::pair<Value*, Value*> > FnToLPadSlotMap; 175c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien SmallPtrSet<Instruction*, 32> DeadInsts; 176c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (DenseMap<InvokeInst*, std::pair<Value*, Value*> >::iterator 177c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien I = InvokeToIntrinsicsMap.begin(), E = InvokeToIntrinsicsMap.end(); 178c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien I != E; ++I) { 179c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien InvokeInst *Invoke = I->first; 180c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BasicBlock *UnwindDest = Invoke->getUnwindDest(); 181c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Function *F = UnwindDest->getParent(); 182c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien std::pair<Value*, Value*> EHIntrinsics = I->second; 183c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *Exn = cast<CallInst>(EHIntrinsics.first); 184c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *Sel = cast<CallInst>(EHIntrinsics.second); 185c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 186c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // Store the exception object and selector value in the entry block. 187c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Value *ExnSlot = 0; 188c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Value *SelSlot = 0; 189c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!FnToLPadSlotMap[F].first) { 190c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BasicBlock *Entry = &F->front(); 191c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien ExnSlot = new AllocaInst(ExnTy, "exn", Entry->getTerminator()); 192c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien SelSlot = new AllocaInst(SelTy, "sel", Entry->getTerminator()); 193c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien FnToLPadSlotMap[F] = std::make_pair(ExnSlot, SelSlot); 194c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } else { 195c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien ExnSlot = FnToLPadSlotMap[F].first; 196c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien SelSlot = FnToLPadSlotMap[F].second; 197c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 198c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 199c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!UnwindDest->getSinglePredecessor()) { 200c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // The unwind destination doesn't have a single predecessor. Create an 201c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // unwind destination which has only one predecessor. 202c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BasicBlock *NewBB = BasicBlock::Create(Context, "new.lpad", 203c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien UnwindDest->getParent()); 204c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BranchInst::Create(UnwindDest, NewBB); 205c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Invoke->setUnwindDest(NewBB); 206c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 207c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // Fix up any PHIs in the original unwind destination block. 208c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (BasicBlock::iterator 209c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien II = UnwindDest->begin(); isa<PHINode>(II); ++II) { 210c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien PHINode *PN = cast<PHINode>(II); 211c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien int Idx = PN->getBasicBlockIndex(Invoke->getParent()); 212c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Idx == -1) continue; 213c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien PN->setIncomingBlock(Idx, NewBB); 214c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 215c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 216c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien UnwindDest = NewBB; 217c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 218c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 219c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien IRBuilder<> Builder(Context); 220c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Builder.SetInsertPoint(UnwindDest, UnwindDest->getFirstInsertionPt()); 221c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 222c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Value *PersFn = Sel->getArgOperand(1); 223c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LandingPadInst *LPI = Builder.CreateLandingPad(LPadSlotTy, PersFn, 0); 224c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Value *LPExn = Builder.CreateExtractValue(LPI, 0); 225c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Value *LPSel = Builder.CreateExtractValue(LPI, 1); 226c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Builder.CreateStore(LPExn, ExnSlot); 227c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Builder.CreateStore(LPSel, SelSlot); 228c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 229c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien TransferClausesToLandingPadInst(LPI, Sel); 230c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 231c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien DeadInsts.insert(Exn); 232c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien DeadInsts.insert(Sel); 233c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 234c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 235c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // Replace the old intrinsic calls with the values from the landingpad 236c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // instruction(s). These values were stored in allocas for us to use here. 237c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (DenseMap<InvokeInst*, std::pair<Value*, Value*> >::iterator 238c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien I = InvokeToIntrinsicsMap.begin(), E = InvokeToIntrinsicsMap.end(); 239c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien I != E; ++I) { 240c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien std::pair<Value*, Value*> EHIntrinsics = I->second; 241c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *Exn = cast<CallInst>(EHIntrinsics.first); 242c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *Sel = cast<CallInst>(EHIntrinsics.second); 243c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BasicBlock *Parent = Exn->getParent(); 244c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 245c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien std::pair<Value*,Value*> ExnSelSlots = FnToLPadSlotMap[Parent->getParent()]; 246c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 247c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien IRBuilder<> Builder(Context); 248c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Builder.SetInsertPoint(Parent, Exn); 249c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LoadInst *LPExn = Builder.CreateLoad(ExnSelSlots.first, "exn.load"); 250c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LoadInst *LPSel = Builder.CreateLoad(ExnSelSlots.second, "sel.load"); 251c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 252c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Exn->replaceAllUsesWith(LPExn); 253c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Sel->replaceAllUsesWith(LPSel); 254c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 255c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 256c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // Remove the dead instructions. 257c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien for (SmallPtrSet<Instruction*, 32>::iterator 258c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien I = DeadInsts.begin(), E = DeadInsts.end(); I != E; ++I) { 259c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Instruction *Inst = *I; 260c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Inst->eraseFromParent(); 261c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 262c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 263c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // Replace calls to "llvm.eh.resume" with the 'resume' instruction. Load the 264c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // exception and selector values from the stored place. 265c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Function *EHResume = M->getFunction("llvm.eh.resume"); 266c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!EHResume) return; 267c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 268c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien while (!EHResume->use_empty()) { 269c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *Resume = cast<CallInst>(EHResume->use_back()); 270c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BasicBlock *BB = Resume->getParent(); 271c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 272c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien IRBuilder<> Builder(Context); 273c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Builder.SetInsertPoint(BB, Resume); 274c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 275c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Value *LPadVal = 276c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Builder.CreateInsertValue(UndefValue::get(LPadSlotTy), 277c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Resume->getArgOperand(0), 0, "lpad.val"); 278c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LPadVal = Builder.CreateInsertValue(LPadVal, Resume->getArgOperand(1), 279c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 1, "lpad.val"); 280c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Builder.CreateResume(LPadVal); 281c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 282c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien // Remove all instructions after the 'resume.' 283c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien BasicBlock::iterator I = Resume; 284c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien while (I != BB->end()) { 285c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Instruction *Inst = &*I++; 286c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Inst->eraseFromParent(); 287c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 288c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 289c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 290c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 291c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 292c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// This function strips all debug info intrinsics, except for llvm.dbg.declare. 293c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// If an llvm.dbg.declare intrinsic is invalid, then this function simply 294c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien /// strips that use. 295c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien void CheckDebugInfoIntrinsics(Module *M) { 296c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Function *FuncStart = M->getFunction("llvm.dbg.func.start")) { 297c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien while (!FuncStart->use_empty()) 298c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien cast<CallInst>(FuncStart->use_back())->eraseFromParent(); 299c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien FuncStart->eraseFromParent(); 300c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 301c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 302c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Function *StopPoint = M->getFunction("llvm.dbg.stoppoint")) { 303c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien while (!StopPoint->use_empty()) 304c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien cast<CallInst>(StopPoint->use_back())->eraseFromParent(); 305c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien StopPoint->eraseFromParent(); 306c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 307c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 308c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Function *RegionStart = M->getFunction("llvm.dbg.region.start")) { 309c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien while (!RegionStart->use_empty()) 310c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien cast<CallInst>(RegionStart->use_back())->eraseFromParent(); 311c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien RegionStart->eraseFromParent(); 312c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 313c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 314c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Function *RegionEnd = M->getFunction("llvm.dbg.region.end")) { 315c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien while (!RegionEnd->use_empty()) 316c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien cast<CallInst>(RegionEnd->use_back())->eraseFromParent(); 317c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien RegionEnd->eraseFromParent(); 318c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 319c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 320c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Function *Declare = M->getFunction("llvm.dbg.declare")) { 321c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!Declare->use_empty()) { 322c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien DbgDeclareInst *DDI = cast<DbgDeclareInst>(Declare->use_back()); 323c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (!isa<MDNode>(DDI->getArgOperand(0)) || 324c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien !isa<MDNode>(DDI->getArgOperand(1))) { 325c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien while (!Declare->use_empty()) { 326c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CallInst *CI = cast<CallInst>(Declare->use_back()); 327c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien CI->eraseFromParent(); 328c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 329c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Declare->eraseFromParent(); 330c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 331c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 332c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 333c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 334c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien} // end anonymous namespace 3353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReader::FreeState() { 3373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BufferOwned) 3383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete Buffer; 3393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Buffer = 0; 3403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Type*>().swap(TypeList); 3413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.clear(); 3423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValueList.clear(); 3433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<AttrListPtr>().swap(MAttributes); 3453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<BasicBlock*>().swap(FunctionBBs); 3463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Function*>().swap(FunctionsWithBodies); 3473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DeferredFunctionInfo.clear(); 3483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDKindMap.clear(); 3493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 3523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// Helper functions to implement forward reference resolution, etc. 3533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 3543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ConvertToString - Convert a string from a record into an std::string, return 3563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// true on failure. 3573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chientemplate<typename StrTy> 3583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic bool ConvertToString(SmallVector<uint64_t, 64> &Record, unsigned Idx, 3593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien StrTy &Result) { 3603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx > Record.size()) 3613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return true; 3623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = Idx, e = Record.size(); i != e; ++i) 3643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Result += (char)Record[i]; 3653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 3663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) { 3693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 3703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Map unknown/new linkages to external 3713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 0: return GlobalValue::ExternalLinkage; 3723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 1: return GlobalValue::WeakAnyLinkage; 3733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 2: return GlobalValue::AppendingLinkage; 3743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 3: return GlobalValue::InternalLinkage; 3753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 4: return GlobalValue::LinkOnceAnyLinkage; 3763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 5: return GlobalValue::DLLImportLinkage; 3773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 6: return GlobalValue::DLLExportLinkage; 3783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 7: return GlobalValue::ExternalWeakLinkage; 3793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 8: return GlobalValue::CommonLinkage; 3803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 9: return GlobalValue::PrivateLinkage; 3813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 10: return GlobalValue::WeakODRLinkage; 3823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 11: return GlobalValue::LinkOnceODRLinkage; 3833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 12: return GlobalValue::AvailableExternallyLinkage; 3843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 13: return GlobalValue::LinkerPrivateLinkage; 3853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 14: return GlobalValue::LinkerPrivateWeakLinkage; 386dd9c0baa7efb4b31dc2360c78759ece6ca81073fStephen Hines case 15: return GlobalValue::LinkOnceODRAutoHideLinkage; 3873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 3883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) { 3913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 3923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Map unknown visibilities to default. 3933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 0: return GlobalValue::DefaultVisibility; 3943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 1: return GlobalValue::HiddenVisibility; 3953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case 2: return GlobalValue::ProtectedVisibility; 3963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 3973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3998b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liaostatic GlobalVariable::ThreadLocalMode GetDecodedThreadLocalMode(unsigned Val) { 4008b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao switch (Val) { 4018b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 0: return GlobalVariable::NotThreadLocal; 4028b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao default: // Map unknown non-zero value to general dynamic. 4038b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 1: return GlobalVariable::GeneralDynamicTLSModel; 4048b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 2: return GlobalVariable::LocalDynamicTLSModel; 4058b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 3: return GlobalVariable::InitialExecTLSModel; 4068b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao case 4: return GlobalVariable::LocalExecTLSModel; 4078b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao } 4088b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao} 4098b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao 4103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic int GetDecodedCastOpcode(unsigned Val) { 4113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: return -1; 4133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_TRUNC : return Instruction::Trunc; 4143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_ZEXT : return Instruction::ZExt; 4153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_SEXT : return Instruction::SExt; 4163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_FPTOUI : return Instruction::FPToUI; 4173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_FPTOSI : return Instruction::FPToSI; 4183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_UITOFP : return Instruction::UIToFP; 4193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_SITOFP : return Instruction::SIToFP; 4203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_FPTRUNC : return Instruction::FPTrunc; 4213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_FPEXT : return Instruction::FPExt; 4223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_PTRTOINT: return Instruction::PtrToInt; 4233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_INTTOPTR: return Instruction::IntToPtr; 4243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CAST_BITCAST : return Instruction::BitCast; 4253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic int GetDecodedBinaryOpcode(unsigned Val, Type *Ty) { 4283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: return -1; 4303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_ADD: 4313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FAdd : Instruction::Add; 4323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_SUB: 4333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FSub : Instruction::Sub; 4343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_MUL: 4353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FMul : Instruction::Mul; 4363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_UDIV: return Instruction::UDiv; 4373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_SDIV: 4383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FDiv : Instruction::SDiv; 4393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_UREM: return Instruction::URem; 4403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_SREM: 4413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty->isFPOrFPVectorTy() ? Instruction::FRem : Instruction::SRem; 4423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_SHL: return Instruction::Shl; 4433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_LSHR: return Instruction::LShr; 4443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_ASHR: return Instruction::AShr; 4453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_AND: return Instruction::And; 4463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_OR: return Instruction::Or; 4473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BINOP_XOR: return Instruction::Xor; 4483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 4513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic AtomicRMWInst::BinOp GetDecodedRMWOperation(unsigned Val) { 4523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: return AtomicRMWInst::BAD_BINOP; 4543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_XCHG: return AtomicRMWInst::Xchg; 4553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_ADD: return AtomicRMWInst::Add; 4563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_SUB: return AtomicRMWInst::Sub; 4573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_AND: return AtomicRMWInst::And; 4583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_NAND: return AtomicRMWInst::Nand; 4593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_OR: return AtomicRMWInst::Or; 4603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_XOR: return AtomicRMWInst::Xor; 4613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_MAX: return AtomicRMWInst::Max; 4623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_MIN: return AtomicRMWInst::Min; 4633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_UMAX: return AtomicRMWInst::UMax; 4643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::RMW_UMIN: return AtomicRMWInst::UMin; 4653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 4683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic AtomicOrdering GetDecodedOrdering(unsigned Val) { 4693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_NOTATOMIC: return NotAtomic; 4713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_UNORDERED: return Unordered; 4723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_MONOTONIC: return Monotonic; 4733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_ACQUIRE: return Acquire; 4743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_RELEASE: return Release; 4753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_ACQREL: return AcquireRelease; 4763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Map unknown orderings to sequentially-consistent. 4773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::ORDERING_SEQCST: return SequentiallyConsistent; 4783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 4813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic SynchronizationScope GetDecodedSynchScope(unsigned Val) { 4823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Val) { 4833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::SYNCHSCOPE_SINGLETHREAD: return SingleThread; 4843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Map unknown scopes to cross-thread. 4853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::SYNCHSCOPE_CROSSTHREAD: return CrossThread; 4863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 4873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 4883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 4893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chiennamespace llvm { 4903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chiennamespace { 4913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// @brief A class for maintaining the slot number definition 4923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// as a placeholder for the actual definition for forward constants defs. 4933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien class ConstantPlaceHolder : public ConstantExpr { 4943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien void operator=(const ConstantPlaceHolder &); // DO NOT IMPLEMENT 4953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien public: 4963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // allocate space for exactly one operand 4973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien void *operator new(size_t s) { 4983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return User::operator new(s, 1); 4993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien explicit ConstantPlaceHolder(Type *Ty, LLVMContext& Context) 5013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) { 5023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Op<0>() = UndefValue::get(Type::getInt32Ty(Context)); 5033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// @brief Methods to support type inquiry through isa, cast, and dyn_cast. 5063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien //static inline bool classof(const ConstantPlaceHolder *) { return true; } 5073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien static bool classof(const Value *V) { 5083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return isa<ConstantExpr>(V) && 5093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1; 5103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// Provide fast operand accessors 5143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien //DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 5153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien }; 5163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// FIXME: can we inherit this from ConstantExpr? 5193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chientemplate <> 5203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstruct OperandTraits<ConstantPlaceHolder> : 5213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien public FixedNumOperandTraits<ConstantPlaceHolder, 1> { 5223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien}; 5233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) { 5273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx == size()) { 5283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien push_back(V); 5293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 5303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 5333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx+1); 5343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien WeakVH &OldV = ValuePtrs[Idx]; 5363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OldV == 0) { 5373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV = V; 5383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 5393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Handle constants and non-constants (e.g. instrs) differently for 5423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // efficiency. 5433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Constant *PHC = dyn_cast<Constant>(&*OldV)) { 5443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResolveConstants.push_back(std::make_pair(PHC, Idx)); 5453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV = V; 5463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 5473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If there was a forward reference to this value, replace it. 5483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *PrevVal = OldV; 5493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV->replaceAllUsesWith(V); 5503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete PrevVal; 5513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienConstant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, 5563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty) { 5573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 5583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx + 1); 5593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Value *V = ValuePtrs[Idx]) { 5613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(Ty == V->getType() && "Type mismatch in constant table!"); 5623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return cast<Constant>(V); 5633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Create and return a placeholder, which will later be RAUW'd. 5663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *C = new ConstantPlaceHolder(Ty, Context); 5673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValuePtrs[Idx] = C; 5683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return C; 5693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienValue *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty) { 5723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 5733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx + 1); 5743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Value *V = ValuePtrs[Idx]) { 5763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!"); 5773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V; 5783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 5793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No type specified, must be invalid reference. 5813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ty == 0) return 0; 5823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Create and return a placeholder, which will later be RAUW'd. 5843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = new Argument(Ty); 5853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValuePtrs[Idx] = V; 5863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V; 5873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 5883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 5893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ResolveConstantForwardRefs - Once all constants are read, this method bulk 5903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// resolves any forward references. The idea behind this is that we sometimes 5913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// get constants (such as large arrays) which reference *many* forward ref 5923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// constants. Replacing each of these causes a lot of thrashing when 5933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// building/reuniquing the constant. Instead of doing this, we look at all the 5943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// uses and rewrite all the place holders at once for any constant that uses 5953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// a placeholder. 5963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReaderValueList::ResolveConstantForwardRefs() { 5973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Sort the values by-pointer so that they are efficient to look up with a 5983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // binary search. 5993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::sort(ResolveConstants.begin(), ResolveConstants.end()); 6003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Constant*, 64> NewOps; 6023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!ResolveConstants.empty()) { 6043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *RealVal = operator[](ResolveConstants.back().second); 6053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Placeholder = ResolveConstants.back().first; 6063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResolveConstants.pop_back(); 6073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Loop over all users of the placeholder, updating them to reference the 6093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // new value. If they reference more than one placeholder, update them all 6103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // at once. 6113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!Placeholder->use_empty()) { 6123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value::use_iterator UI = Placeholder->use_begin(); 6133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien User *U = *UI; 6143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If the using object isn't uniqued, just update the operands. This 6163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // handles instructions and initializers for global variables. 6173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!isa<Constant>(U) || isa<GlobalValue>(U)) { 6183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UI.getUse().set(RealVal); 6193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 6203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Otherwise, we have a constant that uses the placeholder. Replace that 6233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // constant with a new constant that has *all* placeholder uses updated. 6243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *UserC = cast<Constant>(U); 6253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (User::op_iterator I = UserC->op_begin(), E = UserC->op_end(); 6263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I != E; ++I) { 6273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *NewOp; 6283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!isa<ConstantPlaceHolder>(*I)) { 6293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Not a placeholder reference. 6303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOp = *I; 6313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (*I == Placeholder) { 6323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Common case is that it just references this one placeholder. 6333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOp = RealVal; 6343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 6353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Otherwise, look up the placeholder in ResolveConstants. 6363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResolveConstantsTy::iterator It = 6373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::lower_bound(ResolveConstants.begin(), ResolveConstants.end(), 6383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::pair<Constant*, unsigned>(cast<Constant>(*I), 6393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 0)); 6403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(It != ResolveConstants.end() && It->first == *I); 6413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOp = operator[](It->second); 6423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOps.push_back(cast<Constant>(NewOp)); 6453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Make the new constant. 6483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *NewC; 6493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) { 6503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewC = ConstantArray::get(UserCA->getType(), NewOps); 6513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) { 6523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewC = ConstantStruct::get(UserCS->getType(), NewOps); 6533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (isa<ConstantVector>(UserC)) { 6543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewC = ConstantVector::get(NewOps); 6553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 6563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr."); 6573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewC = cast<ConstantExpr>(UserC)->getWithOperands(NewOps); 6583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UserC->replaceAllUsesWith(NewC); 6613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UserC->destroyConstant(); 6623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewOps.clear(); 6633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Update all ValueHandles, they should be the only users at this point. 6663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Placeholder->replaceAllUsesWith(RealVal); 6673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete Placeholder; 6683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 6703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReaderMDValueList::AssignValue(Value *V, unsigned Idx) { 6723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx == size()) { 6733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien push_back(V); 6743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 6753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 6783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx+1); 6793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien WeakVH &OldV = MDValuePtrs[Idx]; 6813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OldV == 0) { 6823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV = V; 6833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 6843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 6853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If there was a forward reference to this value, replace it. 6873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDNode *PrevVal = cast<MDNode>(OldV); 6883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OldV->replaceAllUsesWith(V); 6893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDNode::deleteTemporary(PrevVal); 6903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Deleting PrevVal sets Idx value in MDValuePtrs to null. Set new 6913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // value for Idx. 6923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValuePtrs[Idx] = V; 6933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 6943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienValue *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { 6963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Idx >= size()) 6973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien resize(Idx + 1); 6983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 6993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Value *V = MDValuePtrs[Idx]) { 7003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(V->getType()->isMetadataTy() && "Type mismatch in value table!"); 7013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V; 7023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 7033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Create and return a placeholder, which will later be RAUW'd. 7053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = MDNode::getTemporary(Context, ArrayRef<Value*>()); 7063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValuePtrs[Idx] = V; 7073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V; 7083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 7093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienType *BitcodeReader::getTypeByID(unsigned ID) { 7113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // The type table size is always specified correctly. 7123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ID >= TypeList.size()) 7133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return 0; 714c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 7153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *Ty = TypeList[ID]) 7163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Ty; 7173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If we have a forward reference, the only possible case is when it is to a 7193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // named struct. Just create a placeholder for now. 7203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return TypeList[ID] = StructType::create(Context); 7213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 7223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// FIXME: Remove in LLVM 3.1, only used by ParseOldTypeTable. 7243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienType *BitcodeReader::getTypeByIDOrNull(unsigned ID) { 7253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ID >= TypeList.size()) 7263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList.resize(ID+1); 727c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 7283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return TypeList[ID]; 7293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 7303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 7333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// Functions for parsing blocks from the bitcode file 7343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 7353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::ParseAttributeBlock() { 7373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) 7383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 7393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!MAttributes.empty()) 7413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Multiple PARAMATTR blocks found!"); 7423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 7443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<AttributeWithIndex, 8> Attrs; 7463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records. 7483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 7493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 7503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 7513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 7523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Error at end of PARAMATTR block"); 7533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 7543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 7553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 7573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No known subblocks, always skip them. 7583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadSubBlockID(); 7593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 7603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 7613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 7623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 7633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 7653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 7663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 7673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 7683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 7703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 7713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Stream.ReadRecord(Code, Record)) { 7723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: ignore. 7733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 7743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [paramidx0, attr0, ...] 7753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() & 1) 7763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid ENTRY record"); 7773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FIXME : Remove this autoupgrade code in LLVM 3.0. 7793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If Function attributes are using index 0 then transfer them 7803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // to index ~0. Index 0 is used for return value attributes but used to be 7813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // used for function attributes. 7823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Attributes RetAttribute = Attribute::None; 7833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Attributes FnAttribute = Attribute::None; 7843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 7853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FIXME: remove in LLVM 3.0 7863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // The alignment is stored as a 16-bit raw value from bits 31--16. 7873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // We shift the bits above 31 down by 11 bits. 7883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 7893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Alignment = (Record[i+1] & (0xffffull << 16)) >> 16; 7903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Alignment && !isPowerOf2_32(Alignment)) 7913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Alignment is not a power of two."); 7923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 793c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Attributes ReconstitutedAttr(Record[i+1] & 0xffff); 7943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Alignment) 7953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ReconstitutedAttr |= Attribute::constructAlignmentFromInt(Alignment); 796c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao ReconstitutedAttr |= 797c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Attributes((Record[i+1] & (0xffffull << 32)) >> 11); 7983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 799c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Record[i+1] = ReconstitutedAttr.Raw(); 8003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[i] == 0) 801c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao RetAttribute = ReconstitutedAttr; 8023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (Record[i] == ~0U) 803c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao FnAttribute = ReconstitutedAttr; 8043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 806c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Attributes OldRetAttrs = (Attribute::NoUnwind|Attribute::NoReturn| 807c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Attribute::ReadOnly|Attribute::ReadNone); 8083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (FnAttribute == Attribute::None && RetAttribute != Attribute::None && 810c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao (RetAttribute & OldRetAttrs)) { 8113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (FnAttribute == Attribute::None) { // add a slot so they get added. 8123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.push_back(~0U); 8133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.push_back(0); 8143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FnAttribute |= RetAttribute & OldRetAttrs; 8173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien RetAttribute &= ~OldRetAttrs; 8183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 8213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[i] == 0) { 8223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (RetAttribute != Attribute::None) 8233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Attrs.push_back(AttributeWithIndex::get(0, RetAttribute)); 8243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (Record[i] == ~0U) { 8253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (FnAttribute != Attribute::None) 8263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Attrs.push_back(AttributeWithIndex::get(~0U, FnAttribute)); 827c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao } else if (Attributes(Record[i+1]) != Attribute::None) 828c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Attrs.push_back(AttributeWithIndex::get(Record[i], 829c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Attributes(Record[i+1]))); 8303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8328b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao MAttributes.push_back(AttrListPtr::get(Attrs)); 8333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Attrs.clear(); 8343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 8393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::ParseTypeTable() { 8413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW)) 8423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 843c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 8443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return ParseTypeTableBody(); 8453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 8463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::ParseTypeTableBody() { 8483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!TypeList.empty()) 8493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Multiple TYPE_BLOCKs found!"); 8503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 8523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumRecords = 0; 8533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<64> TypeName; 855c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 8563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this type table. 8573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 8583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 8593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 8603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumRecords != TypeList.size()) 8613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid type forward reference in TYPE_BLOCK"); 8623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 8633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Error at end of type table block"); 8643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 8653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 8683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No known subblocks, always skip them. 8693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadSubBlockID(); 8703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 8713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 8723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 8733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 8763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 8773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 8783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 8793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 8803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 8813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 8823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ResultTy = 0; 8833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Stream.ReadRecord(Code, Record)) { 8843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: return Error("unknown type in type table"); 8853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 8863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // TYPE_CODE_NUMENTRY contains a count of the number of types in the 8873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // type list. This allows us to reserve space. 8883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 8893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid TYPE_CODE_NUMENTRY record"); 8903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList.resize(Record[0]); 8913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 8923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_VOID: // VOID 8933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getVoidTy(Context); 8943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FLOAT: // FLOAT 8963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getFloatTy(Context); 8973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 8983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_DOUBLE: // DOUBLE 8993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getDoubleTy(Context); 9003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_X86_FP80: // X86_FP80 9023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getX86_FP80Ty(Context); 9033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FP128: // FP128 9053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getFP128Ty(Context); 9063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 9083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getPPC_FP128Ty(Context); 9093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_LABEL: // LABEL 9113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getLabelTy(Context); 9123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_METADATA: // METADATA 9143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getMetadataTy(Context); 9153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_X86_MMX: // X86_MMX 9173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getX86_MMXTy(Context); 9183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 9203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 9213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid Integer type record"); 9223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 9233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = IntegerType::get(Context, Record[0]); 9243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 9263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // [pointee type, address space] 9273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 9283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid POINTER type record"); 9293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned AddressSpace = 0; 9303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() == 2) 9313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AddressSpace = Record[1]; 9323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = getTypeByID(Record[0]); 9333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ResultTy == 0) return Error("invalid element type in pointer type"); 9343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = PointerType::get(ResultTy, AddressSpace); 9353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FUNCTION_OLD: { 9383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FIXME: attrid is dead, remove it in LLVM 3.0 9393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [vararg, attrid, retty, paramty x N] 9403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 9413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid FUNCTION type record"); 9423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Type*> ArgTys; 9433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 3, e = Record.size(); i != e; ++i) { 9443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *T = getTypeByID(Record[i])) 9453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArgTys.push_back(T); 9463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 9473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 949c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 9503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = getTypeByID(Record[2]); 9513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ResultTy == 0 || ArgTys.size() < Record.size()-3) 9523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("invalid type in function type"); 9533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 9543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 9553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FUNCTION: { 9583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [vararg, retty, paramty x N] 9593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 9603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid FUNCTION type record"); 9613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Type*> ArgTys; 9623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 2, e = Record.size(); i != e; ++i) { 9633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *T = getTypeByID(Record[i])) 9643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArgTys.push_back(T); 9653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 9663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 968c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 9693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = getTypeByID(Record[1]); 9703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ResultTy == 0 || ArgTys.size() < Record.size()-2) 9713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("invalid type in function type"); 9723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 9733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 9743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N] 9773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 9783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid STRUCT type record"); 9793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Type*> EltTys; 9803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1, e = Record.size(); i != e; ++i) { 9813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *T = getTypeByID(Record[i])) 9823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien EltTys.push_back(T); 9833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 9843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (EltTys.size() != Record.size()-1) 9873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("invalid type in struct type"); 9883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = StructType::get(Context, EltTys, Record[0]); 9893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 9903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 9913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N] 9923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, TypeName)) 9933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid STRUCT_NAME record"); 9943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 9953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 9963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N] 9973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 9983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid STRUCT type record"); 999c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumRecords >= TypeList.size()) 10013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("invalid TYPE table"); 1002c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check to see if this was forward referenced, if so fill in the temp. 10043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 10053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Res) { 10063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res->setName(TypeName); 10073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList[NumRecords] = 0; 10083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else // Otherwise, create a new struct. 10093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res = StructType::create(Context, TypeName); 10103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeName.clear(); 1011c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Type*, 8> EltTys; 10133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1, e = Record.size(); i != e; ++i) { 10143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *T = getTypeByID(Record[i])) 10153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien EltTys.push_back(T); 10163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 10173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 10183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 10193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (EltTys.size() != Record.size()-1) 10203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("invalid STRUCT type record"); 10213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res->setBody(EltTys, Record[0]); 10223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Res; 10233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 10243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 10253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: [] 10263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() != 1) 10273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid OPAQUE type record"); 10283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 10293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumRecords >= TypeList.size()) 10303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("invalid TYPE table"); 1031c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check to see if this was forward referenced, if so fill in the temp. 10333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 10343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Res) { 10353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res->setName(TypeName); 10363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList[NumRecords] = 0; 10373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else // Otherwise, create a new struct with no body. 10383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Res = StructType::create(Context, TypeName); 10393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeName.clear(); 10403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Res; 10413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1042c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 10433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 10443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 10453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid ARRAY type record"); 10463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByID(Record[1]))) 10473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = ArrayType::get(ResultTy, Record[0]); 10483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 10493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid ARRAY type element"); 10503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 10513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 10523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 10533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid VECTOR type record"); 10543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByID(Record[1]))) 10553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = VectorType::get(ResultTy, Record[0]); 10563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 10573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid ARRAY type element"); 10583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 10593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 10603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 10613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumRecords >= TypeList.size()) 10623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("invalid TYPE table"); 10633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(ResultTy && "Didn't read a type?"); 10643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(TypeList[NumRecords] == 0 && "Already read type?"); 10653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList[NumRecords++] = ResultTy; 10663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 10673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 10683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 10693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// FIXME: Remove in LLVM 3.1 10703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::ParseOldTypeTable() { 1071c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Stream.EnterSubBlock(TYPE_BLOCK_ID_OLD_3_0)) 10723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 10733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 10743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!TypeList.empty()) 10753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Multiple TYPE_BLOCKs found!"); 1076c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 1077c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // While horrible, we have no good ordering of types in the bc file. Just 10793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // iteratively parse types out of the bc file in multiple passes until we get 10803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // them all. Do this by saving a cursor for the start of the type block. 10813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BitstreamCursor StartOfTypeBlockCursor(Stream); 1082c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumTypesRead = 0; 1084c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 10863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan ChienRestartScan: 10873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NextTypeID = 0; 10883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool ReadAnyTypes = false; 1089c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this type table. 10913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 10923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 10933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 10943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextTypeID != TypeList.size()) 10953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid type forward reference in TYPE_BLOCK_ID_OLD"); 1096c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 10973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If we haven't read all of the types yet, iterate again. 10983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NumTypesRead != TypeList.size()) { 10993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If we didn't successfully read any types in this pass, then we must 11003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // have an unhandled forward reference. 11013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!ReadAnyTypes) 11023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Obsolete bitcode contains unhandled recursive type"); 1103c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 11043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream = StartOfTypeBlockCursor; 11053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien goto RestartScan; 11063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1107c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 11083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 11093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Error at end of type table block"); 11103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 11113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1112c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 11133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 11143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No known subblocks, always skip them. 11153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadSubBlockID(); 11163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 11173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 11183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 11193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1120c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 11213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 11223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 11233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 11243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1125c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 11263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 11273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 11283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ResultTy = 0; 11293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Stream.ReadRecord(Code, Record)) { 11303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: return Error("unknown type in type table"); 11313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 11323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // TYPE_CODE_NUMENTRY contains a count of the number of types in the 11333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // type list. This allows us to reserve space. 11343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 11353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid TYPE_CODE_NUMENTRY record"); 11363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList.resize(Record[0]); 11373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 11383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_VOID: // VOID 11393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getVoidTy(Context); 11403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FLOAT: // FLOAT 11423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getFloatTy(Context); 11433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_DOUBLE: // DOUBLE 11453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getDoubleTy(Context); 11463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_X86_FP80: // X86_FP80 11483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getX86_FP80Ty(Context); 11493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FP128: // FP128 11513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getFP128Ty(Context); 11523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 11543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getPPC_FP128Ty(Context); 11553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_LABEL: // LABEL 11573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getLabelTy(Context); 11583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_METADATA: // METADATA 11603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getMetadataTy(Context); 11613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_X86_MMX: // X86_MMX 11633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = Type::getX86_MMXTy(Context); 11643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 11663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 11673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid Integer type record"); 11683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = IntegerType::get(Context, Record[0]); 11693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_OPAQUE: // OPAQUE 11713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextTypeID < TypeList.size() && TypeList[NextTypeID] == 0) 11723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = StructType::create(Context); 11733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1174c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien case TYPE_CODE_STRUCT_OLD_3_0: {// STRUCT_OLD 11753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextTypeID >= TypeList.size()) break; 11763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If we already read it, don't reprocess. 11773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (TypeList[NextTypeID] && 11783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien !cast<StructType>(TypeList[NextTypeID])->isOpaque()) 11793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 11813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Set a type. 11823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (TypeList[NextTypeID] == 0) 11833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList[NextTypeID] = StructType::create(Context); 11843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 11853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Type*> EltTys; 11863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1, e = Record.size(); i != e; ++i) { 11873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *Elt = getTypeByIDOrNull(Record[i])) 11883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien EltTys.push_back(Elt); 11893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 11903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 11913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 11923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 11933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (EltTys.size() != Record.size()-1) 11943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; // Not all elements are ready. 1195c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 11963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<StructType>(TypeList[NextTypeID])->setBody(EltTys, Record[0]); 11973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = TypeList[NextTypeID]; 11983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList[NextTypeID] = 0; 11993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 12023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // [pointee type, address space] 12033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 12043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid POINTER type record"); 12053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned AddressSpace = 0; 12063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() == 2) 12073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AddressSpace = Record[1]; 12083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[0]))) 12093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = PointerType::get(ResultTy, AddressSpace); 12103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FUNCTION_OLD: { 12133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FIXME: attrid is dead, remove it in LLVM 3.0 12143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [vararg, attrid, retty, paramty x N] 12153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 12163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid FUNCTION type record"); 12173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Type*> ArgTys; 12183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 3, e = Record.size(); i != e; ++i) { 12193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *Elt = getTypeByIDOrNull(Record[i])) 12203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArgTys.push_back(Elt); 12213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 12223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ArgTys.size()+3 != Record.size()) 12253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; // Something was null. 12263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[2]))) 12273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 12283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_FUNCTION: { 12313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [vararg, retty, paramty x N] 12323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 12333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid FUNCTION type record"); 12343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Type*> ArgTys; 12353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 2, e = Record.size(); i != e; ++i) { 12363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Type *Elt = getTypeByIDOrNull(Record[i])) 12373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArgTys.push_back(Elt); 12383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 12393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ArgTys.size()+2 != Record.size()) 12423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; // Something was null. 12433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[1]))) 12443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 12453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 12483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 12493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid ARRAY type record"); 12503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[1]))) 12513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = ArrayType::get(ResultTy, Record[0]); 12523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 12543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 12553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid VECTOR type record"); 12563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((ResultTy = getTypeByIDOrNull(Record[1]))) 12573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResultTy = VectorType::get(ResultTy, Record[0]); 12583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 12593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1260c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 12613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextTypeID >= TypeList.size()) 12623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("invalid TYPE table"); 1263c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 12643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ResultTy && TypeList[NextTypeID] == 0) { 12653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ++NumTypesRead; 12663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ReadAnyTypes = true; 1267c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 12683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeList[NextTypeID] = ResultTy; 12693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 1270c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 12713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ++NextTypeID; 12723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 12743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::ParseOldTypeSymbolTable() { 1277c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien if (Stream.EnterSubBlock(TYPE_SYMTAB_BLOCK_ID_OLD_3_0)) 12783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 12793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 12813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this type table. 12833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string TypeName; 12843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 12853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 12863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 12873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 12883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Error at end of type symbol table block"); 12893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 12903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 12923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 12933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No known subblocks, always skip them. 12943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadSubBlockID(); 12953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 12963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 12973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 12983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 12993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 13013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 13023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 13033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 13063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 13073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Stream.ReadRecord(Code, Record)) { 13083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: unknown type. 13093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 13103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TST_CODE_ENTRY: // TST_ENTRY: [typeid, namechar x N] 13113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 1, TypeName)) 13123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid TST_ENTRY record"); 13133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned TypeID = Record[0]; 13143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (TypeID >= TypeList.size()) 13153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid Type ID in TST_ENTRY record"); 13163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Only apply the type name to a struct type with no name. 13183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (StructType *STy = dyn_cast<StructType>(TypeList[TypeID])) 13193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!STy->isLiteral() && !STy->hasName()) 13203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien STy->setName(TypeName); 13213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TypeName.clear(); 13223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 13233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 13263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::ParseValueSymbolTable() { 13283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) 13293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 13303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 13323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this value table. 13343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<128> ValueName; 13353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 13363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 13373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 13383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 13393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Error at end of value symbol table block"); 13403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 13413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 13433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No known subblocks, always skip them. 13443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadSubBlockID(); 13453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 13463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 13473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 13483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 13513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 13523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 13533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 13563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 13573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Stream.ReadRecord(Code, Record)) { 13583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: unknown type. 13593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 13603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N] 13613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 1, ValueName)) 13623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid VST_ENTRY record"); 13633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ValueID = Record[0]; 13643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ValueID >= ValueList.size()) 13653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid Value ID in VST_ENTRY record"); 13663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = ValueList[ValueID]; 13673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V->setName(StringRef(ValueName.data(), ValueName.size())); 13693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueName.clear(); 13703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 13713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::VST_CODE_BBENTRY: { 13733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 1, ValueName)) 13743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid VST_BBENTRY record"); 13753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *BB = getBasicBlock(Record[0]); 13763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BB == 0) 13773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid BB ID in VST_BBENTRY record"); 13783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BB->setName(StringRef(ValueName.data(), ValueName.size())); 13803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueName.clear(); 13813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 13823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 13853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 13863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::ParseMetadata() { 13883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NextMDValueNo = MDValueList.size(); 13893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) 13913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 13923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 13943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 13953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records. 13963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 13973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 13983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 13993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 14003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Error at end of PARAMATTR block"); 14013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 14023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 14043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 14053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No known subblocks, always skip them. 14063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadSubBlockID(); 14073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 14083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 14093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 14103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 14123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 14133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 14143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 14153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 14173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool IsFunctionLocal = false; 14183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 14193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 14203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Code = Stream.ReadRecord(Code, Record); 14213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Code) { 14223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: ignore. 14233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 14243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_NAME: { 14253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read named of the named metadata. 14263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NameLength = Record.size(); 14273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<8> Name; 14283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Name.resize(NameLength); 14293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != NameLength; ++i) 14303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Name[i] = Record[i]; 14313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 14323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Code = Stream.ReadCode(); 14333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 14343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // METADATA_NAME is always followed by METADATA_NAMED_NODE. 14353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NextBitCode = Stream.ReadRecord(Code, Record); 14363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(NextBitCode == bitc::METADATA_NAMED_NODE); (void)NextBitCode; 14373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 14383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read named metadata elements. 14393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 14403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NamedMDNode *NMD = TheModule->getOrInsertNamedMetadata(Name); 14413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) { 14423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDNode *MD = dyn_cast<MDNode>(MDValueList.getValueFwdRef(Record[i])); 14433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (MD == 0) 14443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed metadata record"); 14453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NMD->addOperand(MD); 14463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 14483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_FN_NODE: 14503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien IsFunctionLocal = true; 14513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // fall-through 14523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_NODE: { 14533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() % 2 == 1) 14543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid METADATA_NODE record"); 14553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 14563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 14573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Value*, 8> Elts; 14583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; i += 2) { 14593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[i]); 14603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Ty) return Error("Invalid METADATA_NODE record"); 14613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ty->isMetadataTy()) 14623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); 14633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (!Ty->isVoidTy()) 14643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty)); 14653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 14663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(NULL); 14673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = MDNode::getWhenValsUnresolved(Context, Elts, IsFunctionLocal); 14693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien IsFunctionLocal = false; 14703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValueList.AssignValue(V, NextMDValueNo++); 14713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 14723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_STRING: { 14743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned MDStringLength = Record.size(); 14753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<8> String; 14763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien String.resize(MDStringLength); 14773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != MDStringLength; ++i) 14783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien String[i] = Record[i]; 14793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = MDString::get(Context, 14803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien StringRef(String.data(), String.size())); 14813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValueList.AssignValue(V, NextMDValueNo++); 14823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 14833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_KIND: { 14853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned RecordLength = Record.size(); 14863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty() || RecordLength < 2) 14873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid METADATA_KIND record"); 14883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallString<8> Name; 14893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Name.resize(RecordLength-1); 14903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Kind = Record[0]; 14913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1; i != RecordLength; ++i) 14923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Name[i-1] = Record[i]; 1493c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 14943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NewKind = TheModule->getMDKindID(Name.str()); 14953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) 14963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Conflicting METADATA_KIND records"); 14973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 14983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 14993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 15023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// DecodeSignRotatedValue - Decode a signed value stored with the sign bit in 15043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// the LSB for dense VBR encoding. 15053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienstatic uint64_t DecodeSignRotatedValue(uint64_t V) { 15063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((V & 1) == 0) 15073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return V >> 1; 15083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (V != 1) 15093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return -(V >> 1); 15103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // There is no such thing as -0 with integers. "-0" really means MININT. 15113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return 1ULL << 63; 15123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 15133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ResolveGlobalAndAliasInits - Resolve all of the initializers for global 15153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// values and aliases that we can. 15163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::ResolveGlobalAndAliasInits() { 15173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist; 15183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist; 15193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInitWorklist.swap(GlobalInits); 15213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AliasInitWorklist.swap(AliasInits); 15223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!GlobalInitWorklist.empty()) { 15243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ValID = GlobalInitWorklist.back().second; 15253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ValID >= ValueList.size()) { 15263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Not ready to resolve this yet, it requires something later in the file. 15273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInits.push_back(GlobalInitWorklist.back()); 15283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 15293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 15303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInitWorklist.back().first->setInitializer(C); 15313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 15323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Global variable initializer is not a constant!"); 15333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInitWorklist.pop_back(); 15353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!AliasInitWorklist.empty()) { 15383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ValID = AliasInitWorklist.back().second; 15393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ValID >= ValueList.size()) { 15403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AliasInits.push_back(AliasInitWorklist.back()); 15413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 15423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 15433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AliasInitWorklist.back().first->setAliasee(C); 15443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 15453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Alias initializer is not a constant!"); 15463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AliasInitWorklist.pop_back(); 15483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 15503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 15513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::ParseConstants() { 15533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) 15543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 15553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 15573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this value table. 15593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *CurTy = Type::getInt32Ty(Context); 15603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NextCstNo = ValueList.size(); 15613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 15623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 15633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) 15643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 15653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 15673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // No known subblocks, always skip them. 15683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadSubBlockID(); 15693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 15703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 15713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 15723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 15753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 15763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 15773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 15783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 15793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 15803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 15813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = 0; 15823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned BitCode = Stream.ReadRecord(Code, Record); 15833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (BitCode) { 15843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: unknown constant 15853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_UNDEF: // UNDEF 15863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); 15873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 15883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] 15893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 15903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed CST_SETTYPE record"); 15913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[0] >= TypeList.size()) 15923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid Type ID in CST_SETTYPE record"); 15933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CurTy = TypeList[Record[0]]; 15943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; // Skip the ValueList manipulation. 15953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_NULL: // NULL 15963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = Constant::getNullValue(CurTy); 15973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 15983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_INTEGER: // INTEGER: [intval] 15993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!CurTy->isIntegerTy() || Record.empty()) 16003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid CST_INTEGER record"); 16013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantInt::get(CurTy, DecodeSignRotatedValue(Record[0])); 16023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval] 16043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!CurTy->isIntegerTy() || Record.empty()) 16053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid WIDE_INTEGER record"); 16063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumWords = Record.size(); 16083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 8> Words; 16093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Words.resize(NumWords); 16103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != NumWords; ++i) 16113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Words[i] = DecodeSignRotatedValue(Record[i]); 16123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantInt::get(Context, 16133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien APInt(cast<IntegerType>(CurTy)->getBitWidth(), 16143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Words)); 16153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] 16183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 16193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid FLOAT record"); 16203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CurTy->isFloatTy()) 16213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantFP::get(Context, APFloat(APInt(32, (uint32_t)Record[0]))); 16223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (CurTy->isDoubleTy()) 16233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantFP::get(Context, APFloat(APInt(64, Record[0]))); 16243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (CurTy->isX86_FP80Ty()) { 16253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Bits are not stored the same way as a normal i80 APInt, compensate. 16263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien uint64_t Rearrange[2]; 16273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16); 16283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Rearrange[1] = Record[0] >> 48; 16293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantFP::get(Context, APFloat(APInt(80, Rearrange))); 16303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (CurTy->isFP128Ty()) 16313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantFP::get(Context, APFloat(APInt(128, Record), true)); 16323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (CurTy->isPPC_FP128Ty()) 16333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantFP::get(Context, APFloat(APInt(128, Record))); 16343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 16353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); 16363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] 16403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 16413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid CST_AGGREGATE record"); 16423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 16443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Constant*> Elts; 16453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (StructType *STy = dyn_cast<StructType>(CurTy)) { 16473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 16483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getConstantFwdRef(Record[i], 16493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien STy->getElementType(i))); 16503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantStruct::get(STy, Elts); 16513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) { 16523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *EltTy = ATy->getElementType(); 16533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 16543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 16553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantArray::get(ATy, Elts); 16563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) { 16573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *EltTy = VTy->getElementType(); 16583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 16593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 16603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantVector::get(Elts); 16613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 16623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); 16633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_STRING: { // STRING: [values] 16673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 16683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid CST_AGGREGATE record"); 16693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArrayType *ATy = cast<ArrayType>(CurTy); 16713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *EltTy = ATy->getElementType(); 16723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 16743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Constant*> Elts; 16753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 16763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ConstantInt::get(EltTy, Record[i])); 16773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantArray::get(ATy, Elts); 16783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CSTRING: { // CSTRING: [values] 16813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty()) 16823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid CST_AGGREGATE record"); 16833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArrayType *ATy = cast<ArrayType>(CurTy); 16853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *EltTy = ATy->getElementType(); 16863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 16873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 16883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Constant*> Elts; 16893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != Size; ++i) 16903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ConstantInt::get(EltTy, Record[i])); 16913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(Constant::getNullValue(EltTy)); 16923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantArray::get(ATy, Elts); 16933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 16943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 16953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] 16963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) return Error("Invalid CE_BINOP record"); 16973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien int Opc = GetDecodedBinaryOpcode(Record[0], CurTy); 16983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc < 0) { 16993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); // Unknown binop. 17003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 17013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy); 17023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy); 17033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Flags = 0; 17043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() >= 4) { 17053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc == Instruction::Add || 17063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Sub || 17073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Mul || 17083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Shl) { 17093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 17103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Flags |= OverflowingBinaryOperator::NoSignedWrap; 17113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 17123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Flags |= OverflowingBinaryOperator::NoUnsignedWrap; 17133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (Opc == Instruction::SDiv || 17143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::UDiv || 17153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::LShr || 17163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::AShr) { 17173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[3] & (1 << bitc::PEO_EXACT)) 17183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Flags |= SDivOperator::IsExact; 17193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::get(Opc, LHS, RHS, Flags); 17223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] 17263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) return Error("Invalid CE_CAST record"); 17273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien int Opc = GetDecodedCastOpcode(Record[0]); 17283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc < 0) { 17293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = UndefValue::get(CurTy); // Unknown cast. 17303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 17313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[1]); 17323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!OpTy) return Error("Invalid CE_CAST record"); 17333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); 17343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getCast(Opc, Op, CurTy); 17353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_INBOUNDS_GEP: 17393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands] 17403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() & 1) return Error("Invalid CE_GEP record"); 17413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Constant*, 16> Elts; 17423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 17433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ElTy = getTypeByID(Record[i]); 17443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!ElTy) return Error("Invalid CE_GEP record"); 17453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); 17463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end()); 17483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getGetElementPtr(Elts[0], Indices, 17493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BitCode == 17503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bitc::CST_CODE_CE_INBOUNDS_GEP); 17513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_SELECT: // CE_SELECT: [opval#, opval#, opval#] 17543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) return Error("Invalid CE_SELECT record"); 17553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0], 17563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type::getInt1Ty(Context)), 17573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.getConstantFwdRef(Record[1],CurTy), 17583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.getConstantFwdRef(Record[2],CurTy)); 17593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval] 17613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) return Error("Invalid CE_EXTRACTELT record"); 17623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *OpTy = 17633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 17643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpTy == 0) return Error("Invalid CE_EXTRACTELT record"); 17653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 17663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 17673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getExtractElement(Op0, Op1); 17683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval] 17713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *OpTy = dyn_cast<VectorType>(CurTy); 17723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3 || OpTy == 0) 17733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid CE_INSERTELT record"); 17743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 17753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[1], 17763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpTy->getElementType()); 17773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 17783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getInsertElement(Op0, Op1, Op2); 17793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] 17823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *OpTy = dyn_cast<VectorType>(CurTy); 17833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3 || OpTy == 0) 17843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid CE_SHUFFLEVEC record"); 17853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 17863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); 17873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 17883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpTy->getNumElements()); 17893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy); 17903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 17913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 17923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 17933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval] 17943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *RTy = dyn_cast<VectorType>(CurTy); 17953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien VectorType *OpTy = 17963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 17973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 4 || RTy == 0 || OpTy == 0) 17983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid CE_SHUFVEC_EX record"); 17993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 18003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 18013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 18023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien RTy->getNumElements()); 18033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy); 18043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 18053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 18063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] 18083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 4) return Error("Invalid CE_CMP record"); 18093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[0]); 18103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpTy == 0) return Error("Invalid CE_CMP record"); 18113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 18123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 18133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpTy->isFPOrFPVectorTy()) 18153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getFCmp(Record[3], Op0, Op1); 18163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 18173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = ConstantExpr::getICmp(Record[3], Op0, Op1); 18183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 18193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_INLINEASM: { 18213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) return Error("Invalid INLINEASM record"); 18223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string AsmStr, ConstrStr; 18233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool HasSideEffects = Record[0] & 1; 18243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool IsAlignStack = Record[0] >> 1; 18253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned AsmStrSize = Record[1]; 18263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (2+AsmStrSize >= Record.size()) 18273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid INLINEASM record"); 18283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ConstStrSize = Record[2+AsmStrSize]; 18293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (3+AsmStrSize+ConstStrSize > Record.size()) 18303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid INLINEASM record"); 18313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != AsmStrSize; ++i) 18333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AsmStr += (char)Record[2+i]; 18343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0; i != ConstStrSize; ++i) 18353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ConstrStr += (char)Record[3+AsmStrSize+i]; 18363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PointerType *PTy = cast<PointerType>(CurTy); 18373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), 18383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AsmStr, ConstrStr, HasSideEffects, IsAlignStack); 18393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 18403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CST_CODE_BLOCKADDRESS:{ 18423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) return Error("Invalid CE_BLOCKADDRESS record"); 18433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *FnTy = getTypeByID(Record[0]); 18443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (FnTy == 0) return Error("Invalid CE_BLOCKADDRESS record"); 18453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *Fn = 18463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy)); 18473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Fn == 0) return Error("Invalid CE_BLOCKADDRESS record"); 1848c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 18493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalVariable *FwdRef = new GlobalVariable(*Fn->getParent(), 18503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type::getInt8Ty(Context), 18513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien false, GlobalValue::InternalLinkage, 18523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 0, ""); 18533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BlockAddrFwdRefs[Fn].push_back(std::make_pair(Record[2], FwdRef)); 18543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien V = FwdRef; 18553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1856c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien } 18573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.AssignValue(V, NextCstNo); 18603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ++NextCstNo; 18613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 18623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (NextCstNo != ValueList.size()) 18643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid constant reference!"); 18653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 18673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Error at end of constants block"); 18683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Once all the constants have been read, go through and resolve forward 18703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // references. 18713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.ResolveConstantForwardRefs(); 18723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 18733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 18743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// RememberAndSkipFunctionBody - When we see the block for a function body, 18763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// remember where it is and then skip it. This lets us lazily deserialize the 18773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// functions. 18783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::RememberAndSkipFunctionBody() { 18793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Get the function we are talking about. 18803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (FunctionsWithBodies.empty()) 18813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Insufficient function protos"); 18823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *Fn = FunctionsWithBodies.back(); 18843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionsWithBodies.pop_back(); 18853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Save the current stream state. 18873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien uint64_t CurBit = Stream.GetCurrentBitNo(); 18883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DeferredFunctionInfo[Fn] = CurBit; 18893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Skip over the function block for now. 18913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 18923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 18933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 18943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 18953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 18963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::ParseModule() { 18973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 18983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 18993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 19013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::string> SectionTable; 19023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::string> GCTable; 19033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this module. 19053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!Stream.AtEndOfStream()) { 19063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 19073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 19083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 19093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Error at end of module block"); 19103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Patch the initializers for globals and aliases up. 19123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ResolveGlobalAndAliasInits(); 19133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!GlobalInits.empty() || !AliasInits.empty()) 19143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed global initializer set"); 19153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!FunctionsWithBodies.empty()) 19163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Too few function bodies found"); 19173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Look for intrinsic functions which need to be upgraded at some point 19193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); 19203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FI != FE; ++FI) { 19213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function* NewFn; 19223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (UpgradeIntrinsicFunction(FI, NewFn)) 19233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn)); 19243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 19253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Look for global variables which need to be renamed. 19273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (Module::global_iterator 19283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GI = TheModule->global_begin(), GE = TheModule->global_end(); 19293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GI != GE; ++GI) 19303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UpgradeGlobalVariable(GI); 19313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Force deallocation of memory for these vectors to favor the client that 19333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // want lazy deserialization. 19343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); 19353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); 19363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<Function*>().swap(FunctionsWithBodies); 19373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 19383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 19393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 19413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Stream.ReadSubBlockID()) { 19423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Skip unknown content. 19433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 19443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 19453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BLOCKINFO_BLOCK_ID: 19473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockInfoBlock()) 19483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed BlockInfoBlock"); 19493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::PARAMATTR_BLOCK_ID: 19513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ParseAttributeBlock()) 19523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return true; 19533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::TYPE_BLOCK_ID_NEW: 19553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ParseTypeTable()) 19563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return true; 19573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1958c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien case TYPE_BLOCK_ID_OLD_3_0: 19593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ParseOldTypeTable()) 19603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return true; 19613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 1962c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien case TYPE_SYMTAB_BLOCK_ID_OLD_3_0: 19633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ParseOldTypeSymbolTable()) 19643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return true; 19653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::VALUE_SYMTAB_BLOCK_ID: 19673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ParseValueSymbolTable()) 19683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return true; 19693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CONSTANTS_BLOCK_ID: 19713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ParseConstants() || ResolveGlobalAndAliasInits()) 19723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return true; 19733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_BLOCK_ID: 19753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ParseMetadata()) 19763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return true; 19773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNCTION_BLOCK_ID: 19793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If this is the first function body we've seen, reverse the 19803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FunctionsWithBodies list. 19813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!HasReversedFunctionsWithBodies) { 19823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end()); 19833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien HasReversedFunctionsWithBodies = true; 19843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 19853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (RememberAndSkipFunctionBody()) 19873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return true; 19883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 19893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 19903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 19913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 19923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 19943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 19953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 19963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 19973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 19983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 19993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Stream.ReadRecord(Code, Record)) { 20003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: break; // Default behavior, ignore unknown content. 20013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_VERSION: // VERSION: [version#] 20023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 20033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed MODULE_CODE_VERSION"); 20043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Only version #0 is supported so far. 20053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[0] != 0) 20063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Unknown bitstream version!"); 20073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 20093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 20113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid MODULE_CODE_TRIPLE record"); 20123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TheModule->setTargetTriple(S); 20133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] 20163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 20183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid MODULE_CODE_DATALAYOUT record"); 20193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TheModule->setDataLayout(S); 20203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] 20233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 20253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid MODULE_CODE_ASM record"); 20263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TheModule->setModuleInlineAsm(S); 20273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N] 20303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 20323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid MODULE_CODE_DEPLIB record"); 20333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TheModule->addLibrary(S); 20343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] 20373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 20393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid MODULE_CODE_SECTIONNAME record"); 20403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SectionTable.push_back(S); 20413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N] 20443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 20453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 20463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid MODULE_CODE_GCNAME record"); 20473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GCTable.push_back(S); 20483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // GLOBALVAR: [pointer type, isconst, initid, 20513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // linkage, alignment, section, visibility, threadlocal, 20523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // unnamed_addr] 20533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_GLOBALVAR: { 20543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 6) 20553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid MODULE_CODE_GLOBALVAR record"); 20563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[0]); 20573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Ty) return Error("Invalid MODULE_CODE_GLOBALVAR record"); 20583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Ty->isPointerTy()) 20593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Global not a pointer type!"); 20603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); 20613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ty = cast<PointerType>(Ty)->getElementType(); 20623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 20633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool isConstant = Record[1]; 20643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]); 20653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Alignment = (1 << Record[4]) >> 1; 20663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string Section; 20673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[5]) { 20683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[5]-1 >= SectionTable.size()) 20693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid section ID"); 20703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Section = SectionTable[Record[5]-1]; 20713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 20723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; 20733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 6) 20743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Visibility = GetDecodedVisibility(Record[6]); 20758b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao 20768b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal; 20773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 7) 20788b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao TLM = GetDecodedThreadLocalMode(Record[7]); 20793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 20803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool UnnamedAddr = false; 20813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 8) 20823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UnnamedAddr = Record[8]; 20833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 20843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalVariable *NewGV = 20853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien new GlobalVariable(*TheModule, Ty, isConstant, Linkage, 0, "", 0, 20868b5be8604307d0dd342235803dd45775830b84c6Shih-wei Liao TLM, AddressSpace); 20873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGV->setAlignment(Alignment); 20883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Section.empty()) 20893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGV->setSection(Section); 20903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGV->setVisibility(Visibility); 20913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGV->setUnnamedAddr(UnnamedAddr); 20923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 20933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.push_back(NewGV); 20943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 20953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Remember which value to use for the global initializer. 20963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (unsigned InitID = Record[2]) 20973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalInits.push_back(std::make_pair(NewGV, InitID-1)); 20983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 20993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FUNCTION: [type, callingconv, isproto, linkage, paramattr, 21013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // alignment, section, visibility, gc, unnamed_addr] 21023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_FUNCTION: { 21033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 8) 21043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid MODULE_CODE_FUNCTION record"); 21053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[0]); 21063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Ty) return Error("Invalid MODULE_CODE_FUNCTION record"); 21073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Ty->isPointerTy()) 21083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Function not a pointer type!"); 21093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionType *FTy = 21103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType()); 21113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!FTy) 21123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Function not a pointer to function type!"); 21133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, 21153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien "", TheModule); 21163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setCallingConv(static_cast<CallingConv::ID>(Record[1])); 21183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool isProto = Record[2]; 21193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setLinkage(GetDecodedLinkage(Record[3])); 21203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setAttributes(getAttributes(Record[4])); 21213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setAlignment((1 << Record[5]) >> 1); 21233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[6]) { 21243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[6]-1 >= SectionTable.size()) 21253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid section ID"); 21263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setSection(SectionTable[Record[6]-1]); 21273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setVisibility(GetDecodedVisibility(Record[7])); 21293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 8 && Record[8]) { 21303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[8]-1 > GCTable.size()) 21313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid GC ID"); 21323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setGC(GCTable[Record[8]-1].c_str()); 21333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool UnnamedAddr = false; 21353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 9) 21363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UnnamedAddr = Record[9]; 21373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Func->setUnnamedAddr(UnnamedAddr); 21383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.push_back(Func); 21393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If this is a function with a body, remember the prototype we are 21413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // creating now, so that we can match up the body with them later. 21423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!isProto) 21433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionsWithBodies.push_back(Func); 21443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 21453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // ALIAS: [alias type, aliasee val#, linkage] 21473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // ALIAS: [alias type, aliasee val#, linkage, visibility] 21483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_ALIAS: { 21493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 21503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid MODULE_ALIAS record"); 21513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[0]); 21523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Ty) return Error("Invalid MODULE_ALIAS record"); 21533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Ty->isPointerTy()) 21543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Function not a pointer type!"); 21553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]), 21573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien "", 0, TheModule); 21583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Old bitcode files didn't have visibility field. 21593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() > 3) 21603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NewGA->setVisibility(GetDecodedVisibility(Record[3])); 21613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.push_back(NewGA); 21623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AliasInits.push_back(std::make_pair(NewGA, Record[1])); 21633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 21643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien /// MODULE_CODE_PURGEVALS: [numvals] 21663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_PURGEVALS: 21673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Trim down the value list to the specified size. 21683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1 || Record[0] > ValueList.size()) 21693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid MODULE_PURGEVALS record"); 21703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.shrinkTo(Record[0]); 21713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 21723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 21743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Premature end of bitstream"); 21773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 21783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::ParseBitcodeInto(Module *M) { 21803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TheModule = 0; 21813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2182c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao const unsigned char *BufPtr = (unsigned char *)Buffer->getBufferStart(); 2183c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); 21843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Buffer->getBufferSize() & 3) { 21863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!isRawBitcode(BufPtr, BufEnd) && !isBitcodeWrapper(BufPtr, BufEnd)) 21873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid bitcode signature"); 21883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 21893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Bitcode stream should be a multiple of 4 bytes in length"); 21903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 21913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If we have a wrapper header, parse it and ignore the non-bc file contents. 21933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // The magic number is 0x0B17C0DE stored in little endian. 21943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (isBitcodeWrapper(BufPtr, BufEnd)) 2195c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true)) 21963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid bitcode wrapper header"); 21973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 21983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien StreamFile.init(BufPtr, BufEnd); 21993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.init(StreamFile); 22003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Sniff for the signature. 22023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.Read(8) != 'B' || 22033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(8) != 'C' || 22043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0x0 || 22053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xC || 22063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xE || 22073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xD) 22083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid bitcode signature"); 22093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // We expect a number of well-defined blocks, though we don't necessarily 22113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // need to understand them all. 22123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!Stream.AtEndOfStream()) { 22133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 22143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code != bitc::ENTER_SUBBLOCK) { 22163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // The ranlib in xcode 4 will align archive members by appending newlines 22183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // to the end of them. If this file size is a multiple of 4 but not 8, we 22193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // have to read and ignore these final 4 bytes :-( 22203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.GetAbbrevIDWidth() == 2 && Code == 2 && 22213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a && 22223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.AtEndOfStream()) 22233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 22243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid record at top-level"); 22263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned BlockID = Stream.ReadSubBlockID(); 22293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // We only know the MODULE subblock ID. 22313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (BlockID) { 22323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::BLOCKINFO_BLOCK_ID: 22333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockInfoBlock()) 22343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed BlockInfoBlock"); 22353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 22363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_BLOCK_ID: 22373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Reject multiple MODULE_BLOCK's in a single bitstream. 22383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (TheModule) 22393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Multiple MODULE_BLOCKs in same stream"); 22403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien TheModule = M; 22413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ParseModule()) 22423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return true; 22433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 22443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: 22453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 22463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 22473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 22483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 22523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 22533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::ParseModuleTriple(std::string &Triple) { 22553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 22563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 22573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 22593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records for this module. 22613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!Stream.AtEndOfStream()) { 22623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 22633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 22643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 22653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Error at end of module block"); 22663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 22683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 22713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Stream.ReadSubBlockID()) { 22723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Skip unknown content. 22733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 22743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 22753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 22763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 22783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 22813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 22823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 22833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 22843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 22853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 22863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Stream.ReadRecord(Code, Record)) { 22873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: break; // Default behavior, ignore unknown content. 22883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_VERSION: // VERSION: [version#] 22893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1) 22903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed MODULE_CODE_VERSION"); 22913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Only version #0 is supported so far. 22923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[0] != 0) 22933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Unknown bitstream version!"); 22943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 22953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 22963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string S; 22973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ConvertToString(Record, 0, S)) 22983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid MODULE_CODE_TRIPLE record"); 22993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Triple = S; 23003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 23013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 23043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Premature end of bitstream"); 23073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 23083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::ParseTriple(std::string &Triple) { 23103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Buffer->getBufferSize() & 3) 23113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Bitcode stream should be a multiple of 4 bytes in length"); 23123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 2313c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao const unsigned char *BufPtr = (unsigned char *)Buffer->getBufferStart(); 2314c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); 23153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If we have a wrapper header, parse it and ignore the non-bc file contents. 23173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // The magic number is 0x0B17C0DE stored in little endian. 23183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (isBitcodeWrapper(BufPtr, BufEnd)) 2319c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true)) 23203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid bitcode wrapper header"); 23213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien StreamFile.init(BufPtr, BufEnd); 23233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.init(StreamFile); 23243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Sniff for the signature. 23263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.Read(8) != 'B' || 23273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(8) != 'C' || 23283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0x0 || 23293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xC || 23303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xE || 23313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.Read(4) != 0xD) 23323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid bitcode signature"); 23333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // We expect a number of well-defined blocks, though we don't necessarily 23353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // need to understand them all. 23363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (!Stream.AtEndOfStream()) { 23373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 23383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code != bitc::ENTER_SUBBLOCK) 23403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid record at top-level"); 23413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned BlockID = Stream.ReadSubBlockID(); 23433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // We only know the MODULE subblock ID. 23453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (BlockID) { 23463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::MODULE_BLOCK_ID: 23473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ParseModuleTriple(Triple)) 23483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return true; 23493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 23503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: 23513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 23523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 23533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 23543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 23583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 23593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ParseMetadataAttachment - Parse metadata attachments. 23613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::ParseMetadataAttachment() { 23623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) 23633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 23643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 23653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 23663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while(1) { 23673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 23683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 23693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 23703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Error at end of PARAMATTR block"); 23713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 23723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 23743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 23753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 23763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a metadata attachment record. 23783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 23793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Stream.ReadRecord(Code, Record)) { 23803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: ignore. 23813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 23823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_ATTACHMENT: { 23833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned RecordLength = Record.size(); 23843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.empty() || (RecordLength - 1) % 2 == 1) 23853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error ("Invalid METADATA_ATTACHMENT reader!"); 23863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Instruction *Inst = InstructionList[Record[0]]; 23873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 1; i != RecordLength; i = i+2) { 23883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Kind = Record[i]; 23893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DenseMap<unsigned, unsigned>::iterator I = 23903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDKindMap.find(Kind); 23913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I == MDKindMap.end()) 23923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid metadata kind ID"); 23933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Node = MDValueList.getValueFwdRef(Record[i+1]); 23943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Inst->setMetadata(I->second, cast<MDNode>(Node)); 23953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 23973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 23993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 24013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 24023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ParseFunctionBody - Lazily parse the specified function body block. 24043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::ParseFunctionBody(Function *F) { 24053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) 24063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 24073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.clear(); 24093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ModuleValueListSize = ValueList.size(); 24103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ModuleMDValueListSize = MDValueList.size(); 24113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Add all the function arguments to the value table. 24133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) 24143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.push_back(I); 24153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NextValueNo = ValueList.size(); 24173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *CurBB = 0; 24183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned CurBBNo = 0; 24193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DebugLoc LastLoc; 2421c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 24223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read all the records. 24233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<uint64_t, 64> Record; 24243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (1) { 24253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Code = Stream.ReadCode(); 24263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::END_BLOCK) { 24273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.ReadBlockEnd()) 24283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Error at end of function block"); 24293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::ENTER_SUBBLOCK) { 24333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (Stream.ReadSubBlockID()) { 24343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Skip unknown content. 24353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Stream.SkipBlock()) 24363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Malformed block record"); 24373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::CONSTANTS_BLOCK_ID: 24393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ParseConstants()) return true; 24403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien NextValueNo = ValueList.size(); 24413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::VALUE_SYMTAB_BLOCK_ID: 24433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ParseValueSymbolTable()) return true; 24443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_ATTACHMENT_ID: 24463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ParseMetadataAttachment()) return true; 24473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::METADATA_BLOCK_ID: 24493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ParseMetadata()) return true; 24503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 24513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 24533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Code == bitc::DEFINE_ABBREV) { 24563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.ReadAbbrevRecord(); 24573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 24583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 24593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 24603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read a record. 24613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.clear(); 24623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Instruction *I = 0; 24633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned BitCode = Stream.ReadRecord(Code, Record); 24643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien switch (BitCode) { 24653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien default: // Default behavior: reject 24663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Unknown instruction"); 24673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks] 24683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1 || Record[0] == 0) 24693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid DECLAREBLOCKS record"); 24703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Create all the basic blocks for the function. 24713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionBBs.resize(Record[0]); 24723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) 24733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionBBs[i] = BasicBlock::Create(Context, "", F); 24743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CurBB = FunctionBBs[0]; 24753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 2476c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 24773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN 24783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // This record indicates that the last instruction is at the same 24793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // location as the previous instruction with a location. 24803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = 0; 2481c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 24823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // 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(); 2488c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 24893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I == 0) return Error("Invalid DEBUG_LOC_AGAIN record"); 24903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I->setDebugLoc(LastLoc); 24913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = 0; 24923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 2493c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 24943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia] 24953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = 0; // Get the last instruction emitted. 24963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CurBB && !CurBB->empty()) 24973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = &CurBB->back(); 24983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else if (CurBBNo && FunctionBBs[CurBBNo-1] && 24993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien !FunctionBBs[CurBBNo-1]->empty()) 25003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = &FunctionBBs[CurBBNo-1]->back(); 25013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I == 0 || Record.size() < 4) 25023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid FUNC_CODE_DEBUG_LOC record"); 2503c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 25043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Line = Record[0], Col = Record[1]; 25053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned ScopeID = Record[2], IAID = Record[3]; 2506c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 25073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDNode *Scope = 0, *IA = 0; 25083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ScopeID) Scope = cast<MDNode>(MDValueList.getValueFwdRef(ScopeID-1)); 25093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (IAID) IA = cast<MDNode>(MDValueList.getValueFwdRef(IAID-1)); 25103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LastLoc = DebugLoc::get(Line, Col, Scope, IA); 25113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I->setDebugLoc(LastLoc); 25123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = 0; 25133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien continue; 25143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode] 25173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 25183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *LHS, *RHS; 25193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 25203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, LHS->getType(), RHS) || 25213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+1 > Record.size()) 25223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid BINOP record"); 25233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); 25253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc == -1) return Error("Invalid BINOP record"); 25263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); 25273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 25283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpNum < Record.size()) { 25293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc == Instruction::Add || 25303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Sub || 25313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Mul || 25323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::Shl) { 25333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 25343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<BinaryOperator>(I)->setHasNoSignedWrap(true); 25353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 25363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true); 25373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else if (Opc == Instruction::SDiv || 25383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::UDiv || 25393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::LShr || 25403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Opc == Instruction::AShr) { 25413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record[OpNum] & (1 << bitc::PEO_EXACT)) 25423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<BinaryOperator>(I)->setIsExact(true); 25433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 25463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc] 25483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 25493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 25503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 25513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+2 != Record.size()) 25523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid CAST record"); 25533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ResTy = getTypeByID(Record[OpNum]); 25553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien int Opc = GetDecodedCastOpcode(Record[OpNum+1]); 25563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Opc == -1 || ResTy == 0) 25573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid CAST record"); 25583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy); 25593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 25603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 25613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INBOUNDS_GEP: 25633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands] 25643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 25653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *BasePtr; 25663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) 25673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid GEP record"); 25683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Value*, 16> GEPIdx; 25703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (OpNum != Record.size()) { 25713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 25723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 25733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid GEP record"); 25743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GEPIdx.push_back(Op); 25753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = GetElementPtrInst::Create(BasePtr, GEPIdx); 25783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 25793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP) 25803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<GetElementPtrInst>(I)->setIsInBounds(true); 25813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 25823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_EXTRACTVAL: { 25853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // EXTRACTVAL: [opty, opval, n x indices] 25863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 25873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Agg; 25883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 25893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid EXTRACTVAL record"); 25903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 25913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<unsigned, 4> EXTRACTVALIdx; 25923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned RecSize = Record.size(); 25933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum != RecSize; ++OpNum) { 25943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien uint64_t Index = Record[OpNum]; 25953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((unsigned)Index != Index) 25963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid EXTRACTVAL index"); 25973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien EXTRACTVALIdx.push_back((unsigned)Index); 25983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 25993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ExtractValueInst::Create(Agg, EXTRACTVALIdx); 26013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INSERTVAL: { 26063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // INSERTVAL: [opty, opval, opty, opval, n x indices] 26073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Agg; 26093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 26103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid INSERTVAL record"); 26113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Val; 26123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Val)) 26133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid INSERTVAL record"); 26143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<unsigned, 4> INSERTVALIdx; 26163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned RecSize = Record.size(); 26173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum != RecSize; ++OpNum) { 26183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien uint64_t Index = Record[OpNum]; 26193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((unsigned)Index != Index) 26203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid INSERTVAL index"); 26213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien INSERTVALIdx.push_back((unsigned)Index); 26223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = InsertValueInst::Create(Agg, Val, INSERTVALIdx); 26253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval] 26303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // obsolete form of select 26313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // handles select i1 ... in old bitcode 26323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *TrueVal, *FalseVal, *Cond; 26343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 26353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 26363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, Type::getInt1Ty(Context), Cond)) 26373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid SELECT record"); 26383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = SelectInst::Create(Cond, TrueVal, FalseVal); 26403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred] 26453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // new form of select 26463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // handles select i1 or select [N x i1] 26473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *TrueVal, *FalseVal, *Cond; 26493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 26503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 26513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValueTypePair(Record, OpNum, NextValueNo, Cond)) 26523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid SELECT record"); 26533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // select condition can be either i1 or [N x i1] 26553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (VectorType* vector_type = 26563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast<VectorType>(Cond->getType())) { 26573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // expect <n x i1> 26583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (vector_type->getElementType() != Type::getInt1Ty(Context)) 26593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid SELECT condition type"); 26603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 26613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // expect i1 26623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Cond->getType() != Type::getInt1Ty(Context)) 26633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid SELECT condition type"); 26643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = SelectInst::Create(Cond, TrueVal, FalseVal); 26673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval] 26723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Vec, *Idx; 26743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 26753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 26763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid EXTRACTELT record"); 26773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ExtractElementInst::Create(Vec, Idx); 26783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval] 26833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Vec, *Elt, *Idx; 26853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 26863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 26873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<VectorType>(Vec->getType())->getElementType(), Elt) || 26883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 26893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid INSERTELT record"); 26903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = InsertElementInst::Create(Vec, Elt, Idx); 26913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 26923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 26933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 26943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 26953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval] 26963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 26973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Vec1, *Vec2, *Mask; 26983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) || 26993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, Vec1->getType(), Vec2)) 27003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid SHUFFLEVEC record"); 27013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) 27033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid SHUFFLEVEC record"); 27043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new ShuffleVectorInst(Vec1, Vec2, Mask); 27053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred] 27103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Old form of ICmp/FCmp returning bool 27113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were 27123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // both legal on vectors but had different behaviour. 27133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred] 27143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FCmp/ICmp returning bool or vector of bool 27153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 27173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *LHS, *RHS; 27183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 27193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, LHS->getType(), RHS) || 27203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+1 != Record.size()) 27213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid CMP record"); 27223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (LHS->getType()->isFPOrFPVectorTy()) 27243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); 27253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 27263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS); 27273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>] 27323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien { 27333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Size = Record.size(); 27343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Size == 0) { 27353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ReturnInst::Create(Context); 27363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 27413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op = NULL; 27423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 27433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid RET record"); 27443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpNum != Record.size()) 27453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid RET record"); 27463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ReturnInst::Create(Context, Op); 27483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] 27523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() != 1 && Record.size() != 3) 27533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid BR record"); 27543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *TrueDest = getBasicBlock(Record[0]); 27553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (TrueDest == 0) 27563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid BR record"); 27573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 27583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() == 1) { 27593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = BranchInst::Create(TrueDest); 27603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else { 27633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *FalseDest = getBasicBlock(Record[1]); 27643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Cond = getFnValueByID(Record[2], Type::getInt1Ty(Context)); 27653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (FalseDest == 0 || Cond == 0) 27663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid BR record"); 27673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = BranchInst::Create(TrueDest, FalseDest, Cond); 27683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 27693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...] 27733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3 || (Record.size() & 1) == 0) 27743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid SWITCH record"); 27753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[0]); 27763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Cond = getFnValueByID(Record[1], OpTy); 27773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *Default = getBasicBlock(Record[2]); 27783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpTy == 0 || Cond == 0 || Default == 0) 27793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid SWITCH record"); 27803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumCases = (Record.size()-3)/2; 27813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); 27823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(SI); 27833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = NumCases; i != e; ++i) { 27843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ConstantInt *CaseVal = 27853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy)); 27863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); 27873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CaseVal == 0 || DestBB == 0) { 27883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete SI; 27893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid SWITCH record!"); 27903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SI->addCase(CaseVal, DestBB); 27923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = SI; 27943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 27953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 27963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] 27973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 2) 27983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid INDIRECTBR record"); 27993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[0]); 28003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Address = getFnValueByID(Record[1], OpTy); 28013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpTy == 0 || Address == 0) 28023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid INDIRECTBR record"); 28033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumDests = Record.size()-2; 28043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); 28053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(IBI); 28063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = NumDests; i != e; ++i) { 28073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) { 28083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien IBI->addDestination(DestBB); 28093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 28103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete IBI; 28113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid INDIRECTBR record!"); 28123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = IBI; 28153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 28163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 2817c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 28183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_INVOKE: { 28193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] 28203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 4) return Error("Invalid INVOKE record"); 28213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AttrListPtr PAL = getAttributes(Record[0]); 28223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned CCInfo = Record[1]; 28233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *NormalBB = getBasicBlock(Record[2]); 28243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *UnwindBB = getBasicBlock(Record[3]); 28253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 4; 28273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Callee; 28283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 28293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid INVOKE record"); 28303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); 28323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionType *FTy = !CalleeTy ? 0 : 28333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast<FunctionType>(CalleeTy->getElementType()); 28343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check that the right number of fixed parameters are here. 28363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (FTy == 0 || NormalBB == 0 || UnwindBB == 0 || 28373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Record.size() < OpNum+FTy->getNumParams()) 28383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid INVOKE record"); 28393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Value*, 16> Ops; 28413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 28423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ops.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 28433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ops.back() == 0) return Error("Invalid INVOKE record"); 28443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!FTy->isVarArg()) { 28473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() != OpNum) 28483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid INVOKE record"); 28493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 28503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read type/value pairs for varargs params. 28513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (OpNum != Record.size()) { 28523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 28533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 28543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid INVOKE record"); 28553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ops.push_back(Op); 28563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 28593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops); 28603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 28613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<InvokeInst>(I)->setCallingConv( 28623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien static_cast<CallingConv::ID>(CCInfo)); 28633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<InvokeInst>(I)->setAttributes(PAL); 28643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 28653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 28663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_RESUME: { // RESUME: [opval] 28673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Idx = 0; 28683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Val = 0; 28693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, Idx, NextValueNo, Val)) 28703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid RESUME record"); 28713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = ResumeInst::Create(Val); 28723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 28733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 28743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 2875c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao case FUNC_CODE_INST_UNWIND_2_7: { // UNWIND_OLD 2876c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao // 'unwind' instruction has been removed in LLVM 3.1 2877c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao // Replace 'unwind' with 'landingpad' and 'resume'. 2878c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Type *ExnTy = StructType::get(Type::getInt8PtrTy(Context), 2879c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Type::getInt32Ty(Context), NULL); 2880c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao Constant *PersFn = 2881c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao F->getParent()-> 2882c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao getOrInsertFunction("__gcc_personality_v0", 2883c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao FunctionType::get(Type::getInt32Ty(Context), true)); 2884c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 2885c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao LandingPadInst *LP = LandingPadInst::Create(ExnTy, PersFn, 1); 2886c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao LP->setCleanup(true); 2887c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao 2888c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao CurBB->getInstList().push_back(LP); 2889c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao I = ResumeInst::Create(LP); 28903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 28913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 2892c73b5214fa71ef6e3378fa121bb8b6312d2e6d3bShih-wei Liao } 28933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE 28943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new UnreachableInst(Context); 28953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 28963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 28973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...] 28983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 1 || ((Record.size()-1)&1)) 28993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid PHI record"); 29003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[0]); 29013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Ty) return Error("Invalid PHI record"); 29023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2); 29043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(PN); 29053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) { 29073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *V = getFnValueByID(Record[1+i], Ty); 29083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BasicBlock *BB = getBasicBlock(Record[2+i]); 29093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!V || !BB) return Error("Invalid PHI record"); 29103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PN->addIncoming(V, BB); 29113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = PN; 29133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 29143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_LANDINGPAD: { 29173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?] 29183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Idx = 0; 29193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 4) 29203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid LANDINGPAD record"); 29213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *Ty = getTypeByID(Record[Idx++]); 29223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Ty) return Error("Invalid LANDINGPAD record"); 29233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *PersFn = 0; 29243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, Idx, NextValueNo, PersFn)) 29253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid LANDINGPAD record"); 29263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien bool IsCleanup = !!Record[Idx++]; 29283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned NumClauses = Record[Idx++]; 29293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LandingPadInst *LP = LandingPadInst::Create(Ty, PersFn, NumClauses); 29303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LP->setCleanup(IsCleanup); 29313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned J = 0; J != NumClauses; ++J) { 29323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LandingPadInst::ClauseType CT = 29333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LandingPadInst::ClauseType(Record[Idx++]); (void)CT; 29343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Val; 29353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, Idx, NextValueNo, Val)) { 29373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete LP; 29383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid LANDINGPAD record"); 29393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert((CT != LandingPadInst::Catch || 29423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien !isa<ArrayType>(Val->getType())) && 29433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien "Catch clause has a invalid type!"); 29443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert((CT != LandingPadInst::Filter || 29453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien isa<ArrayType>(Val->getType())) && 29463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien "Filter clause has invalid type!"); 29473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien LP->addClause(Val); 29483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = LP; 29513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 29523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 29533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align] 29563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() != 4) 29573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid ALLOCA record"); 29583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PointerType *Ty = 29593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien dyn_cast_or_null<PointerType>(getTypeByID(Record[0])); 29603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[1]); 29613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Size = getFnValueByID(Record[2], OpTy); 29623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned Align = Record[3]; 29633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!Ty || !Size) return Error("Invalid ALLOCA record"); 29643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); 29653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 29663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 29673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol] 29693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 29703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 29713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 29723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+2 != Record.size()) 29733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid LOAD record"); 29743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); 29763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 29773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 29783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 29793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_LOADATOMIC: { 29803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // LOADATOMIC: [opty, op, align, vol, ordering, synchscope] 29813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 29823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 29833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 29843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+4 != Record.size()) 29853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid LOADATOMIC record"); 2986c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 29873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); 29893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Release || 29903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering == AcquireRelease) 29913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid LOADATOMIC record"); 29923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering != NotAtomic && Record[OpNum] == 0) 29933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid LOADATOMIC record"); 29943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); 29953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 29963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1, 29973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering, SynchScope); 29983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 29993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_STORE: { // STORE2:[ptrty, ptr, val, align, vol] 30023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 30033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Val, *Ptr; 30043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 30053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), Val) || 30073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+2 != Record.size()) 30083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid STORE record"); 30093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 30103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 30113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_STOREATOMIC: { 30153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // STOREATOMIC: [ptrty, ptr, val, align, vol, ordering, synchscope] 30163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 30173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Val, *Ptr; 30183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 30193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), Val) || 30213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+4 != Record.size()) 30223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid STOREATOMIC record"); 30233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 30243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); 30253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Acquire || 30263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering == AcquireRelease) 30273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid STOREATOMIC record"); 30283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); 30293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering != NotAtomic && Record[OpNum] == 0) 30303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid STOREATOMIC record"); 30313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 30323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1, 30333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering, SynchScope); 30343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CMPXCHG: { 30383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // CMPXCHG:[ptrty, ptr, cmp, new, vol, ordering, synchscope] 30393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 30403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Ptr, *Cmp, *New; 30413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 30423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), Cmp) || 30443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), New) || 30463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+3 != Record.size()) 30473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid CMPXCHG record"); 30483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+1]); 30493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Unordered) 30503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid CMPXCHG record"); 30513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+2]); 30523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new AtomicCmpXchgInst(Ptr, Cmp, New, Ordering, SynchScope); 30533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]); 30543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_ATOMICRMW: { 30583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // ATOMICRMW:[ptrty, ptr, val, op, vol, ordering, synchscope] 30593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 0; 30603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Ptr, *Val; 30613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 30623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien getValue(Record, OpNum, 30633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<PointerType>(Ptr->getType())->getElementType(), Val) || 30643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien OpNum+4 != Record.size()) 30653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid ATOMICRMW record"); 30663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicRMWInst::BinOp Operation = GetDecodedRMWOperation(Record[OpNum]); 30673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Operation < AtomicRMWInst::FIRST_BINOP || 30683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Operation > AtomicRMWInst::LAST_BINOP) 30693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid ATOMICRMW record"); 30703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); 30713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Unordered) 30723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid ATOMICRMW record"); 30733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); 30743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SynchScope); 30753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]); 30763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, synchscope] 30803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (2 != Record.size()) 30813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid FENCE record"); 30823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AtomicOrdering Ordering = GetDecodedOrdering(Record[0]); 30833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Ordering == NotAtomic || Ordering == Unordered || 30843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Ordering == Monotonic) 30853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid FENCE record"); 30863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SynchronizationScope SynchScope = GetDecodedSynchScope(Record[1]); 30873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new FenceInst(Context, Ordering, SynchScope); 30883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 30893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 30903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 30913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_CALL: { 30923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] 30933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 30943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid CALL record"); 30953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 30963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien AttrListPtr PAL = getAttributes(Record[0]); 30973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned CCInfo = Record[1]; 30983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 30993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned OpNum = 2; 31003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Callee; 31013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 31023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid CALL record"); 31033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); 31053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FunctionType *FTy = 0; 31063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType()); 31073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!FTy || Record.size() < FTy->getNumParams()+OpNum) 31083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid CALL record"); 31093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien SmallVector<Value*, 16> Args; 31113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read the fixed params. 31123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 31133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (FTy->getParamType(i)->isLabelTy()) 31143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Args.push_back(getBasicBlock(Record[OpNum])); 31153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien else 31163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Args.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 31173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Args.back() == 0) return Error("Invalid CALL record"); 31183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read type/value pairs for varargs params. 31213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!FTy->isVarArg()) { 31223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (OpNum != Record.size()) 31233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid CALL record"); 31243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } else { 31253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien while (OpNum != Record.size()) { 31263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op; 31273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 31283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid CALL record"); 31293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Args.push_back(Op); 31303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = CallInst::Create(Callee, Args); 31343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 31353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<CallInst>(I)->setCallingConv( 31363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien static_cast<CallingConv::ID>(CCInfo>>1)); 31373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<CallInst>(I)->setTailCall(CCInfo & 1); 31383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien cast<CallInst>(I)->setAttributes(PAL); 31393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 31403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] 31423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Record.size() < 3) 31433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid VAARG record"); 31443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *OpTy = getTypeByID(Record[0]); 31453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Value *Op = getFnValueByID(Record[1], OpTy); 31463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Type *ResTy = getTypeByID(Record[2]); 31473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!OpTy || !Op || !ResTy) 31483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid VAARG record"); 31493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I = new VAArgInst(Op, ResTy); 31503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien InstructionList.push_back(I); 31513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien break; 31523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Add instruction to end of current BB. If there is no current BB, reject 31563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // this file. 31573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CurBB == 0) { 31583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete I; 31593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid instruction with no BB"); 31603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CurBB->getInstList().push_back(I); 31623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If this was a terminator instruction, move to the next block. 31643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (isa<TerminatorInst>(I)) { 31653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ++CurBBNo; 31663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0; 31673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Non-void values get registered in the value table for future use. 31703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I && !I->getType()->isVoidTy()) 31713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.AssignValue(I, NextValueNo++); 31723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check the function list for unresolved values. 31753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (Argument *A = dyn_cast<Argument>(ValueList.back())) { 31763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (A->getParent() == 0) { 31773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // We found at least one unresolved value. Nuke them all to avoid leaks. 31783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){ 31793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if ((A = dyn_cast<Argument>(ValueList[i])) && A->getParent() == 0) { 31803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien A->replaceAllUsesWith(UndefValue::get(A->getType())); 31813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete A; 31823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Never resolved value found in function!"); 31853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 31873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // FIXME: Check for unresolved forward-declared metadata references 31893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // and clean up leaks. 31903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 31913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // See if anything took the address of blocks in this function. If so, 31923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // resolve them now. 31933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DenseMap<Function*, std::vector<BlockAddrRefTy> >::iterator BAFRI = 31943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BlockAddrFwdRefs.find(F); 31953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BAFRI != BlockAddrFwdRefs.end()) { 31963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<BlockAddrRefTy> &RefList = BAFRI->second; 31973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (unsigned i = 0, e = RefList.size(); i != e; ++i) { 31983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien unsigned BlockIdx = RefList[i].first; 31993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (BlockIdx >= FunctionBBs.size()) 32003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Error("Invalid blockaddress block #"); 3201c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 32023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien GlobalVariable *FwdRef = RefList[i].second; 32033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx])); 32043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien FwdRef->eraseFromParent(); 32053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 3206c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 32073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BlockAddrFwdRefs.erase(BAFRI); 32083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 3209c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien 32103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Trim the value list down to the size it was before we parsed this function. 32113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien ValueList.shrinkTo(ModuleValueListSize); 32123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien MDValueList.shrinkTo(ModuleMDValueListSize); 32133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<BasicBlock*>().swap(FunctionBBs); 32143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 32153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 32163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 32183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// GVMaterializer implementation 32193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 32203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::isMaterializable(const GlobalValue *GV) const { 32233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (const Function *F = dyn_cast<Function>(GV)) { 32243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return F->isDeclaration() && 32253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DeferredFunctionInfo.count(const_cast<Function*>(F)); 32263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32273bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 32283bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 32293bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::Materialize(GlobalValue *GV, std::string *ErrInfo) { 32313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *F = dyn_cast<Function>(GV); 32323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If it's not a function or is already material, ignore the request. 32333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!F || !F->isMaterializable()) return false; 32343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F); 32363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!"); 32373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Move the bit stream to the saved position of the deferred function body. 32393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Stream.JumpToBit(DFII->second); 32403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ParseFunctionBody(F)) { 32423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ErrInfo) *ErrInfo = ErrorString; 32433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return true; 32443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Upgrade any old intrinsic calls in the function. 32473bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(), 32483bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien E = UpgradedIntrinsics.end(); I != E; ++I) { 32493bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I->first != I->second) { 32503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (Value::use_iterator UI = I->first->use_begin(), 32513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UE = I->first->use_end(); UI != UE; ) { 32523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 32533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UpgradeIntrinsicCall(CI, I->second); 32543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 32573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 32593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 32603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::isDematerializable(const GlobalValue *GV) const { 32623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien const Function *F = dyn_cast<Function>(GV); 32633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!F || F->isDeclaration()) 32643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 32653bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return DeferredFunctionInfo.count(const_cast<Function*>(F)); 32663bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 32673bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienvoid BitcodeReader::Dematerialize(GlobalValue *GV) { 32693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Function *F = dyn_cast<Function>(GV); 32703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // If this function isn't dematerializable, this is a noop. 32713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!F || !isDematerializable(F)) 32723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return; 32733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(DeferredFunctionInfo.count(F) && "No info to read function later?"); 32753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Just forget the function body, we can remat it later. 32773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien F->deleteBody(); 32783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 32793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32803bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32813bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chienbool BitcodeReader::MaterializeModule(Module *M, std::string *ErrInfo) { 32823bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien assert(M == TheModule && 32833bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien "Can only Materialize the Module this BitcodeReader is attached to."); 32843bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Iterate over the module, deserializing any functions that are still on 32853bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // disk. 32863bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (Module::iterator F = TheModule->begin(), E = TheModule->end(); 32873bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien F != E; ++F) 32883bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (F->isMaterializable() && 32893bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Materialize(F, ErrInfo)) 32903bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return true; 32913bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 32923bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Upgrade any intrinsic calls that slipped through (should not happen!) and 32933bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // delete the old functions to clean up. We can't do this unless the entire 32943bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // module is materialized because there could always be another function body 32953bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // with calls to the old function. 32963bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (std::vector<std::pair<Function*, Function*> >::iterator I = 32973bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) { 32983bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (I->first != I->second) { 32993bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien for (Value::use_iterator UI = I->first->use_begin(), 33003bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UE = I->first->use_end(); UI != UE; ) { 33013bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 33023bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UpgradeIntrinsicCall(CI, I->second); 33033bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 33043bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!I->first->use_empty()) 33053bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I->first->replaceAllUsesWith(I->second); 33063bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien I->first->eraseFromParent(); 33073bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 33083bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 33093bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics); 33103bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33113bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Upgrade to new EH scheme. N.B. This will go away in 3.1. 33123bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien UpgradeExceptionHandling(M); 33133bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33143bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Check debug info intrinsics. 33153bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien CheckDebugInfoIntrinsics(TheModule); 33163bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33173bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return false; 33183bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 33193bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33203bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33213bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 33223bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien// External interface 33233bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien//===----------------------------------------------------------------------===// 33243bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33253bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// getLazyBitcodeModule - lazy function-at-a-time loading from a file. 33263bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// 3327c7d67a701663191bcdab2416c11b69fae16d49fbLogan ChienModule *llvm_3_0::getLazyBitcodeModule(MemoryBuffer *Buffer, 3328c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LLVMContext& Context, 3329c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien std::string *ErrMsg) { 33303bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien Module *M = new Module(Buffer->getBufferIdentifier(), Context); 33313bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BitcodeReader *R = new BitcodeReader(Buffer, Context); 33323bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien M->setMaterializer(R); 33333bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (R->ParseBitcodeInto(M)) { 33343bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ErrMsg) 33353bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien *ErrMsg = R->getErrorString(); 33363bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33373bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete M; // Also deletes R. 33383bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return 0; 33393bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 33403bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Have the BitcodeReader dtor delete 'Buffer'. 33413bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien R->setBufferOwned(true); 33423bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return M; 33433bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 33443bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33453bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// ParseBitcodeFile - Read the specified bitcode file, returning the module. 33463bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien/// If an error occurs, return null and fill in *ErrMsg if non-null. 3347c7d67a701663191bcdab2416c11b69fae16d49fbLogan ChienModule *llvm_3_0::ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext& Context, 3348c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien std::string *ErrMsg){ 3349c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien Module *M = llvm_3_0::getLazyBitcodeModule(Buffer, Context, ErrMsg); 33503bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (!M) return 0; 33513bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33523bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether 33533bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // there was an error. 33543bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien static_cast<BitcodeReader*>(M->getMaterializer())->setBufferOwned(false); 33553bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33563bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Read in the entire module, and destroy the BitcodeReader. 33573bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (M->MaterializeAllPermanently(ErrMsg)) { 33583bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete M; 33593bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return 0; 33603bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien } 33613bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33623bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return M; 33633bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 33643bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 3365c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chienstd::string llvm_3_0::getBitcodeTargetTriple(MemoryBuffer *Buffer, 3366c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien LLVMContext& Context, 3367c7d67a701663191bcdab2416c11b69fae16d49fbLogan Chien std::string *ErrMsg) { 33683bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien BitcodeReader *R = new BitcodeReader(Buffer, Context); 33693bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien // Don't let the BitcodeReader dtor delete 'Buffer'. 33703bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien R->setBufferOwned(false); 33713bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33723bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien std::string Triple(""); 33733bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (R->ParseTriple(Triple)) 33743bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien if (ErrMsg) 33753bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien *ErrMsg = R->getErrorString(); 33763bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien 33773bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien delete R; 33783bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien return Triple; 33793bdc2a8fde18e9e82a1e6ccef1c7379ef57bca35Logan Chien} 3380