1 //===- BitcodeReader.cpp - Internal BitcodeReader implementation ----------===//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by Chris Lattner and is distributed under
6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This header defines the BitcodeReader class.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/Bitcode/ReaderWriter.h"
15 #include "BitcodeReader.h"
16 #include "llvm/Constants.h"
17 #include "llvm/DerivedTypes.h"
18 #include "llvm/Instructions.h"
19 #include "llvm/Module.h"
20 #include "llvm/ParameterAttributes.h"
21 #include "llvm/ADT/SmallString.h"
22 #include "llvm/Support/MathExtras.h"
23 #include "llvm/Support/MemoryBuffer.h"
26 BitcodeReader::~BitcodeReader() {
30 //===----------------------------------------------------------------------===//
31 // Helper functions to implement forward reference resolution, etc.
32 //===----------------------------------------------------------------------===//
34 /// ConvertToString - Convert a string from a record into an std::string, return
36 template<typename StrTy>
37 static bool ConvertToString(SmallVector<uint64_t, 64> &Record, unsigned Idx,
39 if (Idx > Record.size())
42 for (unsigned i = Idx, e = Record.size(); i != e; ++i)
43 Result += (char)Record[i];
47 static GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) {
49 default: // Map unknown/new linkages to external
50 case 0: return GlobalValue::ExternalLinkage;
51 case 1: return GlobalValue::WeakLinkage;
52 case 2: return GlobalValue::AppendingLinkage;
53 case 3: return GlobalValue::InternalLinkage;
54 case 4: return GlobalValue::LinkOnceLinkage;
55 case 5: return GlobalValue::DLLImportLinkage;
56 case 6: return GlobalValue::DLLExportLinkage;
57 case 7: return GlobalValue::ExternalWeakLinkage;
61 static GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) {
63 default: // Map unknown visibilities to default.
64 case 0: return GlobalValue::DefaultVisibility;
65 case 1: return GlobalValue::HiddenVisibility;
66 case 2: return GlobalValue::ProtectedVisibility;
70 static int GetDecodedCastOpcode(unsigned Val) {
73 case bitc::CAST_TRUNC : return Instruction::Trunc;
74 case bitc::CAST_ZEXT : return Instruction::ZExt;
75 case bitc::CAST_SEXT : return Instruction::SExt;
76 case bitc::CAST_FPTOUI : return Instruction::FPToUI;
77 case bitc::CAST_FPTOSI : return Instruction::FPToSI;
78 case bitc::CAST_UITOFP : return Instruction::UIToFP;
79 case bitc::CAST_SITOFP : return Instruction::SIToFP;
80 case bitc::CAST_FPTRUNC : return Instruction::FPTrunc;
81 case bitc::CAST_FPEXT : return Instruction::FPExt;
82 case bitc::CAST_PTRTOINT: return Instruction::PtrToInt;
83 case bitc::CAST_INTTOPTR: return Instruction::IntToPtr;
84 case bitc::CAST_BITCAST : return Instruction::BitCast;
87 static int GetDecodedBinaryOpcode(unsigned Val, const Type *Ty) {
90 case bitc::BINOP_ADD: return Instruction::Add;
91 case bitc::BINOP_SUB: return Instruction::Sub;
92 case bitc::BINOP_MUL: return Instruction::Mul;
93 case bitc::BINOP_UDIV: return Instruction::UDiv;
94 case bitc::BINOP_SDIV:
95 return Ty->isFPOrFPVector() ? Instruction::FDiv : Instruction::SDiv;
96 case bitc::BINOP_UREM: return Instruction::URem;
97 case bitc::BINOP_SREM:
98 return Ty->isFPOrFPVector() ? Instruction::FRem : Instruction::SRem;
99 case bitc::BINOP_SHL: return Instruction::Shl;
100 case bitc::BINOP_LSHR: return Instruction::LShr;
101 case bitc::BINOP_ASHR: return Instruction::AShr;
102 case bitc::BINOP_AND: return Instruction::And;
103 case bitc::BINOP_OR: return Instruction::Or;
104 case bitc::BINOP_XOR: return Instruction::Xor;
110 /// @brief A class for maintaining the slot number definition
111 /// as a placeholder for the actual definition for forward constants defs.
112 class ConstantPlaceHolder : public ConstantExpr {
113 ConstantPlaceHolder(); // DO NOT IMPLEMENT
114 void operator=(const ConstantPlaceHolder &); // DO NOT IMPLEMENT
117 ConstantPlaceHolder(const Type *Ty)
118 : ConstantExpr(Ty, Instruction::UserOp1, &Op, 1),
119 Op(UndefValue::get(Type::Int32Ty), this) {
124 Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx,
127 // Insert a bunch of null values.
129 OperandList = &Uses[0];
133 if (Value *V = Uses[Idx]) {
134 assert(Ty == V->getType() && "Type mismatch in constant table!");
135 return cast<Constant>(V);
138 // Create and return a placeholder, which will later be RAUW'd.
139 Constant *C = new ConstantPlaceHolder(Ty);
140 Uses[Idx].init(C, this);
144 Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, const Type *Ty) {
146 // Insert a bunch of null values.
148 OperandList = &Uses[0];
152 if (Value *V = Uses[Idx]) {
153 assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!");
157 // No type specified, must be invalid reference.
158 if (Ty == 0) return 0;
160 // Create and return a placeholder, which will later be RAUW'd.
161 Value *V = new Argument(Ty);
162 Uses[Idx].init(V, this);
167 const Type *BitcodeReader::getTypeByID(unsigned ID, bool isTypeTable) {
168 // If the TypeID is in range, return it.
169 if (ID < TypeList.size())
170 return TypeList[ID].get();
171 if (!isTypeTable) return 0;
173 // The type table allows forward references. Push as many Opaque types as
174 // needed to get up to ID.
175 while (TypeList.size() <= ID)
176 TypeList.push_back(OpaqueType::get());
177 return TypeList.back().get();
180 //===----------------------------------------------------------------------===//
181 // Functions for parsing blocks from the bitcode file
182 //===----------------------------------------------------------------------===//
184 bool BitcodeReader::ParseParamAttrBlock() {
185 if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))
186 return Error("Malformed block record");
188 if (!ParamAttrs.empty())
189 return Error("Multiple PARAMATTR blocks found!");
191 SmallVector<uint64_t, 64> Record;
193 ParamAttrsVector Attrs;
195 // Read all the records.
197 unsigned Code = Stream.ReadCode();
198 if (Code == bitc::END_BLOCK) {
199 if (Stream.ReadBlockEnd())
200 return Error("Error at end of PARAMATTR block");
204 if (Code == bitc::ENTER_SUBBLOCK) {
205 // No known subblocks, always skip them.
206 Stream.ReadSubBlockID();
207 if (Stream.SkipBlock())
208 return Error("Malformed block record");
212 if (Code == bitc::DEFINE_ABBREV) {
213 Stream.ReadAbbrevRecord();
219 switch (Stream.ReadRecord(Code, Record)) {
220 default: // Default behavior: ignore.
222 case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [paramidx0, attr0, ...]
223 if (Record.size() & 1)
224 return Error("Invalid ENTRY record");
226 ParamAttrsWithIndex PAWI;
227 for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
228 PAWI.index = Record[i];
229 PAWI.attrs = Record[i+1];
230 Attrs.push_back(PAWI);
232 ParamAttrs.push_back(ParamAttrsList::get(Attrs));
241 bool BitcodeReader::ParseTypeTable() {
242 if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID))
243 return Error("Malformed block record");
245 if (!TypeList.empty())
246 return Error("Multiple TYPE_BLOCKs found!");
248 SmallVector<uint64_t, 64> Record;
249 unsigned NumRecords = 0;
251 // Read all the records for this type table.
253 unsigned Code = Stream.ReadCode();
254 if (Code == bitc::END_BLOCK) {
255 if (NumRecords != TypeList.size())
256 return Error("Invalid type forward reference in TYPE_BLOCK");
257 if (Stream.ReadBlockEnd())
258 return Error("Error at end of type table block");
262 if (Code == bitc::ENTER_SUBBLOCK) {
263 // No known subblocks, always skip them.
264 Stream.ReadSubBlockID();
265 if (Stream.SkipBlock())
266 return Error("Malformed block record");
270 if (Code == bitc::DEFINE_ABBREV) {
271 Stream.ReadAbbrevRecord();
277 const Type *ResultTy = 0;
278 switch (Stream.ReadRecord(Code, Record)) {
279 default: // Default behavior: unknown type.
282 case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries]
283 // TYPE_CODE_NUMENTRY contains a count of the number of types in the
284 // type list. This allows us to reserve space.
285 if (Record.size() < 1)
286 return Error("Invalid TYPE_CODE_NUMENTRY record");
287 TypeList.reserve(Record[0]);
289 case bitc::TYPE_CODE_VOID: // VOID
290 ResultTy = Type::VoidTy;
292 case bitc::TYPE_CODE_FLOAT: // FLOAT
293 ResultTy = Type::FloatTy;
295 case bitc::TYPE_CODE_DOUBLE: // DOUBLE
296 ResultTy = Type::DoubleTy;
298 case bitc::TYPE_CODE_LABEL: // LABEL
299 ResultTy = Type::LabelTy;
301 case bitc::TYPE_CODE_OPAQUE: // OPAQUE
304 case bitc::TYPE_CODE_INTEGER: // INTEGER: [width]
305 if (Record.size() < 1)
306 return Error("Invalid Integer type record");
308 ResultTy = IntegerType::get(Record[0]);
310 case bitc::TYPE_CODE_POINTER: // POINTER: [pointee type]
311 if (Record.size() < 1)
312 return Error("Invalid POINTER type record");
313 ResultTy = PointerType::get(getTypeByID(Record[0], true));
315 case bitc::TYPE_CODE_FUNCTION: {
316 // FUNCTION: [vararg, attrid, retty, paramty x N]
317 if (Record.size() < 3)
318 return Error("Invalid FUNCTION type record");
319 std::vector<const Type*> ArgTys;
320 for (unsigned i = 3, e = Record.size(); i != e; ++i)
321 ArgTys.push_back(getTypeByID(Record[i], true));
323 ResultTy = FunctionType::get(getTypeByID(Record[2], true), ArgTys,
324 Record[0], getParamAttrs(Record[1]));
327 case bitc::TYPE_CODE_STRUCT: { // STRUCT: [ispacked, eltty x N]
328 if (Record.size() < 2)
329 return Error("Invalid STRUCT type record");
330 std::vector<const Type*> EltTys;
331 for (unsigned i = 1, e = Record.size(); i != e; ++i)
332 EltTys.push_back(getTypeByID(Record[i], true));
333 ResultTy = StructType::get(EltTys, Record[0]);
336 case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty]
337 if (Record.size() < 2)
338 return Error("Invalid ARRAY type record");
339 ResultTy = ArrayType::get(getTypeByID(Record[1], true), Record[0]);
341 case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty]
342 if (Record.size() < 2)
343 return Error("Invalid VECTOR type record");
344 ResultTy = VectorType::get(getTypeByID(Record[1], true), Record[0]);
348 if (NumRecords == TypeList.size()) {
349 // If this is a new type slot, just append it.
350 TypeList.push_back(ResultTy ? ResultTy : OpaqueType::get());
352 } else if (ResultTy == 0) {
353 // Otherwise, this was forward referenced, so an opaque type was created,
354 // but the result type is actually just an opaque. Leave the one we
355 // created previously.
358 // Otherwise, this was forward referenced, so an opaque type was created.
359 // Resolve the opaque type to the real type now.
360 assert(NumRecords < TypeList.size() && "Typelist imbalance");
361 const OpaqueType *OldTy = cast<OpaqueType>(TypeList[NumRecords++].get());
363 // Don't directly push the new type on the Tab. Instead we want to replace
364 // the opaque type we previously inserted with the new concrete value. The
365 // refinement from the abstract (opaque) type to the new type causes all
366 // uses of the abstract type to use the concrete type (NewTy). This will
367 // also cause the opaque type to be deleted.
368 const_cast<OpaqueType*>(OldTy)->refineAbstractTypeTo(ResultTy);
370 // This should have replaced the old opaque type with the new type in the
371 // value table... or with a preexisting type that was already in the
372 // system. Let's just make sure it did.
373 assert(TypeList[NumRecords-1].get() != OldTy &&
374 "refineAbstractType didn't work!");
380 bool BitcodeReader::ParseTypeSymbolTable() {
381 if (Stream.EnterSubBlock(bitc::TYPE_SYMTAB_BLOCK_ID))
382 return Error("Malformed block record");
384 SmallVector<uint64_t, 64> Record;
386 // Read all the records for this type table.
387 std::string TypeName;
389 unsigned Code = Stream.ReadCode();
390 if (Code == bitc::END_BLOCK) {
391 if (Stream.ReadBlockEnd())
392 return Error("Error at end of type symbol table block");
396 if (Code == bitc::ENTER_SUBBLOCK) {
397 // No known subblocks, always skip them.
398 Stream.ReadSubBlockID();
399 if (Stream.SkipBlock())
400 return Error("Malformed block record");
404 if (Code == bitc::DEFINE_ABBREV) {
405 Stream.ReadAbbrevRecord();
411 switch (Stream.ReadRecord(Code, Record)) {
412 default: // Default behavior: unknown type.
414 case bitc::TST_CODE_ENTRY: // TST_ENTRY: [typeid, namechar x N]
415 if (ConvertToString(Record, 1, TypeName))
416 return Error("Invalid TST_ENTRY record");
417 unsigned TypeID = Record[0];
418 if (TypeID >= TypeList.size())
419 return Error("Invalid Type ID in TST_ENTRY record");
421 TheModule->addTypeName(TypeName, TypeList[TypeID].get());
428 bool BitcodeReader::ParseValueSymbolTable() {
429 if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
430 return Error("Malformed block record");
432 SmallVector<uint64_t, 64> Record;
434 // Read all the records for this value table.
435 SmallString<128> ValueName;
437 unsigned Code = Stream.ReadCode();
438 if (Code == bitc::END_BLOCK) {
439 if (Stream.ReadBlockEnd())
440 return Error("Error at end of value symbol table block");
443 if (Code == bitc::ENTER_SUBBLOCK) {
444 // No known subblocks, always skip them.
445 Stream.ReadSubBlockID();
446 if (Stream.SkipBlock())
447 return Error("Malformed block record");
451 if (Code == bitc::DEFINE_ABBREV) {
452 Stream.ReadAbbrevRecord();
458 switch (Stream.ReadRecord(Code, Record)) {
459 default: // Default behavior: unknown type.
461 case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N]
462 if (ConvertToString(Record, 1, ValueName))
463 return Error("Invalid TST_ENTRY record");
464 unsigned ValueID = Record[0];
465 if (ValueID >= ValueList.size())
466 return Error("Invalid Value ID in VST_ENTRY record");
467 Value *V = ValueList[ValueID];
469 V->setName(&ValueName[0], ValueName.size());
473 case bitc::VST_CODE_BBENTRY: {
474 if (ConvertToString(Record, 1, ValueName))
475 return Error("Invalid VST_BBENTRY record");
476 BasicBlock *BB = getBasicBlock(Record[0]);
478 return Error("Invalid BB ID in VST_BBENTRY record");
480 BB->setName(&ValueName[0], ValueName.size());
488 /// DecodeSignRotatedValue - Decode a signed value stored with the sign bit in
489 /// the LSB for dense VBR encoding.
490 static uint64_t DecodeSignRotatedValue(uint64_t V) {
495 // There is no such thing as -0 with integers. "-0" really means MININT.
499 /// ResolveGlobalAndAliasInits - Resolve all of the initializers for global
500 /// values and aliases that we can.
501 bool BitcodeReader::ResolveGlobalAndAliasInits() {
502 std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist;
503 std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist;
505 GlobalInitWorklist.swap(GlobalInits);
506 AliasInitWorklist.swap(AliasInits);
508 while (!GlobalInitWorklist.empty()) {
509 unsigned ValID = GlobalInitWorklist.back().second;
510 if (ValID >= ValueList.size()) {
511 // Not ready to resolve this yet, it requires something later in the file.
512 GlobalInits.push_back(GlobalInitWorklist.back());
514 if (Constant *C = dyn_cast<Constant>(ValueList[ValID]))
515 GlobalInitWorklist.back().first->setInitializer(C);
517 return Error("Global variable initializer is not a constant!");
519 GlobalInitWorklist.pop_back();
522 while (!AliasInitWorklist.empty()) {
523 unsigned ValID = AliasInitWorklist.back().second;
524 if (ValID >= ValueList.size()) {
525 AliasInits.push_back(AliasInitWorklist.back());
527 if (Constant *C = dyn_cast<Constant>(ValueList[ValID]))
528 AliasInitWorklist.back().first->setAliasee(C);
530 return Error("Alias initializer is not a constant!");
532 AliasInitWorklist.pop_back();
538 bool BitcodeReader::ParseConstants() {
539 if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))
540 return Error("Malformed block record");
542 SmallVector<uint64_t, 64> Record;
544 // Read all the records for this value table.
545 const Type *CurTy = Type::Int32Ty;
546 unsigned NextCstNo = ValueList.size();
548 unsigned Code = Stream.ReadCode();
549 if (Code == bitc::END_BLOCK) {
550 if (NextCstNo != ValueList.size())
551 return Error("Invalid constant reference!");
553 if (Stream.ReadBlockEnd())
554 return Error("Error at end of constants block");
558 if (Code == bitc::ENTER_SUBBLOCK) {
559 // No known subblocks, always skip them.
560 Stream.ReadSubBlockID();
561 if (Stream.SkipBlock())
562 return Error("Malformed block record");
566 if (Code == bitc::DEFINE_ABBREV) {
567 Stream.ReadAbbrevRecord();
574 switch (Stream.ReadRecord(Code, Record)) {
575 default: // Default behavior: unknown constant
576 case bitc::CST_CODE_UNDEF: // UNDEF
577 V = UndefValue::get(CurTy);
579 case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid]
581 return Error("Malformed CST_SETTYPE record");
582 if (Record[0] >= TypeList.size())
583 return Error("Invalid Type ID in CST_SETTYPE record");
584 CurTy = TypeList[Record[0]];
585 continue; // Skip the ValueList manipulation.
586 case bitc::CST_CODE_NULL: // NULL
587 V = Constant::getNullValue(CurTy);
589 case bitc::CST_CODE_INTEGER: // INTEGER: [intval]
590 if (!isa<IntegerType>(CurTy) || Record.empty())
591 return Error("Invalid CST_INTEGER record");
592 V = ConstantInt::get(CurTy, DecodeSignRotatedValue(Record[0]));
594 case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval]
595 if (!isa<IntegerType>(CurTy) || Record.empty())
596 return Error("Invalid WIDE_INTEGER record");
598 unsigned NumWords = Record.size();
599 SmallVector<uint64_t, 8> Words;
600 Words.resize(NumWords);
601 for (unsigned i = 0; i != NumWords; ++i)
602 Words[i] = DecodeSignRotatedValue(Record[i]);
603 V = ConstantInt::get(APInt(cast<IntegerType>(CurTy)->getBitWidth(),
604 NumWords, &Words[0]));
607 case bitc::CST_CODE_FLOAT: // FLOAT: [fpval]
609 return Error("Invalid FLOAT record");
610 if (CurTy == Type::FloatTy)
611 V = ConstantFP::get(CurTy, BitsToFloat(Record[0]));
612 else if (CurTy == Type::DoubleTy)
613 V = ConstantFP::get(CurTy, BitsToDouble(Record[0]));
615 V = UndefValue::get(CurTy);
618 case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number]
620 return Error("Invalid CST_AGGREGATE record");
622 unsigned Size = Record.size();
623 std::vector<Constant*> Elts;
625 if (const StructType *STy = dyn_cast<StructType>(CurTy)) {
626 for (unsigned i = 0; i != Size; ++i)
627 Elts.push_back(ValueList.getConstantFwdRef(Record[i],
628 STy->getElementType(i)));
629 V = ConstantStruct::get(STy, Elts);
630 } else if (const ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) {
631 const Type *EltTy = ATy->getElementType();
632 for (unsigned i = 0; i != Size; ++i)
633 Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
634 V = ConstantArray::get(ATy, Elts);
635 } else if (const VectorType *VTy = dyn_cast<VectorType>(CurTy)) {
636 const Type *EltTy = VTy->getElementType();
637 for (unsigned i = 0; i != Size; ++i)
638 Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
639 V = ConstantVector::get(Elts);
641 V = UndefValue::get(CurTy);
646 case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval]
647 if (Record.size() < 3) return Error("Invalid CE_BINOP record");
648 int Opc = GetDecodedBinaryOpcode(Record[0], CurTy);
650 V = UndefValue::get(CurTy); // Unknown binop.
652 Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy);
653 Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy);
654 V = ConstantExpr::get(Opc, LHS, RHS);
658 case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval]
659 if (Record.size() < 3) return Error("Invalid CE_CAST record");
660 int Opc = GetDecodedCastOpcode(Record[0]);
662 V = UndefValue::get(CurTy); // Unknown cast.
664 const Type *OpTy = getTypeByID(Record[1]);
665 Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy);
666 V = ConstantExpr::getCast(Opc, Op, CurTy);
670 case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands]
671 if (Record.size() & 1) return Error("Invalid CE_GEP record");
672 SmallVector<Constant*, 16> Elts;
673 for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
674 const Type *ElTy = getTypeByID(Record[i]);
675 if (!ElTy) return Error("Invalid CE_GEP record");
676 Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy));
678 V = ConstantExpr::getGetElementPtr(Elts[0], &Elts[1], Elts.size()-1);
681 case bitc::CST_CODE_CE_SELECT: // CE_SELECT: [opval#, opval#, opval#]
682 if (Record.size() < 3) return Error("Invalid CE_SELECT record");
683 V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0],
685 ValueList.getConstantFwdRef(Record[1],CurTy),
686 ValueList.getConstantFwdRef(Record[2],CurTy));
688 case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval]
689 if (Record.size() < 3) return Error("Invalid CE_EXTRACTELT record");
690 const VectorType *OpTy =
691 dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
692 if (OpTy == 0) return Error("Invalid CE_EXTRACTELT record");
693 Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
694 Constant *Op1 = ValueList.getConstantFwdRef(Record[2],
695 OpTy->getElementType());
696 V = ConstantExpr::getExtractElement(Op0, Op1);
699 case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval]
700 const VectorType *OpTy = dyn_cast<VectorType>(CurTy);
701 if (Record.size() < 3 || OpTy == 0)
702 return Error("Invalid CE_INSERTELT record");
703 Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
704 Constant *Op1 = ValueList.getConstantFwdRef(Record[1],
705 OpTy->getElementType());
706 Constant *Op2 = ValueList.getConstantFwdRef(Record[2], Type::Int32Ty);
707 V = ConstantExpr::getInsertElement(Op0, Op1, Op2);
710 case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval]
711 const VectorType *OpTy = dyn_cast<VectorType>(CurTy);
712 if (Record.size() < 3 || OpTy == 0)
713 return Error("Invalid CE_INSERTELT record");
714 Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
715 Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy);
716 const Type *ShufTy=VectorType::get(Type::Int32Ty, OpTy->getNumElements());
717 Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy);
718 V = ConstantExpr::getShuffleVector(Op0, Op1, Op2);
721 case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred]
722 if (Record.size() < 4) return Error("Invalid CE_CMP record");
723 const Type *OpTy = getTypeByID(Record[0]);
724 if (OpTy == 0) return Error("Invalid CE_CMP record");
725 Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
726 Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
728 if (OpTy->isFloatingPoint())
729 V = ConstantExpr::getFCmp(Record[3], Op0, Op1);
731 V = ConstantExpr::getICmp(Record[3], Op0, Op1);
736 ValueList.AssignValue(V, NextCstNo);
741 /// RememberAndSkipFunctionBody - When we see the block for a function body,
742 /// remember where it is and then skip it. This lets us lazily deserialize the
744 bool BitcodeReader::RememberAndSkipFunctionBody() {
745 // Get the function we are talking about.
746 if (FunctionsWithBodies.empty())
747 return Error("Insufficient function protos");
749 Function *Fn = FunctionsWithBodies.back();
750 FunctionsWithBodies.pop_back();
752 // Save the current stream state.
753 uint64_t CurBit = Stream.GetCurrentBitNo();
754 DeferredFunctionInfo[Fn] = std::make_pair(CurBit, Fn->getLinkage());
756 // Set the functions linkage to GhostLinkage so we know it is lazily
758 Fn->setLinkage(GlobalValue::GhostLinkage);
760 // Skip over the function block for now.
761 if (Stream.SkipBlock())
762 return Error("Malformed block record");
766 bool BitcodeReader::ParseModule(const std::string &ModuleID) {
767 // Reject multiple MODULE_BLOCK's in a single bitstream.
769 return Error("Multiple MODULE_BLOCKs in same stream");
771 if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
772 return Error("Malformed block record");
774 // Otherwise, create the module.
775 TheModule = new Module(ModuleID);
777 SmallVector<uint64_t, 64> Record;
778 std::vector<std::string> SectionTable;
780 // Read all the records for this module.
781 while (!Stream.AtEndOfStream()) {
782 unsigned Code = Stream.ReadCode();
783 if (Code == bitc::END_BLOCK) {
784 if (Stream.ReadBlockEnd())
785 return Error("Error at end of module block");
787 // Patch the initializers for globals and aliases up.
788 ResolveGlobalAndAliasInits();
789 if (!GlobalInits.empty() || !AliasInits.empty())
790 return Error("Malformed global initializer set");
791 if (!FunctionsWithBodies.empty())
792 return Error("Too few function bodies found");
794 // Force deallocation of memory for these vectors to favor the client that
795 // want lazy deserialization.
796 std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits);
797 std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits);
798 std::vector<Function*>().swap(FunctionsWithBodies);
802 if (Code == bitc::ENTER_SUBBLOCK) {
803 switch (Stream.ReadSubBlockID()) {
804 default: // Skip unknown content.
805 if (Stream.SkipBlock())
806 return Error("Malformed block record");
808 case bitc::BLOCKINFO_BLOCK_ID:
809 if (Stream.ReadBlockInfoBlock())
810 return Error("Malformed BlockInfoBlock");
812 case bitc::PARAMATTR_BLOCK_ID:
813 if (ParseParamAttrBlock())
816 case bitc::TYPE_BLOCK_ID:
817 if (ParseTypeTable())
820 case bitc::TYPE_SYMTAB_BLOCK_ID:
821 if (ParseTypeSymbolTable())
824 case bitc::VALUE_SYMTAB_BLOCK_ID:
825 if (ParseValueSymbolTable())
828 case bitc::CONSTANTS_BLOCK_ID:
829 if (ParseConstants() || ResolveGlobalAndAliasInits())
832 case bitc::FUNCTION_BLOCK_ID:
833 // If this is the first function body we've seen, reverse the
834 // FunctionsWithBodies list.
835 if (!HasReversedFunctionsWithBodies) {
836 std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end());
837 HasReversedFunctionsWithBodies = true;
840 if (RememberAndSkipFunctionBody())
847 if (Code == bitc::DEFINE_ABBREV) {
848 Stream.ReadAbbrevRecord();
853 switch (Stream.ReadRecord(Code, Record)) {
854 default: break; // Default behavior, ignore unknown content.
855 case bitc::MODULE_CODE_VERSION: // VERSION: [version#]
856 if (Record.size() < 1)
857 return Error("Malformed MODULE_CODE_VERSION");
858 // Only version #0 is supported so far.
860 return Error("Unknown bitstream version!");
862 case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N]
864 if (ConvertToString(Record, 0, S))
865 return Error("Invalid MODULE_CODE_TRIPLE record");
866 TheModule->setTargetTriple(S);
869 case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N]
871 if (ConvertToString(Record, 0, S))
872 return Error("Invalid MODULE_CODE_DATALAYOUT record");
873 TheModule->setDataLayout(S);
876 case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N]
878 if (ConvertToString(Record, 0, S))
879 return Error("Invalid MODULE_CODE_ASM record");
880 TheModule->setModuleInlineAsm(S);
883 case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N]
885 if (ConvertToString(Record, 0, S))
886 return Error("Invalid MODULE_CODE_DEPLIB record");
887 TheModule->addLibrary(S);
890 case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N]
892 if (ConvertToString(Record, 0, S))
893 return Error("Invalid MODULE_CODE_SECTIONNAME record");
894 SectionTable.push_back(S);
897 // GLOBALVAR: [type, isconst, initid,
898 // linkage, alignment, section, visibility, threadlocal]
899 case bitc::MODULE_CODE_GLOBALVAR: {
900 if (Record.size() < 6)
901 return Error("Invalid MODULE_CODE_GLOBALVAR record");
902 const Type *Ty = getTypeByID(Record[0]);
903 if (!isa<PointerType>(Ty))
904 return Error("Global not a pointer type!");
905 Ty = cast<PointerType>(Ty)->getElementType();
907 bool isConstant = Record[1];
908 GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]);
909 unsigned Alignment = (1 << Record[4]) >> 1;
912 if (Record[5]-1 >= SectionTable.size())
913 return Error("Invalid section ID");
914 Section = SectionTable[Record[5]-1];
916 GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility;
917 if (Record.size() >= 6) Visibility = GetDecodedVisibility(Record[6]);
918 bool isThreadLocal = false;
919 if (Record.size() >= 7) isThreadLocal = Record[7];
921 GlobalVariable *NewGV =
922 new GlobalVariable(Ty, isConstant, Linkage, 0, "", TheModule);
923 NewGV->setAlignment(Alignment);
924 if (!Section.empty())
925 NewGV->setSection(Section);
926 NewGV->setVisibility(Visibility);
927 NewGV->setThreadLocal(isThreadLocal);
929 ValueList.push_back(NewGV);
931 // Remember which value to use for the global initializer.
932 if (unsigned InitID = Record[2])
933 GlobalInits.push_back(std::make_pair(NewGV, InitID-1));
936 // FUNCTION: [type, callingconv, isproto, linkage, alignment, section,
938 case bitc::MODULE_CODE_FUNCTION: {
939 if (Record.size() < 7)
940 return Error("Invalid MODULE_CODE_FUNCTION record");
941 const Type *Ty = getTypeByID(Record[0]);
942 if (!isa<PointerType>(Ty))
943 return Error("Function not a pointer type!");
944 const FunctionType *FTy =
945 dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType());
947 return Error("Function not a pointer to function type!");
949 Function *Func = new Function(FTy, GlobalValue::ExternalLinkage,
952 Func->setCallingConv(Record[1]);
953 bool isProto = Record[2];
954 Func->setLinkage(GetDecodedLinkage(Record[3]));
955 Func->setAlignment((1 << Record[4]) >> 1);
957 if (Record[5]-1 >= SectionTable.size())
958 return Error("Invalid section ID");
959 Func->setSection(SectionTable[Record[5]-1]);
961 Func->setVisibility(GetDecodedVisibility(Record[6]));
963 ValueList.push_back(Func);
965 // If this is a function with a body, remember the prototype we are
966 // creating now, so that we can match up the body with them later.
968 FunctionsWithBodies.push_back(Func);
971 // ALIAS: [alias type, aliasee val#, linkage]
972 case bitc::MODULE_CODE_ALIAS: {
973 if (Record.size() < 3)
974 return Error("Invalid MODULE_ALIAS record");
975 const Type *Ty = getTypeByID(Record[0]);
976 if (!isa<PointerType>(Ty))
977 return Error("Function not a pointer type!");
979 GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]),
981 ValueList.push_back(NewGA);
982 AliasInits.push_back(std::make_pair(NewGA, Record[1]));
985 /// MODULE_CODE_PURGEVALS: [numvals]
986 case bitc::MODULE_CODE_PURGEVALS:
987 // Trim down the value list to the specified size.
988 if (Record.size() < 1 || Record[0] > ValueList.size())
989 return Error("Invalid MODULE_PURGEVALS record");
990 ValueList.shrinkTo(Record[0]);
996 return Error("Premature end of bitstream");
1000 bool BitcodeReader::ParseBitcode() {
1003 if (Buffer->getBufferSize() & 3)
1004 return Error("Bitcode stream should be a multiple of 4 bytes in length");
1006 unsigned char *BufPtr = (unsigned char *)Buffer->getBufferStart();
1007 Stream.init(BufPtr, BufPtr+Buffer->getBufferSize());
1009 // Sniff for the signature.
1010 if (Stream.Read(8) != 'B' ||
1011 Stream.Read(8) != 'C' ||
1012 Stream.Read(4) != 0x0 ||
1013 Stream.Read(4) != 0xC ||
1014 Stream.Read(4) != 0xE ||
1015 Stream.Read(4) != 0xD)
1016 return Error("Invalid bitcode signature");
1018 // We expect a number of well-defined blocks, though we don't necessarily
1019 // need to understand them all.
1020 while (!Stream.AtEndOfStream()) {
1021 unsigned Code = Stream.ReadCode();
1023 if (Code != bitc::ENTER_SUBBLOCK)
1024 return Error("Invalid record at top-level");
1026 unsigned BlockID = Stream.ReadSubBlockID();
1028 // We only know the MODULE subblock ID.
1030 case bitc::BLOCKINFO_BLOCK_ID:
1031 if (Stream.ReadBlockInfoBlock())
1032 return Error("Malformed BlockInfoBlock");
1034 case bitc::MODULE_BLOCK_ID:
1035 if (ParseModule(Buffer->getBufferIdentifier()))
1039 if (Stream.SkipBlock())
1040 return Error("Malformed block record");
1049 bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo) {
1050 // If it already is material, ignore the request.
1051 if (!F->hasNotBeenReadFromBytecode()) return false;
1053 DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator DFII =
1054 DeferredFunctionInfo.find(F);
1055 assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!");
1057 // Move the bit stream to the saved position of the deferred function body and
1058 // restore the real linkage type for the function.
1059 Stream.JumpToBit(DFII->second.first);
1060 F->setLinkage((GlobalValue::LinkageTypes)DFII->second.second);
1061 DeferredFunctionInfo.erase(DFII);
1063 if (ParseFunctionBody(F)) {
1064 if (ErrInfo) *ErrInfo = ErrorString;
1071 Module *BitcodeReader::materializeModule(std::string *ErrInfo) {
1072 DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator I =
1073 DeferredFunctionInfo.begin();
1074 while (!DeferredFunctionInfo.empty()) {
1075 Function *F = (*I++).first;
1076 assert(F->hasNotBeenReadFromBytecode() &&
1077 "Deserialized function found in map!");
1078 if (materializeFunction(F, ErrInfo))
1085 /// ParseFunctionBody - Lazily parse the specified function body block.
1086 bool BitcodeReader::ParseFunctionBody(Function *F) {
1087 if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))
1088 return Error("Malformed block record");
1090 unsigned ModuleValueListSize = ValueList.size();
1092 // Add all the function arguments to the value table.
1093 for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I)
1094 ValueList.push_back(I);
1096 unsigned NextValueNo = ValueList.size();
1097 BasicBlock *CurBB = 0;
1098 unsigned CurBBNo = 0;
1100 // Read all the records.
1101 SmallVector<uint64_t, 64> Record;
1103 unsigned Code = Stream.ReadCode();
1104 if (Code == bitc::END_BLOCK) {
1105 if (Stream.ReadBlockEnd())
1106 return Error("Error at end of function block");
1110 if (Code == bitc::ENTER_SUBBLOCK) {
1111 switch (Stream.ReadSubBlockID()) {
1112 default: // Skip unknown content.
1113 if (Stream.SkipBlock())
1114 return Error("Malformed block record");
1116 case bitc::CONSTANTS_BLOCK_ID:
1117 if (ParseConstants()) return true;
1118 NextValueNo = ValueList.size();
1120 case bitc::VALUE_SYMTAB_BLOCK_ID:
1121 if (ParseValueSymbolTable()) return true;
1127 if (Code == bitc::DEFINE_ABBREV) {
1128 Stream.ReadAbbrevRecord();
1135 switch (Stream.ReadRecord(Code, Record)) {
1136 default: // Default behavior: reject
1137 return Error("Unknown instruction");
1138 case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks]
1139 if (Record.size() < 1 || Record[0] == 0)
1140 return Error("Invalid DECLAREBLOCKS record");
1141 // Create all the basic blocks for the function.
1142 FunctionBBs.resize(Record[0]);
1143 for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i)
1144 FunctionBBs[i] = new BasicBlock("", F);
1145 CurBB = FunctionBBs[0];
1148 case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opcode, ty, opval, opval]
1149 if (Record.size() < 4) return Error("Invalid BINOP record");
1150 const Type *Ty = getTypeByID(Record[1]);
1151 int Opc = GetDecodedBinaryOpcode(Record[0], Ty);
1152 Value *LHS = getFnValueByID(Record[2], Ty);
1153 Value *RHS = getFnValueByID(Record[3], Ty);
1154 if (Opc == -1 || Ty == 0 || LHS == 0 || RHS == 0)
1155 return Error("Invalid BINOP record");
1156 I = BinaryOperator::create((Instruction::BinaryOps)Opc, LHS, RHS);
1159 case bitc::FUNC_CODE_INST_CAST: { // CAST: [opcode, ty, opty, opval]
1160 if (Record.size() < 4) return Error("Invalid CAST record");
1161 int Opc = GetDecodedCastOpcode(Record[0]);
1162 const Type *ResTy = getTypeByID(Record[1]);
1163 const Type *OpTy = getTypeByID(Record[2]);
1164 Value *Op = getFnValueByID(Record[3], OpTy);
1165 if (Opc == -1 || ResTy == 0 || OpTy == 0 || Op == 0)
1166 return Error("Invalid CAST record");
1167 I = CastInst::create((Instruction::CastOps)Opc, Op, ResTy);
1170 case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands]
1171 if (Record.size() < 2 || (Record.size() & 1))
1172 return Error("Invalid GEP record");
1173 const Type *OpTy = getTypeByID(Record[0]);
1174 Value *Op = getFnValueByID(Record[1], OpTy);
1175 if (OpTy == 0 || Op == 0)
1176 return Error("Invalid GEP record");
1178 SmallVector<Value*, 16> GEPIdx;
1179 for (unsigned i = 1, e = Record.size()/2; i != e; ++i) {
1180 const Type *IdxTy = getTypeByID(Record[i*2]);
1181 Value *Idx = getFnValueByID(Record[i*2+1], IdxTy);
1182 if (IdxTy == 0 || Idx == 0)
1183 return Error("Invalid GEP record");
1184 GEPIdx.push_back(Idx);
1187 I = new GetElementPtrInst(Op, &GEPIdx[0], GEPIdx.size());
1191 case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [ty, opval, opval, opval]
1192 if (Record.size() < 4) return Error("Invalid SELECT record");
1193 const Type *Ty = getTypeByID(Record[0]);
1194 Value *Cond = getFnValueByID(Record[1], Type::Int1Ty);
1195 Value *LHS = getFnValueByID(Record[2], Ty);
1196 Value *RHS = getFnValueByID(Record[3], Ty);
1197 if (Ty == 0 || Cond == 0 || LHS == 0 || RHS == 0)
1198 return Error("Invalid SELECT record");
1199 I = new SelectInst(Cond, LHS, RHS);
1203 case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval]
1204 if (Record.size() < 3) return Error("Invalid EXTRACTELT record");
1205 const Type *OpTy = getTypeByID(Record[0]);
1206 Value *Vec = getFnValueByID(Record[1], OpTy);
1207 Value *Idx = getFnValueByID(Record[2], Type::Int32Ty);
1208 if (OpTy == 0 || Vec == 0 || Idx == 0)
1209 return Error("Invalid EXTRACTELT record");
1210 I = new ExtractElementInst(Vec, Idx);
1214 case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval]
1215 if (Record.size() < 4) return Error("Invalid INSERTELT record");
1216 const VectorType *OpTy =
1217 dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
1218 if (OpTy == 0) return Error("Invalid INSERTELT record");
1219 Value *Vec = getFnValueByID(Record[1], OpTy);
1220 Value *Elt = getFnValueByID(Record[2], OpTy->getElementType());
1221 Value *Idx = getFnValueByID(Record[3], Type::Int32Ty);
1222 if (Vec == 0 || Elt == 0 || Idx == 0)
1223 return Error("Invalid INSERTELT record");
1224 I = new InsertElementInst(Vec, Elt, Idx);
1228 case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [ty,opval,opval,opval]
1229 if (Record.size() < 4) return Error("Invalid SHUFFLEVEC record");
1230 const VectorType *OpTy =
1231 dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
1232 if (OpTy == 0) return Error("Invalid SHUFFLEVEC record");
1233 Value *Vec1 = getFnValueByID(Record[1], OpTy);
1234 Value *Vec2 = getFnValueByID(Record[2], OpTy);
1235 Value *Mask = getFnValueByID(Record[3],
1236 VectorType::get(Type::Int32Ty,
1237 OpTy->getNumElements()));
1238 if (Vec1 == 0 || Vec2 == 0 || Mask == 0)
1239 return Error("Invalid SHUFFLEVEC record");
1240 I = new ShuffleVectorInst(Vec1, Vec2, Mask);
1244 case bitc::FUNC_CODE_INST_CMP: { // CMP: [opty, opval, opval, pred]
1245 if (Record.size() < 4) return Error("Invalid CMP record");
1246 const Type *OpTy = getTypeByID(Record[0]);
1247 Value *LHS = getFnValueByID(Record[1], OpTy);
1248 Value *RHS = getFnValueByID(Record[2], OpTy);
1249 if (OpTy == 0 || LHS == 0 || RHS == 0)
1250 return Error("Invalid CMP record");
1251 if (OpTy->isFPOrFPVector())
1252 I = new FCmpInst((FCmpInst::Predicate)Record[3], LHS, RHS);
1254 I = new ICmpInst((ICmpInst::Predicate)Record[3], LHS, RHS);
1258 case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>]
1259 if (Record.size() == 0) {
1260 I = new ReturnInst();
1263 if (Record.size() == 2) {
1264 const Type *OpTy = getTypeByID(Record[0]);
1265 Value *Op = getFnValueByID(Record[1], OpTy);
1267 return Error("Invalid RET record");
1268 I = new ReturnInst(Op);
1271 return Error("Invalid RET record");
1272 case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#]
1273 if (Record.size() != 1 && Record.size() != 3)
1274 return Error("Invalid BR record");
1275 BasicBlock *TrueDest = getBasicBlock(Record[0]);
1277 return Error("Invalid BR record");
1279 if (Record.size() == 1)
1280 I = new BranchInst(TrueDest);
1282 BasicBlock *FalseDest = getBasicBlock(Record[1]);
1283 Value *Cond = getFnValueByID(Record[2], Type::Int1Ty);
1284 if (FalseDest == 0 || Cond == 0)
1285 return Error("Invalid BR record");
1286 I = new BranchInst(TrueDest, FalseDest, Cond);
1290 case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, opval, n, n x ops]
1291 if (Record.size() < 3 || (Record.size() & 1) == 0)
1292 return Error("Invalid SWITCH record");
1293 const Type *OpTy = getTypeByID(Record[0]);
1294 Value *Cond = getFnValueByID(Record[1], OpTy);
1295 BasicBlock *Default = getBasicBlock(Record[2]);
1296 if (OpTy == 0 || Cond == 0 || Default == 0)
1297 return Error("Invalid SWITCH record");
1298 unsigned NumCases = (Record.size()-3)/2;
1299 SwitchInst *SI = new SwitchInst(Cond, Default, NumCases);
1300 for (unsigned i = 0, e = NumCases; i != e; ++i) {
1301 ConstantInt *CaseVal =
1302 dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy));
1303 BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]);
1304 if (CaseVal == 0 || DestBB == 0) {
1306 return Error("Invalid SWITCH record!");
1308 SI->addCase(CaseVal, DestBB);
1314 case bitc::FUNC_CODE_INST_INVOKE: { // INVOKE: [cc,fnty, op0,op1,op2, ...]
1315 if (Record.size() < 5)
1316 return Error("Invalid INVOKE record");
1317 unsigned CCInfo = Record[0];
1318 const PointerType *CalleeTy =
1319 dyn_cast_or_null<PointerType>(getTypeByID(Record[1]));
1320 Value *Callee = getFnValueByID(Record[2], CalleeTy);
1321 BasicBlock *NormalBB = getBasicBlock(Record[3]);
1322 BasicBlock *UnwindBB = getBasicBlock(Record[4]);
1323 if (CalleeTy == 0 || Callee == 0 || NormalBB == 0 || UnwindBB == 0)
1324 return Error("Invalid INVOKE record");
1326 const FunctionType *FTy =
1327 dyn_cast<FunctionType>(CalleeTy->getElementType());
1329 // Check that the right number of fixed parameters are here.
1330 if (FTy == 0 || Record.size() < 5+FTy->getNumParams())
1331 return Error("Invalid INVOKE record");
1333 SmallVector<Value*, 16> Ops;
1334 for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
1335 Ops.push_back(getFnValueByID(Record[5+i], FTy->getParamType(i)));
1336 if (Ops.back() == 0)
1337 return Error("Invalid INVOKE record");
1340 unsigned FirstVarargParam = 5+FTy->getNumParams();
1341 if (FTy->isVarArg()) {
1342 // Read type/value pairs for varargs params.
1343 if ((Record.size()-FirstVarargParam) & 1)
1344 return Error("Invalid INVOKE record");
1346 for (unsigned i = FirstVarargParam, e = Record.size(); i != e; i += 2) {
1347 const Type *ArgTy = getTypeByID(Record[i]);
1348 Ops.push_back(getFnValueByID(Record[i+1], ArgTy));
1349 if (Ops.back() == 0 || ArgTy == 0)
1350 return Error("Invalid INVOKE record");
1353 if (Record.size() != FirstVarargParam)
1354 return Error("Invalid INVOKE record");
1357 I = new InvokeInst(Callee, NormalBB, UnwindBB, &Ops[0], Ops.size());
1358 cast<InvokeInst>(I)->setCallingConv(CCInfo);
1361 case bitc::FUNC_CODE_INST_UNWIND: // UNWIND
1362 I = new UnwindInst();
1364 case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE
1365 I = new UnreachableInst();
1367 case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, #ops, val0,bb0, ...]
1368 if (Record.size() < 1 || ((Record.size()-1)&1))
1369 return Error("Invalid PHI record");
1370 const Type *Ty = getTypeByID(Record[0]);
1371 if (!Ty) return Error("Invalid PHI record");
1373 PHINode *PN = new PHINode(Ty);
1374 PN->reserveOperandSpace(Record.size()-1);
1376 for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) {
1377 Value *V = getFnValueByID(Record[1+i], Ty);
1378 BasicBlock *BB = getBasicBlock(Record[2+i]);
1379 if (!V || !BB) return Error("Invalid PHI record");
1380 PN->addIncoming(V, BB);
1386 case bitc::FUNC_CODE_INST_MALLOC: { // MALLOC: [instty, op, align]
1387 if (Record.size() < 3)
1388 return Error("Invalid MALLOC record");
1389 const PointerType *Ty =
1390 dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
1391 Value *Size = getFnValueByID(Record[1], Type::Int32Ty);
1392 unsigned Align = Record[2];
1393 if (!Ty || !Size) return Error("Invalid MALLOC record");
1394 I = new MallocInst(Ty->getElementType(), Size, (1 << Align) >> 1);
1397 case bitc::FUNC_CODE_INST_FREE: { // FREE: [opty, op]
1398 if (Record.size() < 2)
1399 return Error("Invalid FREE record");
1400 const Type *OpTy = getTypeByID(Record[0]);
1401 Value *Op = getFnValueByID(Record[1], OpTy);
1403 return Error("Invalid FREE record");
1404 I = new FreeInst(Op);
1407 case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, op, align]
1408 if (Record.size() < 3)
1409 return Error("Invalid ALLOCA record");
1410 const PointerType *Ty =
1411 dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
1412 Value *Size = getFnValueByID(Record[1], Type::Int32Ty);
1413 unsigned Align = Record[2];
1414 if (!Ty || !Size) return Error("Invalid ALLOCA record");
1415 I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1);
1418 case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol]
1419 if (Record.size() < 4)
1420 return Error("Invalid LOAD record");
1421 const Type *OpTy = getTypeByID(Record[0]);
1422 Value *Op = getFnValueByID(Record[1], OpTy);
1424 return Error("Invalid LOAD record");
1425 I = new LoadInst(Op, "", Record[3], (1 << Record[2]) >> 1);
1428 case bitc::FUNC_CODE_INST_STORE: { // STORE:[ptrty,val,ptr, align, vol]
1429 if (Record.size() < 5)
1430 return Error("Invalid LOAD record");
1431 const PointerType *OpTy =
1432 dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
1433 Value *Op = getFnValueByID(Record[1], OpTy ? OpTy->getElementType() : 0);
1434 Value *Ptr = getFnValueByID(Record[2], OpTy);
1435 if (!OpTy || !Op || !Ptr)
1436 return Error("Invalid STORE record");
1437 I = new StoreInst(Op, Ptr, Record[4], (1 << Record[3]) >> 1);
1440 case bitc::FUNC_CODE_INST_CALL: { // CALL: [cc, fnty, fnid, arg0, arg1...]
1441 if (Record.size() < 3)
1442 return Error("Invalid CALL record");
1443 unsigned CCInfo = Record[0];
1444 const PointerType *OpTy =
1445 dyn_cast_or_null<PointerType>(getTypeByID(Record[1]));
1446 const FunctionType *FTy = 0;
1447 if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType());
1448 Value *Callee = getFnValueByID(Record[2], OpTy);
1449 if (!FTy || !Callee || Record.size() < FTy->getNumParams()+3)
1450 return Error("Invalid CALL record");
1452 SmallVector<Value*, 16> Args;
1453 // Read the fixed params.
1454 for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
1455 Args.push_back(getFnValueByID(Record[i+3], FTy->getParamType(i)));
1456 if (Args.back() == 0) return Error("Invalid CALL record");
1460 // Read type/value pairs for varargs params.
1461 unsigned NextArg = FTy->getNumParams()+3;
1462 if (!FTy->isVarArg()) {
1463 if (NextArg != Record.size())
1464 return Error("Invalid CALL record");
1466 if ((Record.size()-NextArg) & 1)
1467 return Error("Invalid CALL record");
1468 for (unsigned e = Record.size(); NextArg != e; NextArg += 2) {
1469 Args.push_back(getFnValueByID(Record[NextArg+1],
1470 getTypeByID(Record[NextArg])));
1471 if (Args.back() == 0) return Error("Invalid CALL record");
1475 I = new CallInst(Callee, &Args[0], Args.size());
1476 cast<CallInst>(I)->setCallingConv(CCInfo>>1);
1477 cast<CallInst>(I)->setTailCall(CCInfo & 1);
1480 case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty]
1481 if (Record.size() < 3)
1482 return Error("Invalid VAARG record");
1483 const Type *OpTy = getTypeByID(Record[0]);
1484 Value *Op = getFnValueByID(Record[1], OpTy);
1485 const Type *ResTy = getTypeByID(Record[2]);
1486 if (!OpTy || !Op || !ResTy)
1487 return Error("Invalid VAARG record");
1488 I = new VAArgInst(Op, ResTy);
1493 // Add instruction to end of current BB. If there is no current BB, reject
1497 return Error("Invalid instruction with no BB");
1499 CurBB->getInstList().push_back(I);
1501 // If this was a terminator instruction, move to the next block.
1502 if (isa<TerminatorInst>(I)) {
1504 CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0;
1507 // Non-void values get registered in the value table for future use.
1508 if (I && I->getType() != Type::VoidTy)
1509 ValueList.AssignValue(I, NextValueNo++);
1512 // Check the function list for unresolved values.
1513 if (Argument *A = dyn_cast<Argument>(ValueList.back())) {
1514 if (A->getParent() == 0) {
1515 // We found at least one unresolved value. Nuke them all to avoid leaks.
1516 for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){
1517 if ((A = dyn_cast<Argument>(ValueList.back())) && A->getParent() == 0) {
1518 A->replaceAllUsesWith(UndefValue::get(A->getType()));
1522 return Error("Never resolved value found in function!");
1526 // Trim the value list down to the size it was before we parsed this function.
1527 ValueList.shrinkTo(ModuleValueListSize);
1528 std::vector<BasicBlock*>().swap(FunctionBBs);
1534 //===----------------------------------------------------------------------===//
1535 // External interface
1536 //===----------------------------------------------------------------------===//
1538 /// getBitcodeModuleProvider - lazy function-at-a-time loading from a file.
1540 ModuleProvider *llvm::getBitcodeModuleProvider(MemoryBuffer *Buffer,
1541 std::string *ErrMsg) {
1542 BitcodeReader *R = new BitcodeReader(Buffer);
1543 if (R->ParseBitcode()) {
1545 *ErrMsg = R->getErrorString();
1547 // Don't let the BitcodeReader dtor delete 'Buffer'.
1548 R->releaseMemoryBuffer();
1555 /// ParseBitcodeFile - Read the specified bitcode file, returning the module.
1556 /// If an error occurs, return null and fill in *ErrMsg if non-null.
1557 Module *llvm::ParseBitcodeFile(MemoryBuffer *Buffer, std::string *ErrMsg){
1559 R = static_cast<BitcodeReader*>(getBitcodeModuleProvider(Buffer, ErrMsg));
1562 // Read the whole module, get a pointer to it, tell ModuleProvider not to
1563 // delete it when its dtor is run.
1564 Module *M = R->releaseModule(ErrMsg);
1566 // Don't let the BitcodeReader dtor delete 'Buffer'.
1567 R->releaseMemoryBuffer();