+
+
+bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo) {
+ // If it already is material, ignore the request.
+ if (!F->hasNotBeenReadFromBytecode()) return false;
+
+ DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator DFII =
+ DeferredFunctionInfo.find(F);
+ assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!");
+
+ // Move the bit stream to the saved position of the deferred function body and
+ // restore the real linkage type for the function.
+ Stream.JumpToBit(DFII->second.first);
+ F->setLinkage((GlobalValue::LinkageTypes)DFII->second.second);
+ DeferredFunctionInfo.erase(DFII);
+
+ if (ParseFunctionBody(F)) {
+ if (ErrInfo) *ErrInfo = ErrorString;
+ return true;
+ }
+
+ return false;
+}
+
+Module *BitcodeReader::materializeModule(std::string *ErrInfo) {
+ DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator I =
+ DeferredFunctionInfo.begin();
+ while (!DeferredFunctionInfo.empty()) {
+ Function *F = (*I++).first;
+ assert(F->hasNotBeenReadFromBytecode() &&
+ "Deserialized function found in map!");
+ if (materializeFunction(F, ErrInfo))
+ return 0;
+ }
+ return TheModule;
+}
+
+
+/// ParseFunctionBody - Lazily parse the specified function body block.
+bool BitcodeReader::ParseFunctionBody(Function *F) {
+ if (Stream.EnterSubBlock())
+ return Error("Malformed block record");
+
+ unsigned ModuleValueListSize = ValueList.size();
+
+ // Add all the function arguments to the value table.
+ for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I)
+ ValueList.push_back(I);
+
+ unsigned NextValueNo = ValueList.size();
+ BasicBlock *CurBB = 0;
+ unsigned CurBBNo = 0;
+
+ // Read all the records.
+ SmallVector<uint64_t, 64> Record;
+ while (1) {
+ unsigned Code = Stream.ReadCode();
+ if (Code == bitc::END_BLOCK) {
+ if (Stream.ReadBlockEnd())
+ return Error("Error at end of function block");
+ break;
+ }
+
+ if (Code == bitc::ENTER_SUBBLOCK) {
+ switch (Stream.ReadSubBlockID()) {
+ default: // Skip unknown content.
+ if (Stream.SkipBlock())
+ return Error("Malformed block record");
+ break;
+ case bitc::CONSTANTS_BLOCK_ID:
+ if (ParseConstants()) return true;
+ NextValueNo = ValueList.size();
+ break;
+ case bitc::VALUE_SYMTAB_BLOCK_ID:
+ if (ParseValueSymbolTable()) return true;
+ break;
+ }
+ continue;
+ }
+
+ if (Code == bitc::DEFINE_ABBREV) {
+ Stream.ReadAbbrevRecord();
+ continue;
+ }
+
+ // Read a record.
+ Record.clear();
+ Instruction *I = 0;
+ switch (Stream.ReadRecord(Code, Record)) {
+ default: // Default behavior: reject
+ return Error("Unknown instruction");
+ case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks]
+ if (Record.size() < 1 || Record[0] == 0)
+ return Error("Invalid DECLAREBLOCKS record");
+ // Create all the basic blocks for the function.
+ FunctionBBs.resize(Record.size());
+ for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i)
+ FunctionBBs[i] = new BasicBlock("", F);
+ CurBB = FunctionBBs[0];
+ continue;
+
+ case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opcode, ty, opval, opval]
+ if (Record.size() < 4) return Error("Invalid BINOP record");
+ const Type *Ty = getTypeByID(Record[1]);
+ int Opc = GetDecodedBinaryOpcode(Record[0], Ty);
+ Value *LHS = getFnValueByID(Record[2], Ty);
+ Value *RHS = getFnValueByID(Record[3], Ty);
+ if (Opc == -1 || Ty == 0 || LHS == 0 || RHS == 0)
+ return Error("Invalid BINOP record");
+ I = BinaryOperator::create((Instruction::BinaryOps)Opc, LHS, RHS);
+ break;
+ }
+ case bitc::FUNC_CODE_INST_CAST: { // CAST: [opcode, ty, opty, opval]
+ if (Record.size() < 4) return Error("Invalid CAST record");
+ int Opc = GetDecodedCastOpcode(Record[0]);
+ const Type *ResTy = getTypeByID(Record[1]);
+ const Type *OpTy = getTypeByID(Record[2]);
+ Value *Op = getFnValueByID(Record[3], OpTy);
+ if (Opc == -1 || ResTy == 0 || OpTy == 0 || Op == 0)
+ return Error("Invalid CAST record");
+ I = CastInst::create((Instruction::CastOps)Opc, Op, ResTy);
+ break;
+ }
+ case bitc::FUNC_CODE_INST_GEP: { // GEP: [n, n x operands]
+ if (Record.size() < 2 || (Record.size() & 1))
+ return Error("Invalid GEP record");
+ const Type *OpTy = getTypeByID(Record[0]);
+ Value *Op = getFnValueByID(Record[1], OpTy);
+ if (OpTy == 0 || Op == 0)
+ return Error("Invalid GEP record");
+
+ SmallVector<Value*, 8> GEPIdx;
+ for (unsigned i = 1, e = Record.size()/2; i != e; ++i) {
+ const Type *IdxTy = getTypeByID(Record[i*2]);
+ Value *Idx = getFnValueByID(Record[i*2+1], IdxTy);
+ if (IdxTy == 0 || Idx == 0)
+ return Error("Invalid GEP record");
+ GEPIdx.push_back(Idx);
+ }
+
+ I = new GetElementPtrInst(Op, &GEPIdx[0], GEPIdx.size());
+ break;
+ }
+
+ case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [ty, opval, opval, opval]
+ if (Record.size() < 4) return Error("Invalid SELECT record");
+ const Type *Ty = getTypeByID(Record[0]);
+ Value *Cond = getFnValueByID(Record[1], Type::Int1Ty);
+ Value *LHS = getFnValueByID(Record[2], Ty);
+ Value *RHS = getFnValueByID(Record[3], Ty);
+ if (Ty == 0 || Cond == 0 || LHS == 0 || RHS == 0)
+ return Error("Invalid SELECT record");
+ I = new SelectInst(Cond, LHS, RHS);
+ break;
+ }
+
+ case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval]
+ if (Record.size() < 3) return Error("Invalid EXTRACTELT record");
+ const Type *OpTy = getTypeByID(Record[0]);
+ Value *Vec = getFnValueByID(Record[1], OpTy);
+ Value *Idx = getFnValueByID(Record[2], Type::Int32Ty);
+ if (OpTy == 0 || Vec == 0 || Idx == 0)
+ return Error("Invalid EXTRACTELT record");
+ I = new ExtractElementInst(Vec, Idx);
+ break;
+ }
+
+ case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval]
+ if (Record.size() < 4) return Error("Invalid INSERTELT record");
+ const VectorType *OpTy =
+ dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
+ if (OpTy == 0) return Error("Invalid INSERTELT record");
+ Value *Vec = getFnValueByID(Record[1], OpTy);
+ Value *Elt = getFnValueByID(Record[2], OpTy->getElementType());
+ Value *Idx = getFnValueByID(Record[3], Type::Int32Ty);
+ if (Vec == 0 || Elt == 0 || Idx == 0)
+ return Error("Invalid INSERTELT record");
+ I = new InsertElementInst(Vec, Elt, Idx);
+ break;
+ }
+
+ case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [ty,opval,opval,opval]
+ if (Record.size() < 4) return Error("Invalid SHUFFLEVEC record");
+ const VectorType *OpTy =
+ dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
+ if (OpTy == 0) return Error("Invalid SHUFFLEVEC record");
+ Value *Vec1 = getFnValueByID(Record[1], OpTy);
+ Value *Vec2 = getFnValueByID(Record[2], OpTy);
+ Value *Mask = getFnValueByID(Record[3],
+ VectorType::get(Type::Int32Ty,
+ OpTy->getNumElements()));
+ if (Vec1 == 0 || Vec2 == 0 || Mask == 0)
+ return Error("Invalid SHUFFLEVEC record");
+ I = new ShuffleVectorInst(Vec1, Vec2, Mask);
+ break;
+ }
+
+ case bitc::FUNC_CODE_INST_CMP: { // CMP: [opty, opval, opval, pred]
+ if (Record.size() < 4) return Error("Invalid CMP record");
+ const Type *OpTy = getTypeByID(Record[0]);
+ Value *LHS = getFnValueByID(Record[1], OpTy);
+ Value *RHS = getFnValueByID(Record[2], OpTy);
+ if (OpTy == 0 || LHS == 0 || RHS == 0)
+ return Error("Invalid CMP record");
+ if (OpTy->isFPOrFPVector())
+ I = new FCmpInst((FCmpInst::Predicate)Record[3], LHS, RHS);
+ else
+ I = new ICmpInst((ICmpInst::Predicate)Record[3], LHS, RHS);
+ break;
+ }
+
+ case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>]
+ if (Record.size() == 0) {
+ I = new ReturnInst();
+ break;
+ }
+ if (Record.size() == 2) {
+ const Type *OpTy = getTypeByID(Record[0]);
+ Value *Op = getFnValueByID(Record[1], OpTy);
+ if (OpTy && Op);
+ I = new ReturnInst(Op);
+ break;
+ }
+ return Error("Invalid RET record");
+#if 0
+ case bitc::FUNC_CODE_INST_BR:
+ // BR: [opval, bb#, bb#] or [bb#]
+ case bitc::FUNC_CODE_INST_SWITCH:
+ // SWITCH: [opty, opval, n, n x ops]
+ case bitc::FUNC_CODE_INST_INVOKE:
+ // INVOKE: [fnty, op0,op1,op2, ...]
+ case bitc::FUNC_CODE_INST_UNWIND: // UNWIND
+ I = new UnwindInst();
+ break;
+ case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE
+ I = new UnreachableInst();
+ break;
+
+ case bitc::FUNC_CODE_INST_PHI:
+ // PHI: [ty, #ops, val0,bb0, ...]
+ case bitc::FUNC_CODE_INST_MALLOC:
+ // MALLOC: [instty, op, align]
+ case bitc::FUNC_CODE_INST_FREE:
+ // FREE: [opty, op]
+ case bitc::FUNC_CODE_INST_ALLOCA:
+ // ALLOCA: [instty, op, align]
+ case bitc::FUNC_CODE_INST_LOAD:
+ // LOAD: [opty, op, align, vol]
+ case bitc::FUNC_CODE_INST_STORE:
+ // STORE: [ptrty,val,ptr, align, vol]
+ case bitc::FUNC_CODE_INST_CALL:
+ // CALL: [fnty, fnid, arg0, arg1...]
+ case bitc::FUNC_CODE_INST_VAARG:
+ // VAARG: [valistty, valist, instty]
+ break;
+#endif
+ }
+
+ // Add instruction to end of current BB. If there is no current BB, reject
+ // this file.
+ if (CurBB == 0) {
+ delete I;
+ return Error("Invalid instruction with no BB");
+ }
+ CurBB->getInstList().push_back(I);
+
+ // If this was a terminator instruction, move to the next block.
+ if (isa<TerminatorInst>(I)) {
+ ++CurBBNo;
+ CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0;
+ }
+
+ // Non-void values get registered in the value table for future use.
+ if (I && I->getType() != Type::VoidTy)
+ ValueList.AssignValue(I, NextValueNo++);
+ }
+
+ // Check the function list for unresolved values.
+ if (Argument *A = dyn_cast<Argument>(ValueList.back())) {
+ if (A->getParent() == 0) {
+ // We found at least one unresolved value. Nuke them all to avoid leaks.
+ for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){
+ if ((A = dyn_cast<Argument>(ValueList.back())) && A->getParent() == 0) {
+ A->replaceAllUsesWith(UndefValue::get(A->getType()));
+ delete A;
+ }
+ }
+ }
+ return Error("Never resolved value found in function!");
+ }
+
+ // Trim the value list down to the size it was before we parsed this function.
+ ValueList.shrinkTo(ModuleValueListSize);
+ std::vector<BasicBlock*>().swap(FunctionBBs);
+
+ return false;
+}
+
+
+//===----------------------------------------------------------------------===//
+// External interface
+//===----------------------------------------------------------------------===//
+
+/// getBitcodeModuleProvider - lazy function-at-a-time loading from a file.
+///
+ModuleProvider *llvm::getBitcodeModuleProvider(MemoryBuffer *Buffer,
+ std::string *ErrMsg) {
+ BitcodeReader *R = new BitcodeReader(Buffer);
+ if (R->ParseBitcode()) {
+ if (ErrMsg)
+ *ErrMsg = R->getErrorString();
+
+ // Don't let the BitcodeReader dtor delete 'Buffer'.
+ R->releaseMemoryBuffer();
+ delete R;
+ return 0;
+ }
+ return R;
+}
+
+/// ParseBitcodeFile - Read the specified bitcode file, returning the module.
+/// If an error occurs, return null and fill in *ErrMsg if non-null.
+Module *llvm::ParseBitcodeFile(MemoryBuffer *Buffer, std::string *ErrMsg){
+ BitcodeReader *R;
+ R = static_cast<BitcodeReader*>(getBitcodeModuleProvider(Buffer, ErrMsg));
+ if (!R) return 0;
+
+ // Read the whole module, get a pointer to it, tell ModuleProvider not to
+ // delete it when its dtor is run.
+ Module *M = R->releaseModule(ErrMsg);
+
+ // Don't let the BitcodeReader dtor delete 'Buffer'.
+ R->releaseMemoryBuffer();
+ delete R;
+ return M;
+}