//
//===----------------------------------------------------------------------===//
+#include "llvm/Bitcode/ReaderWriter.h"
#include "BitcodeReader.h"
-#include "llvm/Bitcode/BitstreamReader.h"
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
+#include "llvm/Instructions.h"
#include "llvm/Module.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/MemoryBuffer.h"
using namespace llvm;
+BitcodeReader::~BitcodeReader() {
+ delete Buffer;
+}
+
+
/// ConvertToString - Convert a string from a record into an std::string, return
/// true on failure.
template<typename StrTy>
default: // Map unknown visibilities to default.
case 0: return GlobalValue::DefaultVisibility;
case 1: return GlobalValue::HiddenVisibility;
+ case 2: return GlobalValue::ProtectedVisibility;
}
}
NumOperands = Idx+1;
}
- if (Uses[Idx]) {
- assert(Ty == getOperand(Idx)->getType() &&
- "Type mismatch in constant table!");
- return cast<Constant>(getOperand(Idx));
+ if (Value *V = Uses[Idx]) {
+ assert(Ty == V->getType() && "Type mismatch in constant table!");
+ return cast<Constant>(V);
}
// Create and return a placeholder, which will later be RAUW'd.
return C;
}
+Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, const Type *Ty) {
+ if (Idx >= size()) {
+ // Insert a bunch of null values.
+ Uses.resize(Idx+1);
+ OperandList = &Uses[0];
+ NumOperands = Idx+1;
+ }
+
+ if (Value *V = Uses[Idx]) {
+ assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!");
+ return V;
+ }
+
+ // No type specified, must be invalid reference.
+ if (Ty == 0) return 0;
+
+ // Create and return a placeholder, which will later be RAUW'd.
+ Value *V = new Argument(Ty);
+ Uses[Idx].init(V, this);
+ return V;
+}
+
const Type *BitcodeReader::getTypeByID(unsigned ID, bool isTypeTable) {
// If the TypeID is in range, return it.
return TypeList.back().get();
}
-
-bool BitcodeReader::ParseTypeTable(BitstreamReader &Stream) {
+bool BitcodeReader::ParseTypeTable() {
if (Stream.EnterSubBlock())
return Error("Malformed block record");
}
-bool BitcodeReader::ParseTypeSymbolTable(BitstreamReader &Stream) {
+bool BitcodeReader::ParseTypeSymbolTable() {
if (Stream.EnterSubBlock())
return Error("Malformed block record");
}
}
-bool BitcodeReader::ParseValueSymbolTable(BitstreamReader &Stream) {
+bool BitcodeReader::ParseValueSymbolTable() {
if (Stream.EnterSubBlock())
return Error("Malformed block record");
return 1ULL << 63;
}
-bool BitcodeReader::ParseConstants(BitstreamReader &Stream) {
+/// ResolveGlobalAndAliasInits - Resolve all of the initializers for global
+/// values and aliases that we can.
+bool BitcodeReader::ResolveGlobalAndAliasInits() {
+ std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist;
+ std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist;
+
+ GlobalInitWorklist.swap(GlobalInits);
+ AliasInitWorklist.swap(AliasInits);
+
+ while (!GlobalInitWorklist.empty()) {
+ unsigned ValID = GlobalInitWorklist.back().second;
+ if (ValID >= ValueList.size()) {
+ // Not ready to resolve this yet, it requires something later in the file.
+ GlobalInits.push_back(GlobalInitWorklist.back());
+ } else {
+ if (Constant *C = dyn_cast<Constant>(ValueList[ValID]))
+ GlobalInitWorklist.back().first->setInitializer(C);
+ else
+ return Error("Global variable initializer is not a constant!");
+ }
+ GlobalInitWorklist.pop_back();
+ }
+
+ while (!AliasInitWorklist.empty()) {
+ unsigned ValID = AliasInitWorklist.back().second;
+ if (ValID >= ValueList.size()) {
+ AliasInits.push_back(AliasInitWorklist.back());
+ } else {
+ if (Constant *C = dyn_cast<Constant>(ValueList[ValID]))
+ AliasInitWorklist.back().first->setAliasee(C);
+ else
+ return Error("Alias initializer is not a constant!");
+ }
+ AliasInitWorklist.pop_back();
+ }
+ return false;
+}
+
+
+bool BitcodeReader::ParseConstants() {
if (Stream.EnterSubBlock())
return Error("Malformed block record");
while (1) {
unsigned Code = Stream.ReadCode();
if (Code == bitc::END_BLOCK) {
- // If there are global var inits to process, do so now.
- if (!GlobalInits.empty()) {
- while (!GlobalInits.empty()) {
- unsigned ValID = GlobalInits.back().second;
- if (ValID >= ValueList.size())
- return Error("Invalid value ID for global var init!");
- if (Constant *C = dyn_cast<Constant>(ValueList[ValID]))
- GlobalInits.back().first->setInitializer(C);
- else
- return Error("Global variable initializer is not a constant!");
- GlobalInits.pop_back();
- }
- }
-
if (NextCstNo != ValueList.size())
return Error("Invalid constant reference!");
}
}
- if (NextCstNo == ValueList.size())
- ValueList.push_back(V);
- else if (ValueList[NextCstNo] == 0)
- ValueList.initVal(NextCstNo, V);
- else {
- // If there was a forward reference to this constant,
- Value *OldV = ValueList[NextCstNo];
- ValueList.setOperand(NextCstNo, V);
- OldV->replaceAllUsesWith(V);
- delete OldV;
- }
-
+ ValueList.AssignValue(V, NextCstNo);
++NextCstNo;
}
}
-bool BitcodeReader::ParseModule(BitstreamReader &Stream,
- const std::string &ModuleID) {
+/// RememberAndSkipFunctionBody - When we see the block for a function body,
+/// remember where it is and then skip it. This lets us lazily deserialize the
+/// functions.
+bool BitcodeReader::RememberAndSkipFunctionBody() {
+ // Get the function we are talking about.
+ if (FunctionsWithBodies.empty())
+ return Error("Insufficient function protos");
+
+ Function *Fn = FunctionsWithBodies.back();
+ FunctionsWithBodies.pop_back();
+
+ // Save the current stream state.
+ uint64_t CurBit = Stream.GetCurrentBitNo();
+ DeferredFunctionInfo[Fn] = std::make_pair(CurBit, Fn->getLinkage());
+
+ // Set the functions linkage to GhostLinkage so we know it is lazily
+ // deserialized.
+ Fn->setLinkage(GlobalValue::GhostLinkage);
+
+ // Skip over the function block for now.
+ if (Stream.SkipBlock())
+ return Error("Malformed block record");
+ return false;
+}
+
+bool BitcodeReader::ParseModule(const std::string &ModuleID) {
// Reject multiple MODULE_BLOCK's in a single bitstream.
if (TheModule)
return Error("Multiple MODULE_BLOCKs in same stream");
while (!Stream.AtEndOfStream()) {
unsigned Code = Stream.ReadCode();
if (Code == bitc::END_BLOCK) {
- if (!GlobalInits.empty())
- return Error("Malformed global initializer set");
if (Stream.ReadBlockEnd())
return Error("Error at end of module block");
+
+ // Patch the initializers for globals and aliases up.
+ ResolveGlobalAndAliasInits();
+ if (!GlobalInits.empty() || !AliasInits.empty())
+ return Error("Malformed global initializer set");
+ if (!FunctionsWithBodies.empty())
+ return Error("Too few function bodies found");
+
+ // Force deallocation of memory for these vectors to favor the client that
+ // want lazy deserialization.
+ std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits);
+ std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits);
+ std::vector<Function*>().swap(FunctionsWithBodies);
return false;
}
return Error("Malformed block record");
break;
case bitc::TYPE_BLOCK_ID:
- if (ParseTypeTable(Stream))
+ if (ParseTypeTable())
return true;
break;
case bitc::TYPE_SYMTAB_BLOCK_ID:
- if (ParseTypeSymbolTable(Stream))
+ if (ParseTypeSymbolTable())
return true;
break;
case bitc::VALUE_SYMTAB_BLOCK_ID:
- if (ParseValueSymbolTable(Stream))
+ if (ParseValueSymbolTable())
return true;
break;
case bitc::CONSTANTS_BLOCK_ID:
- if (ParseConstants(Stream))
+ if (ParseConstants() || ResolveGlobalAndAliasInits())
+ return true;
+ break;
+ case bitc::FUNCTION_BLOCK_ID:
+ // If this is the first function body we've seen, reverse the
+ // FunctionsWithBodies list.
+ if (!HasReversedFunctionsWithBodies) {
+ std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end());
+ HasReversedFunctionsWithBodies = true;
+ }
+
+ if (RememberAndSkipFunctionBody())
return true;
break;
}
"", TheModule);
Func->setCallingConv(Record[1]);
+ bool isProto = Record[2];
Func->setLinkage(GetDecodedLinkage(Record[3]));
Func->setAlignment((1 << Record[4]) >> 1);
if (Record[5]) {
Func->setVisibility(GetDecodedVisibility(Record[6]));
ValueList.push_back(Func);
- // TODO: remember initializer/global pair for later substitution.
+
+ // If this is a function with a body, remember the prototype we are
+ // creating now, so that we can match up the body with them later.
+ if (!isProto)
+ FunctionsWithBodies.push_back(Func);
break;
}
+ // ALIAS: [alias type, aliasee val#, linkage]
+ case bitc::MODULE_CODE_ALIAS: {
+ if (Record.size() < 3)
+ return Error("Invalid MODULE_ALIAS record");
+ const Type *Ty = getTypeByID(Record[0]);
+ if (!isa<PointerType>(Ty))
+ return Error("Function not a pointer type!");
+
+ GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]),
+ "", 0, TheModule);
+ ValueList.push_back(NewGA);
+ AliasInits.push_back(std::make_pair(NewGA, Record[1]));
+ break;
+ }
+ /// MODULE_CODE_PURGEVALS: [numvals]
+ case bitc::MODULE_CODE_PURGEVALS:
+ // Trim down the value list to the specified size.
+ if (Record.size() < 1 || Record[0] > ValueList.size())
+ return Error("Invalid MODULE_PURGEVALS record");
+ ValueList.shrinkTo(Record[0]);
+ break;
}
Record.clear();
}
}
-bool BitcodeReader::ParseBitcode(unsigned char *Buf, unsigned Length,
- const std::string &ModuleID) {
+bool BitcodeReader::ParseBitcode() {
TheModule = 0;
- if (Length & 3)
+ if (Buffer->getBufferSize() & 3)
return Error("Bitcode stream should be a multiple of 4 bytes in length");
- BitstreamReader Stream(Buf, Buf+Length);
+ unsigned char *BufPtr = (unsigned char *)Buffer->getBufferStart();
+ Stream.init(BufPtr, BufPtr+Buffer->getBufferSize());
// Sniff for the signature.
if (Stream.Read(8) != 'B' ||
// We only know the MODULE subblock ID.
if (BlockID == bitc::MODULE_BLOCK_ID) {
- if (ParseModule(Stream, ModuleID))
+ if (ParseModule(Buffer->getBufferIdentifier()))
return true;
} else if (Stream.SkipBlock()) {
return Error("Malformed block record");
return false;
}
+
+
+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;
+}