blob: 93542f3dad0540a7d29e35247d75184b11d0f6c9 [file] [log] [blame]
Chris Lattnercaee0dc2007-04-22 06:23:29 +00001//===- BitcodeReader.cpp - Internal BitcodeReader implementation ----------===//
2//
3// The LLVM Compiler Infrastructure
4//
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.
7//
8//===----------------------------------------------------------------------===//
9//
10// This header defines the BitcodeReader class.
11//
12//===----------------------------------------------------------------------===//
13
Chris Lattnerc453f762007-04-29 07:54:31 +000014#include "llvm/Bitcode/ReaderWriter.h"
Chris Lattnercaee0dc2007-04-22 06:23:29 +000015#include "BitcodeReader.h"
Chris Lattnere16504e2007-04-24 03:30:34 +000016#include "llvm/Constants.h"
Chris Lattnercaee0dc2007-04-22 06:23:29 +000017#include "llvm/DerivedTypes.h"
Chris Lattner2bce93a2007-05-06 01:58:20 +000018#include "llvm/InlineAsm.h"
Chris Lattnera7c49aa2007-05-01 07:01:57 +000019#include "llvm/Instructions.h"
Chris Lattnercaee0dc2007-04-22 06:23:29 +000020#include "llvm/Module.h"
Chris Lattner48c85b82007-05-04 03:30:17 +000021#include "llvm/ParameterAttributes.h"
Chandler Carruth69940402007-08-04 01:51:18 +000022#include "llvm/AutoUpgrade.h"
Chris Lattner0b2482a2007-04-23 21:26:05 +000023#include "llvm/ADT/SmallString.h"
Chris Lattner0eef0802007-04-24 04:04:35 +000024#include "llvm/Support/MathExtras.h"
Chris Lattnerc453f762007-04-29 07:54:31 +000025#include "llvm/Support/MemoryBuffer.h"
Chris Lattnercaee0dc2007-04-22 06:23:29 +000026using namespace llvm;
27
Chris Lattnerb348bb82007-05-18 04:02:46 +000028void BitcodeReader::FreeState() {
Chris Lattnerc453f762007-04-29 07:54:31 +000029 delete Buffer;
Chris Lattnerb348bb82007-05-18 04:02:46 +000030 Buffer = 0;
31 std::vector<PATypeHolder>().swap(TypeList);
32 ValueList.clear();
33 std::vector<const ParamAttrsList*>().swap(ParamAttrs);
34 std::vector<BasicBlock*>().swap(FunctionBBs);
35 std::vector<Function*>().swap(FunctionsWithBodies);
36 DeferredFunctionInfo.clear();
Chris Lattnerc453f762007-04-29 07:54:31 +000037}
38
Chris Lattner48c85b82007-05-04 03:30:17 +000039//===----------------------------------------------------------------------===//
40// Helper functions to implement forward reference resolution, etc.
41//===----------------------------------------------------------------------===//
Chris Lattnerc453f762007-04-29 07:54:31 +000042
Chris Lattnercaee0dc2007-04-22 06:23:29 +000043/// ConvertToString - Convert a string from a record into an std::string, return
44/// true on failure.
Chris Lattner0b2482a2007-04-23 21:26:05 +000045template<typename StrTy>
Chris Lattnercaee0dc2007-04-22 06:23:29 +000046static bool ConvertToString(SmallVector<uint64_t, 64> &Record, unsigned Idx,
Chris Lattner0b2482a2007-04-23 21:26:05 +000047 StrTy &Result) {
Chris Lattner15e6d172007-05-04 19:11:41 +000048 if (Idx > Record.size())
Chris Lattnercaee0dc2007-04-22 06:23:29 +000049 return true;
50
Chris Lattner15e6d172007-05-04 19:11:41 +000051 for (unsigned i = Idx, e = Record.size(); i != e; ++i)
52 Result += (char)Record[i];
Chris Lattnercaee0dc2007-04-22 06:23:29 +000053 return false;
54}
55
56static GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) {
57 switch (Val) {
58 default: // Map unknown/new linkages to external
59 case 0: return GlobalValue::ExternalLinkage;
60 case 1: return GlobalValue::WeakLinkage;
61 case 2: return GlobalValue::AppendingLinkage;
62 case 3: return GlobalValue::InternalLinkage;
63 case 4: return GlobalValue::LinkOnceLinkage;
64 case 5: return GlobalValue::DLLImportLinkage;
65 case 6: return GlobalValue::DLLExportLinkage;
66 case 7: return GlobalValue::ExternalWeakLinkage;
67 }
68}
69
70static GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) {
71 switch (Val) {
72 default: // Map unknown visibilities to default.
73 case 0: return GlobalValue::DefaultVisibility;
74 case 1: return GlobalValue::HiddenVisibility;
Anton Korobeynikov9cd3ccf2007-04-29 20:56:48 +000075 case 2: return GlobalValue::ProtectedVisibility;
Chris Lattnercaee0dc2007-04-22 06:23:29 +000076 }
77}
78
Chris Lattnerf581c3b2007-04-24 07:07:11 +000079static int GetDecodedCastOpcode(unsigned Val) {
80 switch (Val) {
81 default: return -1;
82 case bitc::CAST_TRUNC : return Instruction::Trunc;
83 case bitc::CAST_ZEXT : return Instruction::ZExt;
84 case bitc::CAST_SEXT : return Instruction::SExt;
85 case bitc::CAST_FPTOUI : return Instruction::FPToUI;
86 case bitc::CAST_FPTOSI : return Instruction::FPToSI;
87 case bitc::CAST_UITOFP : return Instruction::UIToFP;
88 case bitc::CAST_SITOFP : return Instruction::SIToFP;
89 case bitc::CAST_FPTRUNC : return Instruction::FPTrunc;
90 case bitc::CAST_FPEXT : return Instruction::FPExt;
91 case bitc::CAST_PTRTOINT: return Instruction::PtrToInt;
92 case bitc::CAST_INTTOPTR: return Instruction::IntToPtr;
93 case bitc::CAST_BITCAST : return Instruction::BitCast;
94 }
95}
96static int GetDecodedBinaryOpcode(unsigned Val, const Type *Ty) {
97 switch (Val) {
98 default: return -1;
99 case bitc::BINOP_ADD: return Instruction::Add;
100 case bitc::BINOP_SUB: return Instruction::Sub;
101 case bitc::BINOP_MUL: return Instruction::Mul;
102 case bitc::BINOP_UDIV: return Instruction::UDiv;
103 case bitc::BINOP_SDIV:
104 return Ty->isFPOrFPVector() ? Instruction::FDiv : Instruction::SDiv;
105 case bitc::BINOP_UREM: return Instruction::URem;
106 case bitc::BINOP_SREM:
107 return Ty->isFPOrFPVector() ? Instruction::FRem : Instruction::SRem;
108 case bitc::BINOP_SHL: return Instruction::Shl;
109 case bitc::BINOP_LSHR: return Instruction::LShr;
110 case bitc::BINOP_ASHR: return Instruction::AShr;
111 case bitc::BINOP_AND: return Instruction::And;
112 case bitc::BINOP_OR: return Instruction::Or;
113 case bitc::BINOP_XOR: return Instruction::Xor;
114 }
115}
116
117
Chris Lattner522b7b12007-04-24 05:48:56 +0000118namespace {
119 /// @brief A class for maintaining the slot number definition
120 /// as a placeholder for the actual definition for forward constants defs.
121 class ConstantPlaceHolder : public ConstantExpr {
122 ConstantPlaceHolder(); // DO NOT IMPLEMENT
123 void operator=(const ConstantPlaceHolder &); // DO NOT IMPLEMENT
Chris Lattnerf581c3b2007-04-24 07:07:11 +0000124 public:
125 Use Op;
Dan Gohmanadf3eab2007-11-19 15:30:20 +0000126 explicit ConstantPlaceHolder(const Type *Ty)
Chris Lattnerf581c3b2007-04-24 07:07:11 +0000127 : ConstantExpr(Ty, Instruction::UserOp1, &Op, 1),
128 Op(UndefValue::get(Type::Int32Ty), this) {
Chris Lattner522b7b12007-04-24 05:48:56 +0000129 }
130 };
131}
132
133Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx,
134 const Type *Ty) {
135 if (Idx >= size()) {
136 // Insert a bunch of null values.
137 Uses.resize(Idx+1);
138 OperandList = &Uses[0];
139 NumOperands = Idx+1;
140 }
141
Chris Lattnera7c49aa2007-05-01 07:01:57 +0000142 if (Value *V = Uses[Idx]) {
143 assert(Ty == V->getType() && "Type mismatch in constant table!");
144 return cast<Constant>(V);
Chris Lattnerf581c3b2007-04-24 07:07:11 +0000145 }
Chris Lattner522b7b12007-04-24 05:48:56 +0000146
147 // Create and return a placeholder, which will later be RAUW'd.
148 Constant *C = new ConstantPlaceHolder(Ty);
149 Uses[Idx].init(C, this);
150 return C;
151}
152
Chris Lattnera7c49aa2007-05-01 07:01:57 +0000153Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, const Type *Ty) {
154 if (Idx >= size()) {
155 // Insert a bunch of null values.
156 Uses.resize(Idx+1);
157 OperandList = &Uses[0];
158 NumOperands = Idx+1;
159 }
160
161 if (Value *V = Uses[Idx]) {
162 assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!");
163 return V;
164 }
165
Chris Lattner01ff65f2007-05-02 05:16:49 +0000166 // No type specified, must be invalid reference.
167 if (Ty == 0) return 0;
168
Chris Lattnera7c49aa2007-05-01 07:01:57 +0000169 // Create and return a placeholder, which will later be RAUW'd.
170 Value *V = new Argument(Ty);
171 Uses[Idx].init(V, this);
172 return V;
173}
174
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000175
176const Type *BitcodeReader::getTypeByID(unsigned ID, bool isTypeTable) {
177 // If the TypeID is in range, return it.
178 if (ID < TypeList.size())
179 return TypeList[ID].get();
180 if (!isTypeTable) return 0;
181
182 // The type table allows forward references. Push as many Opaque types as
183 // needed to get up to ID.
184 while (TypeList.size() <= ID)
185 TypeList.push_back(OpaqueType::get());
186 return TypeList.back().get();
187}
188
Chris Lattner48c85b82007-05-04 03:30:17 +0000189//===----------------------------------------------------------------------===//
190// Functions for parsing blocks from the bitcode file
191//===----------------------------------------------------------------------===//
192
193bool BitcodeReader::ParseParamAttrBlock() {
Chris Lattnere17b6582007-05-05 00:17:00 +0000194 if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))
Chris Lattner48c85b82007-05-04 03:30:17 +0000195 return Error("Malformed block record");
196
197 if (!ParamAttrs.empty())
198 return Error("Multiple PARAMATTR blocks found!");
199
200 SmallVector<uint64_t, 64> Record;
201
202 ParamAttrsVector Attrs;
203
204 // Read all the records.
205 while (1) {
206 unsigned Code = Stream.ReadCode();
207 if (Code == bitc::END_BLOCK) {
208 if (Stream.ReadBlockEnd())
209 return Error("Error at end of PARAMATTR block");
210 return false;
211 }
212
213 if (Code == bitc::ENTER_SUBBLOCK) {
214 // No known subblocks, always skip them.
215 Stream.ReadSubBlockID();
216 if (Stream.SkipBlock())
217 return Error("Malformed block record");
218 continue;
219 }
220
221 if (Code == bitc::DEFINE_ABBREV) {
222 Stream.ReadAbbrevRecord();
223 continue;
224 }
225
226 // Read a record.
227 Record.clear();
228 switch (Stream.ReadRecord(Code, Record)) {
229 default: // Default behavior: ignore.
230 break;
231 case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [paramidx0, attr0, ...]
232 if (Record.size() & 1)
233 return Error("Invalid ENTRY record");
234
Chris Lattner48c85b82007-05-04 03:30:17 +0000235 for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
Duncan Sands5e41f652007-11-20 14:09:29 +0000236 if (Record[i+1] != ParamAttr::None)
237 Attrs.push_back(ParamAttrsWithIndex::get(Record[i], Record[i+1]));
Chris Lattner48c85b82007-05-04 03:30:17 +0000238 }
Duncan Sands5e41f652007-11-20 14:09:29 +0000239 ParamAttrs.push_back(Attrs.empty() ? NULL : ParamAttrsList::get(Attrs));
Chris Lattner48c85b82007-05-04 03:30:17 +0000240 Attrs.clear();
241 break;
242 }
Duncan Sands5e41f652007-11-20 14:09:29 +0000243 }
Chris Lattner48c85b82007-05-04 03:30:17 +0000244 }
245}
246
247
Chris Lattner86697142007-05-01 05:01:34 +0000248bool BitcodeReader::ParseTypeTable() {
Chris Lattnere17b6582007-05-05 00:17:00 +0000249 if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID))
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000250 return Error("Malformed block record");
251
252 if (!TypeList.empty())
253 return Error("Multiple TYPE_BLOCKs found!");
254
255 SmallVector<uint64_t, 64> Record;
256 unsigned NumRecords = 0;
257
258 // Read all the records for this type table.
259 while (1) {
260 unsigned Code = Stream.ReadCode();
261 if (Code == bitc::END_BLOCK) {
262 if (NumRecords != TypeList.size())
263 return Error("Invalid type forward reference in TYPE_BLOCK");
Chris Lattnerf66d20d2007-04-24 18:15:21 +0000264 if (Stream.ReadBlockEnd())
265 return Error("Error at end of type table block");
266 return false;
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000267 }
268
269 if (Code == bitc::ENTER_SUBBLOCK) {
270 // No known subblocks, always skip them.
271 Stream.ReadSubBlockID();
272 if (Stream.SkipBlock())
273 return Error("Malformed block record");
274 continue;
275 }
276
Chris Lattner36d5e7d2007-04-23 16:04:05 +0000277 if (Code == bitc::DEFINE_ABBREV) {
Chris Lattnerd127c1b2007-04-23 18:58:34 +0000278 Stream.ReadAbbrevRecord();
279 continue;
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000280 }
281
282 // Read a record.
283 Record.clear();
284 const Type *ResultTy = 0;
285 switch (Stream.ReadRecord(Code, Record)) {
286 default: // Default behavior: unknown type.
287 ResultTy = 0;
288 break;
289 case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries]
290 // TYPE_CODE_NUMENTRY contains a count of the number of types in the
291 // type list. This allows us to reserve space.
292 if (Record.size() < 1)
293 return Error("Invalid TYPE_CODE_NUMENTRY record");
294 TypeList.reserve(Record[0]);
295 continue;
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000296 case bitc::TYPE_CODE_VOID: // VOID
297 ResultTy = Type::VoidTy;
298 break;
299 case bitc::TYPE_CODE_FLOAT: // FLOAT
300 ResultTy = Type::FloatTy;
301 break;
302 case bitc::TYPE_CODE_DOUBLE: // DOUBLE
303 ResultTy = Type::DoubleTy;
304 break;
Dale Johannesen320fc8a2007-08-03 01:03:46 +0000305 case bitc::TYPE_CODE_X86_FP80: // X86_FP80
306 ResultTy = Type::X86_FP80Ty;
307 break;
308 case bitc::TYPE_CODE_FP128: // FP128
309 ResultTy = Type::FP128Ty;
310 break;
311 case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128
312 ResultTy = Type::PPC_FP128Ty;
313 break;
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000314 case bitc::TYPE_CODE_LABEL: // LABEL
315 ResultTy = Type::LabelTy;
316 break;
317 case bitc::TYPE_CODE_OPAQUE: // OPAQUE
318 ResultTy = 0;
319 break;
320 case bitc::TYPE_CODE_INTEGER: // INTEGER: [width]
321 if (Record.size() < 1)
322 return Error("Invalid Integer type record");
323
324 ResultTy = IntegerType::get(Record[0]);
325 break;
326 case bitc::TYPE_CODE_POINTER: // POINTER: [pointee type]
327 if (Record.size() < 1)
328 return Error("Invalid POINTER type record");
329 ResultTy = PointerType::get(getTypeByID(Record[0], true));
330 break;
331 case bitc::TYPE_CODE_FUNCTION: {
Duncan Sandsdc024672007-11-27 13:23:08 +0000332 // FUNCTION: [vararg, retty, paramty x N]
333 if (Record.size() < 2)
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000334 return Error("Invalid FUNCTION type record");
335 std::vector<const Type*> ArgTys;
Duncan Sandsdc024672007-11-27 13:23:08 +0000336 for (unsigned i = 2, e = Record.size(); i != e; ++i)
Chris Lattner15e6d172007-05-04 19:11:41 +0000337 ArgTys.push_back(getTypeByID(Record[i], true));
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000338
Duncan Sandsdc024672007-11-27 13:23:08 +0000339 ResultTy = FunctionType::get(getTypeByID(Record[1], true), ArgTys,
340 Record[0]);
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000341 break;
342 }
Chris Lattner15e6d172007-05-04 19:11:41 +0000343 case bitc::TYPE_CODE_STRUCT: { // STRUCT: [ispacked, eltty x N]
Chris Lattner7108dce2007-05-06 08:21:50 +0000344 if (Record.size() < 1)
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000345 return Error("Invalid STRUCT type record");
346 std::vector<const Type*> EltTys;
Chris Lattner15e6d172007-05-04 19:11:41 +0000347 for (unsigned i = 1, e = Record.size(); i != e; ++i)
348 EltTys.push_back(getTypeByID(Record[i], true));
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000349 ResultTy = StructType::get(EltTys, Record[0]);
350 break;
351 }
352 case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty]
353 if (Record.size() < 2)
354 return Error("Invalid ARRAY type record");
355 ResultTy = ArrayType::get(getTypeByID(Record[1], true), Record[0]);
356 break;
357 case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty]
358 if (Record.size() < 2)
359 return Error("Invalid VECTOR type record");
360 ResultTy = VectorType::get(getTypeByID(Record[1], true), Record[0]);
361 break;
362 }
363
364 if (NumRecords == TypeList.size()) {
365 // If this is a new type slot, just append it.
366 TypeList.push_back(ResultTy ? ResultTy : OpaqueType::get());
367 ++NumRecords;
368 } else if (ResultTy == 0) {
369 // Otherwise, this was forward referenced, so an opaque type was created,
370 // but the result type is actually just an opaque. Leave the one we
371 // created previously.
372 ++NumRecords;
373 } else {
374 // Otherwise, this was forward referenced, so an opaque type was created.
375 // Resolve the opaque type to the real type now.
376 assert(NumRecords < TypeList.size() && "Typelist imbalance");
377 const OpaqueType *OldTy = cast<OpaqueType>(TypeList[NumRecords++].get());
378
379 // Don't directly push the new type on the Tab. Instead we want to replace
380 // the opaque type we previously inserted with the new concrete value. The
381 // refinement from the abstract (opaque) type to the new type causes all
382 // uses of the abstract type to use the concrete type (NewTy). This will
383 // also cause the opaque type to be deleted.
384 const_cast<OpaqueType*>(OldTy)->refineAbstractTypeTo(ResultTy);
385
386 // This should have replaced the old opaque type with the new type in the
Chris Lattner0eef0802007-04-24 04:04:35 +0000387 // value table... or with a preexisting type that was already in the
388 // system. Let's just make sure it did.
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000389 assert(TypeList[NumRecords-1].get() != OldTy &&
390 "refineAbstractType didn't work!");
391 }
392 }
393}
394
395
Chris Lattner86697142007-05-01 05:01:34 +0000396bool BitcodeReader::ParseTypeSymbolTable() {
Chris Lattnere17b6582007-05-05 00:17:00 +0000397 if (Stream.EnterSubBlock(bitc::TYPE_SYMTAB_BLOCK_ID))
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000398 return Error("Malformed block record");
399
400 SmallVector<uint64_t, 64> Record;
401
402 // Read all the records for this type table.
403 std::string TypeName;
404 while (1) {
405 unsigned Code = Stream.ReadCode();
Chris Lattnerf66d20d2007-04-24 18:15:21 +0000406 if (Code == bitc::END_BLOCK) {
407 if (Stream.ReadBlockEnd())
408 return Error("Error at end of type symbol table block");
409 return false;
410 }
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000411
412 if (Code == bitc::ENTER_SUBBLOCK) {
413 // No known subblocks, always skip them.
414 Stream.ReadSubBlockID();
415 if (Stream.SkipBlock())
416 return Error("Malformed block record");
417 continue;
418 }
419
Chris Lattner36d5e7d2007-04-23 16:04:05 +0000420 if (Code == bitc::DEFINE_ABBREV) {
Chris Lattnerd127c1b2007-04-23 18:58:34 +0000421 Stream.ReadAbbrevRecord();
422 continue;
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000423 }
424
425 // Read a record.
426 Record.clear();
427 switch (Stream.ReadRecord(Code, Record)) {
428 default: // Default behavior: unknown type.
429 break;
Chris Lattner15e6d172007-05-04 19:11:41 +0000430 case bitc::TST_CODE_ENTRY: // TST_ENTRY: [typeid, namechar x N]
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000431 if (ConvertToString(Record, 1, TypeName))
432 return Error("Invalid TST_ENTRY record");
433 unsigned TypeID = Record[0];
434 if (TypeID >= TypeList.size())
435 return Error("Invalid Type ID in TST_ENTRY record");
436
437 TheModule->addTypeName(TypeName, TypeList[TypeID].get());
438 TypeName.clear();
439 break;
440 }
441 }
442}
443
Chris Lattner86697142007-05-01 05:01:34 +0000444bool BitcodeReader::ParseValueSymbolTable() {
Chris Lattnere17b6582007-05-05 00:17:00 +0000445 if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
Chris Lattner0b2482a2007-04-23 21:26:05 +0000446 return Error("Malformed block record");
447
448 SmallVector<uint64_t, 64> Record;
449
450 // Read all the records for this value table.
451 SmallString<128> ValueName;
452 while (1) {
453 unsigned Code = Stream.ReadCode();
Chris Lattnerf66d20d2007-04-24 18:15:21 +0000454 if (Code == bitc::END_BLOCK) {
455 if (Stream.ReadBlockEnd())
456 return Error("Error at end of value symbol table block");
457 return false;
458 }
Chris Lattner0b2482a2007-04-23 21:26:05 +0000459 if (Code == bitc::ENTER_SUBBLOCK) {
460 // No known subblocks, always skip them.
461 Stream.ReadSubBlockID();
462 if (Stream.SkipBlock())
463 return Error("Malformed block record");
464 continue;
465 }
466
467 if (Code == bitc::DEFINE_ABBREV) {
468 Stream.ReadAbbrevRecord();
469 continue;
470 }
471
472 // Read a record.
473 Record.clear();
474 switch (Stream.ReadRecord(Code, Record)) {
475 default: // Default behavior: unknown type.
476 break;
Chris Lattner15e6d172007-05-04 19:11:41 +0000477 case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N]
Chris Lattner0b2482a2007-04-23 21:26:05 +0000478 if (ConvertToString(Record, 1, ValueName))
479 return Error("Invalid TST_ENTRY record");
480 unsigned ValueID = Record[0];
481 if (ValueID >= ValueList.size())
482 return Error("Invalid Value ID in VST_ENTRY record");
483 Value *V = ValueList[ValueID];
484
485 V->setName(&ValueName[0], ValueName.size());
486 ValueName.clear();
487 break;
Reid Spencerc8f8a242007-05-04 01:43:33 +0000488 }
489 case bitc::VST_CODE_BBENTRY: {
Chris Lattnere825ed52007-05-03 22:18:21 +0000490 if (ConvertToString(Record, 1, ValueName))
491 return Error("Invalid VST_BBENTRY record");
492 BasicBlock *BB = getBasicBlock(Record[0]);
493 if (BB == 0)
494 return Error("Invalid BB ID in VST_BBENTRY record");
495
496 BB->setName(&ValueName[0], ValueName.size());
497 ValueName.clear();
498 break;
Chris Lattner0b2482a2007-04-23 21:26:05 +0000499 }
Reid Spencerc8f8a242007-05-04 01:43:33 +0000500 }
Chris Lattner0b2482a2007-04-23 21:26:05 +0000501 }
502}
503
Chris Lattner0eef0802007-04-24 04:04:35 +0000504/// DecodeSignRotatedValue - Decode a signed value stored with the sign bit in
505/// the LSB for dense VBR encoding.
506static uint64_t DecodeSignRotatedValue(uint64_t V) {
507 if ((V & 1) == 0)
508 return V >> 1;
509 if (V != 1)
510 return -(V >> 1);
511 // There is no such thing as -0 with integers. "-0" really means MININT.
512 return 1ULL << 63;
513}
514
Chris Lattner07d98b42007-04-26 02:46:40 +0000515/// ResolveGlobalAndAliasInits - Resolve all of the initializers for global
516/// values and aliases that we can.
517bool BitcodeReader::ResolveGlobalAndAliasInits() {
518 std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist;
519 std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist;
520
521 GlobalInitWorklist.swap(GlobalInits);
522 AliasInitWorklist.swap(AliasInits);
523
524 while (!GlobalInitWorklist.empty()) {
Chris Lattner198f34a2007-04-26 03:27:58 +0000525 unsigned ValID = GlobalInitWorklist.back().second;
Chris Lattner07d98b42007-04-26 02:46:40 +0000526 if (ValID >= ValueList.size()) {
527 // Not ready to resolve this yet, it requires something later in the file.
Chris Lattner198f34a2007-04-26 03:27:58 +0000528 GlobalInits.push_back(GlobalInitWorklist.back());
Chris Lattner07d98b42007-04-26 02:46:40 +0000529 } else {
530 if (Constant *C = dyn_cast<Constant>(ValueList[ValID]))
531 GlobalInitWorklist.back().first->setInitializer(C);
532 else
533 return Error("Global variable initializer is not a constant!");
534 }
535 GlobalInitWorklist.pop_back();
536 }
537
538 while (!AliasInitWorklist.empty()) {
539 unsigned ValID = AliasInitWorklist.back().second;
540 if (ValID >= ValueList.size()) {
541 AliasInits.push_back(AliasInitWorklist.back());
542 } else {
543 if (Constant *C = dyn_cast<Constant>(ValueList[ValID]))
Anton Korobeynikov7dde0ff2007-04-28 14:57:59 +0000544 AliasInitWorklist.back().first->setAliasee(C);
Chris Lattner07d98b42007-04-26 02:46:40 +0000545 else
546 return Error("Alias initializer is not a constant!");
547 }
548 AliasInitWorklist.pop_back();
549 }
550 return false;
551}
552
553
Chris Lattner86697142007-05-01 05:01:34 +0000554bool BitcodeReader::ParseConstants() {
Chris Lattnere17b6582007-05-05 00:17:00 +0000555 if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))
Chris Lattnere16504e2007-04-24 03:30:34 +0000556 return Error("Malformed block record");
557
558 SmallVector<uint64_t, 64> Record;
559
560 // Read all the records for this value table.
561 const Type *CurTy = Type::Int32Ty;
Chris Lattner522b7b12007-04-24 05:48:56 +0000562 unsigned NextCstNo = ValueList.size();
Chris Lattnere16504e2007-04-24 03:30:34 +0000563 while (1) {
564 unsigned Code = Stream.ReadCode();
565 if (Code == bitc::END_BLOCK) {
Chris Lattner522b7b12007-04-24 05:48:56 +0000566 if (NextCstNo != ValueList.size())
567 return Error("Invalid constant reference!");
568
Chris Lattnerf66d20d2007-04-24 18:15:21 +0000569 if (Stream.ReadBlockEnd())
570 return Error("Error at end of constants block");
571 return false;
Chris Lattnere16504e2007-04-24 03:30:34 +0000572 }
573
574 if (Code == bitc::ENTER_SUBBLOCK) {
575 // No known subblocks, always skip them.
576 Stream.ReadSubBlockID();
577 if (Stream.SkipBlock())
578 return Error("Malformed block record");
579 continue;
580 }
581
582 if (Code == bitc::DEFINE_ABBREV) {
583 Stream.ReadAbbrevRecord();
584 continue;
585 }
586
587 // Read a record.
588 Record.clear();
589 Value *V = 0;
590 switch (Stream.ReadRecord(Code, Record)) {
591 default: // Default behavior: unknown constant
592 case bitc::CST_CODE_UNDEF: // UNDEF
593 V = UndefValue::get(CurTy);
594 break;
595 case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid]
596 if (Record.empty())
597 return Error("Malformed CST_SETTYPE record");
598 if (Record[0] >= TypeList.size())
599 return Error("Invalid Type ID in CST_SETTYPE record");
600 CurTy = TypeList[Record[0]];
Chris Lattner0eef0802007-04-24 04:04:35 +0000601 continue; // Skip the ValueList manipulation.
Chris Lattnere16504e2007-04-24 03:30:34 +0000602 case bitc::CST_CODE_NULL: // NULL
603 V = Constant::getNullValue(CurTy);
604 break;
605 case bitc::CST_CODE_INTEGER: // INTEGER: [intval]
Chris Lattner0eef0802007-04-24 04:04:35 +0000606 if (!isa<IntegerType>(CurTy) || Record.empty())
607 return Error("Invalid CST_INTEGER record");
608 V = ConstantInt::get(CurTy, DecodeSignRotatedValue(Record[0]));
609 break;
Chris Lattner15e6d172007-05-04 19:11:41 +0000610 case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval]
611 if (!isa<IntegerType>(CurTy) || Record.empty())
Chris Lattner0eef0802007-04-24 04:04:35 +0000612 return Error("Invalid WIDE_INTEGER record");
613
Chris Lattner15e6d172007-05-04 19:11:41 +0000614 unsigned NumWords = Record.size();
Chris Lattner084a8442007-04-24 17:22:05 +0000615 SmallVector<uint64_t, 8> Words;
616 Words.resize(NumWords);
Chris Lattner0eef0802007-04-24 04:04:35 +0000617 for (unsigned i = 0; i != NumWords; ++i)
Chris Lattner15e6d172007-05-04 19:11:41 +0000618 Words[i] = DecodeSignRotatedValue(Record[i]);
Chris Lattner0eef0802007-04-24 04:04:35 +0000619 V = ConstantInt::get(APInt(cast<IntegerType>(CurTy)->getBitWidth(),
Chris Lattner084a8442007-04-24 17:22:05 +0000620 NumWords, &Words[0]));
Chris Lattner0eef0802007-04-24 04:04:35 +0000621 break;
622 }
Dale Johannesen3f6eb742007-09-11 18:32:33 +0000623 case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval]
Chris Lattner0eef0802007-04-24 04:04:35 +0000624 if (Record.empty())
625 return Error("Invalid FLOAT record");
626 if (CurTy == Type::FloatTy)
Dale Johannesen3f6eb742007-09-11 18:32:33 +0000627 V = ConstantFP::get(CurTy, APFloat(APInt(32, (uint32_t)Record[0])));
Chris Lattner0eef0802007-04-24 04:04:35 +0000628 else if (CurTy == Type::DoubleTy)
Dale Johannesen3f6eb742007-09-11 18:32:33 +0000629 V = ConstantFP::get(CurTy, APFloat(APInt(64, Record[0])));
Dale Johannesen43421b32007-09-06 18:13:44 +0000630 else if (CurTy == Type::X86_FP80Ty)
Dale Johannesen3f6eb742007-09-11 18:32:33 +0000631 V = ConstantFP::get(CurTy, APFloat(APInt(80, 2, &Record[0])));
Dale Johannesen43421b32007-09-06 18:13:44 +0000632 else if (CurTy == Type::FP128Ty)
Dale Johannesena471c2e2007-10-11 18:07:22 +0000633 V = ConstantFP::get(CurTy, APFloat(APInt(128, 2, &Record[0]), true));
Dale Johannesen43421b32007-09-06 18:13:44 +0000634 else if (CurTy == Type::PPC_FP128Ty)
Dale Johannesena471c2e2007-10-11 18:07:22 +0000635 V = ConstantFP::get(CurTy, APFloat(APInt(128, 2, &Record[0])));
Chris Lattnere16504e2007-04-24 03:30:34 +0000636 else
Chris Lattner0eef0802007-04-24 04:04:35 +0000637 V = UndefValue::get(CurTy);
Chris Lattnere16504e2007-04-24 03:30:34 +0000638 break;
Dale Johannesen3f6eb742007-09-11 18:32:33 +0000639 }
Chris Lattner522b7b12007-04-24 05:48:56 +0000640
Chris Lattner15e6d172007-05-04 19:11:41 +0000641 case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number]
642 if (Record.empty())
Chris Lattner522b7b12007-04-24 05:48:56 +0000643 return Error("Invalid CST_AGGREGATE record");
644
Chris Lattner15e6d172007-05-04 19:11:41 +0000645 unsigned Size = Record.size();
Chris Lattner522b7b12007-04-24 05:48:56 +0000646 std::vector<Constant*> Elts;
647
648 if (const StructType *STy = dyn_cast<StructType>(CurTy)) {
649 for (unsigned i = 0; i != Size; ++i)
Chris Lattner15e6d172007-05-04 19:11:41 +0000650 Elts.push_back(ValueList.getConstantFwdRef(Record[i],
Chris Lattner522b7b12007-04-24 05:48:56 +0000651 STy->getElementType(i)));
652 V = ConstantStruct::get(STy, Elts);
653 } else if (const ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) {
654 const Type *EltTy = ATy->getElementType();
655 for (unsigned i = 0; i != Size; ++i)
Chris Lattner15e6d172007-05-04 19:11:41 +0000656 Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
Chris Lattner522b7b12007-04-24 05:48:56 +0000657 V = ConstantArray::get(ATy, Elts);
658 } else if (const VectorType *VTy = dyn_cast<VectorType>(CurTy)) {
659 const Type *EltTy = VTy->getElementType();
660 for (unsigned i = 0; i != Size; ++i)
Chris Lattner15e6d172007-05-04 19:11:41 +0000661 Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
Chris Lattner522b7b12007-04-24 05:48:56 +0000662 V = ConstantVector::get(Elts);
663 } else {
664 V = UndefValue::get(CurTy);
665 }
Chris Lattnerf581c3b2007-04-24 07:07:11 +0000666 break;
667 }
Chris Lattnerff7fc5d2007-05-06 00:35:24 +0000668 case bitc::CST_CODE_STRING: { // STRING: [values]
669 if (Record.empty())
670 return Error("Invalid CST_AGGREGATE record");
Chris Lattnerf581c3b2007-04-24 07:07:11 +0000671
Chris Lattnerff7fc5d2007-05-06 00:35:24 +0000672 const ArrayType *ATy = cast<ArrayType>(CurTy);
673 const Type *EltTy = ATy->getElementType();
674
675 unsigned Size = Record.size();
676 std::vector<Constant*> Elts;
Chris Lattnerff7fc5d2007-05-06 00:35:24 +0000677 for (unsigned i = 0; i != Size; ++i)
678 Elts.push_back(ConstantInt::get(EltTy, Record[i]));
679 V = ConstantArray::get(ATy, Elts);
680 break;
681 }
Chris Lattnercb3d91b2007-05-06 00:53:07 +0000682 case bitc::CST_CODE_CSTRING: { // CSTRING: [values]
683 if (Record.empty())
684 return Error("Invalid CST_AGGREGATE record");
685
686 const ArrayType *ATy = cast<ArrayType>(CurTy);
687 const Type *EltTy = ATy->getElementType();
688
689 unsigned Size = Record.size();
690 std::vector<Constant*> Elts;
691 for (unsigned i = 0; i != Size; ++i)
692 Elts.push_back(ConstantInt::get(EltTy, Record[i]));
693 Elts.push_back(Constant::getNullValue(EltTy));
694 V = ConstantArray::get(ATy, Elts);
695 break;
696 }
Chris Lattnerf581c3b2007-04-24 07:07:11 +0000697 case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval]
698 if (Record.size() < 3) return Error("Invalid CE_BINOP record");
699 int Opc = GetDecodedBinaryOpcode(Record[0], CurTy);
Chris Lattnerf66d20d2007-04-24 18:15:21 +0000700 if (Opc < 0) {
701 V = UndefValue::get(CurTy); // Unknown binop.
702 } else {
703 Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy);
704 Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy);
705 V = ConstantExpr::get(Opc, LHS, RHS);
706 }
Chris Lattnerf581c3b2007-04-24 07:07:11 +0000707 break;
708 }
709 case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval]
710 if (Record.size() < 3) return Error("Invalid CE_CAST record");
711 int Opc = GetDecodedCastOpcode(Record[0]);
Chris Lattnerf66d20d2007-04-24 18:15:21 +0000712 if (Opc < 0) {
713 V = UndefValue::get(CurTy); // Unknown cast.
714 } else {
715 const Type *OpTy = getTypeByID(Record[1]);
Chris Lattnerbfcc3802007-05-06 07:33:01 +0000716 if (!OpTy) return Error("Invalid CE_CAST record");
Chris Lattnerf66d20d2007-04-24 18:15:21 +0000717 Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy);
718 V = ConstantExpr::getCast(Opc, Op, CurTy);
719 }
Chris Lattnerf581c3b2007-04-24 07:07:11 +0000720 break;
721 }
722 case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands]
Chris Lattner15e6d172007-05-04 19:11:41 +0000723 if (Record.size() & 1) return Error("Invalid CE_GEP record");
Chris Lattnerf581c3b2007-04-24 07:07:11 +0000724 SmallVector<Constant*, 16> Elts;
Chris Lattner15e6d172007-05-04 19:11:41 +0000725 for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
Chris Lattnerf581c3b2007-04-24 07:07:11 +0000726 const Type *ElTy = getTypeByID(Record[i]);
727 if (!ElTy) return Error("Invalid CE_GEP record");
728 Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy));
729 }
Chris Lattnerf66d20d2007-04-24 18:15:21 +0000730 V = ConstantExpr::getGetElementPtr(Elts[0], &Elts[1], Elts.size()-1);
731 break;
Chris Lattnerf581c3b2007-04-24 07:07:11 +0000732 }
733 case bitc::CST_CODE_CE_SELECT: // CE_SELECT: [opval#, opval#, opval#]
734 if (Record.size() < 3) return Error("Invalid CE_SELECT record");
735 V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0],
736 Type::Int1Ty),
737 ValueList.getConstantFwdRef(Record[1],CurTy),
738 ValueList.getConstantFwdRef(Record[2],CurTy));
739 break;
740 case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval]
741 if (Record.size() < 3) return Error("Invalid CE_EXTRACTELT record");
742 const VectorType *OpTy =
743 dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
744 if (OpTy == 0) return Error("Invalid CE_EXTRACTELT record");
745 Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
746 Constant *Op1 = ValueList.getConstantFwdRef(Record[2],
747 OpTy->getElementType());
748 V = ConstantExpr::getExtractElement(Op0, Op1);
749 break;
750 }
751 case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval]
752 const VectorType *OpTy = dyn_cast<VectorType>(CurTy);
753 if (Record.size() < 3 || OpTy == 0)
754 return Error("Invalid CE_INSERTELT record");
755 Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
756 Constant *Op1 = ValueList.getConstantFwdRef(Record[1],
757 OpTy->getElementType());
758 Constant *Op2 = ValueList.getConstantFwdRef(Record[2], Type::Int32Ty);
759 V = ConstantExpr::getInsertElement(Op0, Op1, Op2);
760 break;
761 }
762 case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval]
763 const VectorType *OpTy = dyn_cast<VectorType>(CurTy);
764 if (Record.size() < 3 || OpTy == 0)
765 return Error("Invalid CE_INSERTELT record");
766 Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
767 Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy);
768 const Type *ShufTy=VectorType::get(Type::Int32Ty, OpTy->getNumElements());
769 Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy);
770 V = ConstantExpr::getShuffleVector(Op0, Op1, Op2);
771 break;
772 }
773 case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred]
774 if (Record.size() < 4) return Error("Invalid CE_CMP record");
775 const Type *OpTy = getTypeByID(Record[0]);
776 if (OpTy == 0) return Error("Invalid CE_CMP record");
777 Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
778 Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
779
780 if (OpTy->isFloatingPoint())
781 V = ConstantExpr::getFCmp(Record[3], Op0, Op1);
782 else
783 V = ConstantExpr::getICmp(Record[3], Op0, Op1);
784 break;
Chris Lattner522b7b12007-04-24 05:48:56 +0000785 }
Chris Lattner2bce93a2007-05-06 01:58:20 +0000786 case bitc::CST_CODE_INLINEASM: {
787 if (Record.size() < 2) return Error("Invalid INLINEASM record");
788 std::string AsmStr, ConstrStr;
789 bool HasSideEffects = Record[0];
790 unsigned AsmStrSize = Record[1];
791 if (2+AsmStrSize >= Record.size())
792 return Error("Invalid INLINEASM record");
793 unsigned ConstStrSize = Record[2+AsmStrSize];
794 if (3+AsmStrSize+ConstStrSize > Record.size())
795 return Error("Invalid INLINEASM record");
796
797 for (unsigned i = 0; i != AsmStrSize; ++i)
798 AsmStr += (char)Record[2+i];
799 for (unsigned i = 0; i != ConstStrSize; ++i)
800 ConstrStr += (char)Record[3+AsmStrSize+i];
801 const PointerType *PTy = cast<PointerType>(CurTy);
802 V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()),
803 AsmStr, ConstrStr, HasSideEffects);
804 break;
805 }
Chris Lattnere16504e2007-04-24 03:30:34 +0000806 }
807
Chris Lattnera7c49aa2007-05-01 07:01:57 +0000808 ValueList.AssignValue(V, NextCstNo);
Chris Lattner522b7b12007-04-24 05:48:56 +0000809 ++NextCstNo;
Chris Lattnere16504e2007-04-24 03:30:34 +0000810 }
811}
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000812
Chris Lattner980e5aa2007-05-01 05:52:21 +0000813/// RememberAndSkipFunctionBody - When we see the block for a function body,
814/// remember where it is and then skip it. This lets us lazily deserialize the
815/// functions.
816bool BitcodeReader::RememberAndSkipFunctionBody() {
Chris Lattner48f84872007-05-01 04:59:48 +0000817 // Get the function we are talking about.
818 if (FunctionsWithBodies.empty())
819 return Error("Insufficient function protos");
820
821 Function *Fn = FunctionsWithBodies.back();
822 FunctionsWithBodies.pop_back();
823
824 // Save the current stream state.
825 uint64_t CurBit = Stream.GetCurrentBitNo();
826 DeferredFunctionInfo[Fn] = std::make_pair(CurBit, Fn->getLinkage());
827
828 // Set the functions linkage to GhostLinkage so we know it is lazily
829 // deserialized.
830 Fn->setLinkage(GlobalValue::GhostLinkage);
831
832 // Skip over the function block for now.
833 if (Stream.SkipBlock())
834 return Error("Malformed block record");
835 return false;
836}
837
Chris Lattner86697142007-05-01 05:01:34 +0000838bool BitcodeReader::ParseModule(const std::string &ModuleID) {
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000839 // Reject multiple MODULE_BLOCK's in a single bitstream.
840 if (TheModule)
841 return Error("Multiple MODULE_BLOCKs in same stream");
842
Chris Lattnere17b6582007-05-05 00:17:00 +0000843 if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000844 return Error("Malformed block record");
845
846 // Otherwise, create the module.
847 TheModule = new Module(ModuleID);
848
849 SmallVector<uint64_t, 64> Record;
850 std::vector<std::string> SectionTable;
851
852 // Read all the records for this module.
853 while (!Stream.AtEndOfStream()) {
854 unsigned Code = Stream.ReadCode();
Chris Lattnere84bcb92007-04-24 00:21:45 +0000855 if (Code == bitc::END_BLOCK) {
Chris Lattner980e5aa2007-05-01 05:52:21 +0000856 if (Stream.ReadBlockEnd())
857 return Error("Error at end of module block");
858
859 // Patch the initializers for globals and aliases up.
Chris Lattner07d98b42007-04-26 02:46:40 +0000860 ResolveGlobalAndAliasInits();
861 if (!GlobalInits.empty() || !AliasInits.empty())
Chris Lattnere84bcb92007-04-24 00:21:45 +0000862 return Error("Malformed global initializer set");
Chris Lattner48f84872007-05-01 04:59:48 +0000863 if (!FunctionsWithBodies.empty())
864 return Error("Too few function bodies found");
Chris Lattner980e5aa2007-05-01 05:52:21 +0000865
Chandler Carruth69940402007-08-04 01:51:18 +0000866 // Look for intrinsic functions which need to be upgraded at some point
867 for (Module::iterator FI = TheModule->begin(), FE = TheModule->end();
868 FI != FE; ++FI) {
869 if (Function* NewFn = UpgradeIntrinsicFunction(FI))
870 UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn));
871 }
872
Chris Lattner980e5aa2007-05-01 05:52:21 +0000873 // Force deallocation of memory for these vectors to favor the client that
874 // want lazy deserialization.
875 std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits);
876 std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits);
877 std::vector<Function*>().swap(FunctionsWithBodies);
Chris Lattnerf66d20d2007-04-24 18:15:21 +0000878 return false;
Chris Lattnere84bcb92007-04-24 00:21:45 +0000879 }
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000880
881 if (Code == bitc::ENTER_SUBBLOCK) {
882 switch (Stream.ReadSubBlockID()) {
883 default: // Skip unknown content.
884 if (Stream.SkipBlock())
885 return Error("Malformed block record");
886 break;
Chris Lattner3f799802007-05-05 18:57:30 +0000887 case bitc::BLOCKINFO_BLOCK_ID:
888 if (Stream.ReadBlockInfoBlock())
889 return Error("Malformed BlockInfoBlock");
890 break;
Chris Lattner48c85b82007-05-04 03:30:17 +0000891 case bitc::PARAMATTR_BLOCK_ID:
892 if (ParseParamAttrBlock())
893 return true;
894 break;
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000895 case bitc::TYPE_BLOCK_ID:
Chris Lattner86697142007-05-01 05:01:34 +0000896 if (ParseTypeTable())
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000897 return true;
898 break;
899 case bitc::TYPE_SYMTAB_BLOCK_ID:
Chris Lattner86697142007-05-01 05:01:34 +0000900 if (ParseTypeSymbolTable())
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000901 return true;
902 break;
Chris Lattner0b2482a2007-04-23 21:26:05 +0000903 case bitc::VALUE_SYMTAB_BLOCK_ID:
Chris Lattner86697142007-05-01 05:01:34 +0000904 if (ParseValueSymbolTable())
Chris Lattner0b2482a2007-04-23 21:26:05 +0000905 return true;
906 break;
Chris Lattnere16504e2007-04-24 03:30:34 +0000907 case bitc::CONSTANTS_BLOCK_ID:
Chris Lattner86697142007-05-01 05:01:34 +0000908 if (ParseConstants() || ResolveGlobalAndAliasInits())
Chris Lattnere16504e2007-04-24 03:30:34 +0000909 return true;
910 break;
Chris Lattner48f84872007-05-01 04:59:48 +0000911 case bitc::FUNCTION_BLOCK_ID:
912 // If this is the first function body we've seen, reverse the
913 // FunctionsWithBodies list.
914 if (!HasReversedFunctionsWithBodies) {
915 std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end());
916 HasReversedFunctionsWithBodies = true;
917 }
918
Chris Lattner980e5aa2007-05-01 05:52:21 +0000919 if (RememberAndSkipFunctionBody())
Chris Lattner48f84872007-05-01 04:59:48 +0000920 return true;
921 break;
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000922 }
923 continue;
924 }
925
Chris Lattner36d5e7d2007-04-23 16:04:05 +0000926 if (Code == bitc::DEFINE_ABBREV) {
Chris Lattnerd127c1b2007-04-23 18:58:34 +0000927 Stream.ReadAbbrevRecord();
928 continue;
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000929 }
930
931 // Read a record.
932 switch (Stream.ReadRecord(Code, Record)) {
933 default: break; // Default behavior, ignore unknown content.
934 case bitc::MODULE_CODE_VERSION: // VERSION: [version#]
935 if (Record.size() < 1)
936 return Error("Malformed MODULE_CODE_VERSION");
937 // Only version #0 is supported so far.
938 if (Record[0] != 0)
939 return Error("Unknown bitstream version!");
940 break;
Chris Lattner15e6d172007-05-04 19:11:41 +0000941 case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N]
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000942 std::string S;
943 if (ConvertToString(Record, 0, S))
944 return Error("Invalid MODULE_CODE_TRIPLE record");
945 TheModule->setTargetTriple(S);
946 break;
947 }
Chris Lattner15e6d172007-05-04 19:11:41 +0000948 case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N]
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000949 std::string S;
950 if (ConvertToString(Record, 0, S))
951 return Error("Invalid MODULE_CODE_DATALAYOUT record");
952 TheModule->setDataLayout(S);
953 break;
954 }
Chris Lattner15e6d172007-05-04 19:11:41 +0000955 case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N]
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000956 std::string S;
957 if (ConvertToString(Record, 0, S))
958 return Error("Invalid MODULE_CODE_ASM record");
959 TheModule->setModuleInlineAsm(S);
960 break;
961 }
Chris Lattner15e6d172007-05-04 19:11:41 +0000962 case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N]
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000963 std::string S;
964 if (ConvertToString(Record, 0, S))
965 return Error("Invalid MODULE_CODE_DEPLIB record");
966 TheModule->addLibrary(S);
967 break;
968 }
Chris Lattner15e6d172007-05-04 19:11:41 +0000969 case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N]
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000970 std::string S;
971 if (ConvertToString(Record, 0, S))
972 return Error("Invalid MODULE_CODE_SECTIONNAME record");
973 SectionTable.push_back(S);
974 break;
975 }
976 // GLOBALVAR: [type, isconst, initid,
977 // linkage, alignment, section, visibility, threadlocal]
978 case bitc::MODULE_CODE_GLOBALVAR: {
Chris Lattner36d5e7d2007-04-23 16:04:05 +0000979 if (Record.size() < 6)
Chris Lattnercaee0dc2007-04-22 06:23:29 +0000980 return Error("Invalid MODULE_CODE_GLOBALVAR record");
981 const Type *Ty = getTypeByID(Record[0]);
982 if (!isa<PointerType>(Ty))
983 return Error("Global not a pointer type!");
984 Ty = cast<PointerType>(Ty)->getElementType();
985
986 bool isConstant = Record[1];
987 GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]);
988 unsigned Alignment = (1 << Record[4]) >> 1;
989 std::string Section;
990 if (Record[5]) {
991 if (Record[5]-1 >= SectionTable.size())
992 return Error("Invalid section ID");
993 Section = SectionTable[Record[5]-1];
994 }
Chris Lattner36d5e7d2007-04-23 16:04:05 +0000995 GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility;
Chris Lattner5f32c012007-05-06 19:27:46 +0000996 if (Record.size() > 6)
997 Visibility = GetDecodedVisibility(Record[6]);
Chris Lattner36d5e7d2007-04-23 16:04:05 +0000998 bool isThreadLocal = false;
Chris Lattner5f32c012007-05-06 19:27:46 +0000999 if (Record.size() > 7)
1000 isThreadLocal = Record[7];
Chris Lattnercaee0dc2007-04-22 06:23:29 +00001001
1002 GlobalVariable *NewGV =
1003 new GlobalVariable(Ty, isConstant, Linkage, 0, "", TheModule);
1004 NewGV->setAlignment(Alignment);
1005 if (!Section.empty())
1006 NewGV->setSection(Section);
1007 NewGV->setVisibility(Visibility);
1008 NewGV->setThreadLocal(isThreadLocal);
1009
Chris Lattner0b2482a2007-04-23 21:26:05 +00001010 ValueList.push_back(NewGV);
1011
Chris Lattner6dbfd7b2007-04-24 00:18:21 +00001012 // Remember which value to use for the global initializer.
1013 if (unsigned InitID = Record[2])
1014 GlobalInits.push_back(std::make_pair(NewGV, InitID-1));
Chris Lattnercaee0dc2007-04-22 06:23:29 +00001015 break;
1016 }
Chris Lattnera9bb7132007-05-08 05:38:01 +00001017 // FUNCTION: [type, callingconv, isproto, linkage, paramattr,
1018 // alignment, section, visibility]
Chris Lattnercaee0dc2007-04-22 06:23:29 +00001019 case bitc::MODULE_CODE_FUNCTION: {
Chris Lattnera9bb7132007-05-08 05:38:01 +00001020 if (Record.size() < 8)
Chris Lattnercaee0dc2007-04-22 06:23:29 +00001021 return Error("Invalid MODULE_CODE_FUNCTION record");
1022 const Type *Ty = getTypeByID(Record[0]);
1023 if (!isa<PointerType>(Ty))
1024 return Error("Function not a pointer type!");
1025 const FunctionType *FTy =
1026 dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType());
1027 if (!FTy)
1028 return Error("Function not a pointer to function type!");
1029
1030 Function *Func = new Function(FTy, GlobalValue::ExternalLinkage,
1031 "", TheModule);
1032
1033 Func->setCallingConv(Record[1]);
Chris Lattner48f84872007-05-01 04:59:48 +00001034 bool isProto = Record[2];
Chris Lattnercaee0dc2007-04-22 06:23:29 +00001035 Func->setLinkage(GetDecodedLinkage(Record[3]));
Duncan Sandsdc024672007-11-27 13:23:08 +00001036 const ParamAttrsList *PAL = getParamAttrs(Record[4]);
1037 Func->setParamAttrs(PAL);
Chris Lattnera9bb7132007-05-08 05:38:01 +00001038
1039 Func->setAlignment((1 << Record[5]) >> 1);
1040 if (Record[6]) {
1041 if (Record[6]-1 >= SectionTable.size())
Chris Lattnercaee0dc2007-04-22 06:23:29 +00001042 return Error("Invalid section ID");
Chris Lattnera9bb7132007-05-08 05:38:01 +00001043 Func->setSection(SectionTable[Record[6]-1]);
Chris Lattnercaee0dc2007-04-22 06:23:29 +00001044 }
Chris Lattnera9bb7132007-05-08 05:38:01 +00001045 Func->setVisibility(GetDecodedVisibility(Record[7]));
Chris Lattnercaee0dc2007-04-22 06:23:29 +00001046
Chris Lattner0b2482a2007-04-23 21:26:05 +00001047 ValueList.push_back(Func);
Chris Lattner48f84872007-05-01 04:59:48 +00001048
1049 // If this is a function with a body, remember the prototype we are
1050 // creating now, so that we can match up the body with them later.
1051 if (!isProto)
1052 FunctionsWithBodies.push_back(Func);
Chris Lattnercaee0dc2007-04-22 06:23:29 +00001053 break;
1054 }
Chris Lattner07d98b42007-04-26 02:46:40 +00001055 // ALIAS: [alias type, aliasee val#, linkage]
Chris Lattner198f34a2007-04-26 03:27:58 +00001056 case bitc::MODULE_CODE_ALIAS: {
Chris Lattner07d98b42007-04-26 02:46:40 +00001057 if (Record.size() < 3)
1058 return Error("Invalid MODULE_ALIAS record");
1059 const Type *Ty = getTypeByID(Record[0]);
1060 if (!isa<PointerType>(Ty))
1061 return Error("Function not a pointer type!");
1062
1063 GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]),
1064 "", 0, TheModule);
1065 ValueList.push_back(NewGA);
1066 AliasInits.push_back(std::make_pair(NewGA, Record[1]));
1067 break;
Chris Lattnercaee0dc2007-04-22 06:23:29 +00001068 }
Chris Lattner198f34a2007-04-26 03:27:58 +00001069 /// MODULE_CODE_PURGEVALS: [numvals]
1070 case bitc::MODULE_CODE_PURGEVALS:
1071 // Trim down the value list to the specified size.
1072 if (Record.size() < 1 || Record[0] > ValueList.size())
1073 return Error("Invalid MODULE_PURGEVALS record");
1074 ValueList.shrinkTo(Record[0]);
1075 break;
1076 }
Chris Lattnercaee0dc2007-04-22 06:23:29 +00001077 Record.clear();
1078 }
1079
1080 return Error("Premature end of bitstream");
1081}
1082
1083
Chris Lattnerc453f762007-04-29 07:54:31 +00001084bool BitcodeReader::ParseBitcode() {
Chris Lattnercaee0dc2007-04-22 06:23:29 +00001085 TheModule = 0;
1086
Chris Lattnerc453f762007-04-29 07:54:31 +00001087 if (Buffer->getBufferSize() & 3)
Chris Lattnercaee0dc2007-04-22 06:23:29 +00001088 return Error("Bitcode stream should be a multiple of 4 bytes in length");
1089
Chris Lattnerc453f762007-04-29 07:54:31 +00001090 unsigned char *BufPtr = (unsigned char *)Buffer->getBufferStart();
Chris Lattner48f84872007-05-01 04:59:48 +00001091 Stream.init(BufPtr, BufPtr+Buffer->getBufferSize());
Chris Lattnercaee0dc2007-04-22 06:23:29 +00001092
1093 // Sniff for the signature.
1094 if (Stream.Read(8) != 'B' ||
1095 Stream.Read(8) != 'C' ||
1096 Stream.Read(4) != 0x0 ||
1097 Stream.Read(4) != 0xC ||
1098 Stream.Read(4) != 0xE ||
1099 Stream.Read(4) != 0xD)
1100 return Error("Invalid bitcode signature");
1101
1102 // We expect a number of well-defined blocks, though we don't necessarily
1103 // need to understand them all.
1104 while (!Stream.AtEndOfStream()) {
1105 unsigned Code = Stream.ReadCode();
1106
1107 if (Code != bitc::ENTER_SUBBLOCK)
1108 return Error("Invalid record at top-level");
1109
1110 unsigned BlockID = Stream.ReadSubBlockID();
1111
1112 // We only know the MODULE subblock ID.
Chris Lattnere17b6582007-05-05 00:17:00 +00001113 switch (BlockID) {
1114 case bitc::BLOCKINFO_BLOCK_ID:
1115 if (Stream.ReadBlockInfoBlock())
1116 return Error("Malformed BlockInfoBlock");
1117 break;
1118 case bitc::MODULE_BLOCK_ID:
Chris Lattner86697142007-05-01 05:01:34 +00001119 if (ParseModule(Buffer->getBufferIdentifier()))
Chris Lattnercaee0dc2007-04-22 06:23:29 +00001120 return true;
Chris Lattnere17b6582007-05-05 00:17:00 +00001121 break;
1122 default:
1123 if (Stream.SkipBlock())
1124 return Error("Malformed block record");
1125 break;
Chris Lattnercaee0dc2007-04-22 06:23:29 +00001126 }
1127 }
1128
1129 return false;
1130}
Chris Lattnerc453f762007-04-29 07:54:31 +00001131
Chris Lattner48f84872007-05-01 04:59:48 +00001132
Chris Lattner980e5aa2007-05-01 05:52:21 +00001133/// ParseFunctionBody - Lazily parse the specified function body block.
1134bool BitcodeReader::ParseFunctionBody(Function *F) {
Chris Lattnere17b6582007-05-05 00:17:00 +00001135 if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))
Chris Lattner980e5aa2007-05-01 05:52:21 +00001136 return Error("Malformed block record");
1137
1138 unsigned ModuleValueListSize = ValueList.size();
1139
1140 // Add all the function arguments to the value table.
1141 for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I)
1142 ValueList.push_back(I);
1143
Chris Lattnera7c49aa2007-05-01 07:01:57 +00001144 unsigned NextValueNo = ValueList.size();
Chris Lattner231cbcb2007-05-02 04:27:25 +00001145 BasicBlock *CurBB = 0;
1146 unsigned CurBBNo = 0;
1147
Chris Lattner980e5aa2007-05-01 05:52:21 +00001148 // Read all the records.
1149 SmallVector<uint64_t, 64> Record;
1150 while (1) {
1151 unsigned Code = Stream.ReadCode();
1152 if (Code == bitc::END_BLOCK) {
1153 if (Stream.ReadBlockEnd())
1154 return Error("Error at end of function block");
1155 break;
1156 }
1157
1158 if (Code == bitc::ENTER_SUBBLOCK) {
1159 switch (Stream.ReadSubBlockID()) {
1160 default: // Skip unknown content.
1161 if (Stream.SkipBlock())
1162 return Error("Malformed block record");
1163 break;
1164 case bitc::CONSTANTS_BLOCK_ID:
1165 if (ParseConstants()) return true;
Chris Lattnera7c49aa2007-05-01 07:01:57 +00001166 NextValueNo = ValueList.size();
Chris Lattner980e5aa2007-05-01 05:52:21 +00001167 break;
1168 case bitc::VALUE_SYMTAB_BLOCK_ID:
1169 if (ParseValueSymbolTable()) return true;
1170 break;
1171 }
1172 continue;
1173 }
1174
1175 if (Code == bitc::DEFINE_ABBREV) {
1176 Stream.ReadAbbrevRecord();
1177 continue;
1178 }
1179
1180 // Read a record.
1181 Record.clear();
Chris Lattnera7c49aa2007-05-01 07:01:57 +00001182 Instruction *I = 0;
Chris Lattner980e5aa2007-05-01 05:52:21 +00001183 switch (Stream.ReadRecord(Code, Record)) {
Chris Lattnera7c49aa2007-05-01 07:01:57 +00001184 default: // Default behavior: reject
1185 return Error("Unknown instruction");
Chris Lattner980e5aa2007-05-01 05:52:21 +00001186 case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks]
Chris Lattnera7c49aa2007-05-01 07:01:57 +00001187 if (Record.size() < 1 || Record[0] == 0)
1188 return Error("Invalid DECLAREBLOCKS record");
Chris Lattner980e5aa2007-05-01 05:52:21 +00001189 // Create all the basic blocks for the function.
Chris Lattnerf61e6452007-05-03 22:09:51 +00001190 FunctionBBs.resize(Record[0]);
Chris Lattner980e5aa2007-05-01 05:52:21 +00001191 for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i)
1192 FunctionBBs[i] = new BasicBlock("", F);
Chris Lattnera7c49aa2007-05-01 07:01:57 +00001193 CurBB = FunctionBBs[0];
1194 continue;
1195
Chris Lattnerabfbf852007-05-06 00:21:25 +00001196 case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode]
1197 unsigned OpNum = 0;
1198 Value *LHS, *RHS;
1199 if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
1200 getValue(Record, OpNum, LHS->getType(), RHS) ||
1201 OpNum+1 != Record.size())
1202 return Error("Invalid BINOP record");
1203
1204 int Opc = GetDecodedBinaryOpcode(Record[OpNum], LHS->getType());
1205 if (Opc == -1) return Error("Invalid BINOP record");
Chris Lattnera7c49aa2007-05-01 07:01:57 +00001206 I = BinaryOperator::create((Instruction::BinaryOps)Opc, LHS, RHS);
Chris Lattner980e5aa2007-05-01 05:52:21 +00001207 break;
1208 }
Chris Lattnerabfbf852007-05-06 00:21:25 +00001209 case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc]
1210 unsigned OpNum = 0;
1211 Value *Op;
1212 if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
1213 OpNum+2 != Record.size())
1214 return Error("Invalid CAST record");
1215
1216 const Type *ResTy = getTypeByID(Record[OpNum]);
1217 int Opc = GetDecodedCastOpcode(Record[OpNum+1]);
1218 if (Opc == -1 || ResTy == 0)
Chris Lattner231cbcb2007-05-02 04:27:25 +00001219 return Error("Invalid CAST record");
1220 I = CastInst::create((Instruction::CastOps)Opc, Op, ResTy);
1221 break;
1222 }
Chris Lattner15e6d172007-05-04 19:11:41 +00001223 case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands]
Chris Lattner7337ab92007-05-06 00:00:00 +00001224 unsigned OpNum = 0;
1225 Value *BasePtr;
1226 if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr))
Chris Lattner01ff65f2007-05-02 05:16:49 +00001227 return Error("Invalid GEP record");
1228
Chris Lattnerf4c8e522007-05-02 05:46:45 +00001229 SmallVector<Value*, 16> GEPIdx;
Chris Lattner7337ab92007-05-06 00:00:00 +00001230 while (OpNum != Record.size()) {
1231 Value *Op;
1232 if (getValueTypePair(Record, OpNum, NextValueNo, Op))
Chris Lattner01ff65f2007-05-02 05:16:49 +00001233 return Error("Invalid GEP record");
Chris Lattner7337ab92007-05-06 00:00:00 +00001234 GEPIdx.push_back(Op);
Chris Lattner01ff65f2007-05-02 05:16:49 +00001235 }
1236
David Greeneb8f74792007-09-04 15:46:09 +00001237 I = new GetElementPtrInst(BasePtr, GEPIdx.begin(), GEPIdx.end());
Chris Lattner01ff65f2007-05-02 05:16:49 +00001238 break;
1239 }
Chris Lattner231cbcb2007-05-02 04:27:25 +00001240
Chris Lattnerabfbf852007-05-06 00:21:25 +00001241 case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval]
1242 unsigned OpNum = 0;
1243 Value *TrueVal, *FalseVal, *Cond;
1244 if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) ||
1245 getValue(Record, OpNum, TrueVal->getType(), FalseVal) ||
1246 getValue(Record, OpNum, Type::Int1Ty, Cond))
Chris Lattner01ff65f2007-05-02 05:16:49 +00001247 return Error("Invalid SELECT record");
Chris Lattnerabfbf852007-05-06 00:21:25 +00001248
1249 I = new SelectInst(Cond, TrueVal, FalseVal);
Chris Lattner01ff65f2007-05-02 05:16:49 +00001250 break;
1251 }
1252
1253 case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval]
Chris Lattnerabfbf852007-05-06 00:21:25 +00001254 unsigned OpNum = 0;
1255 Value *Vec, *Idx;
1256 if (getValueTypePair(Record, OpNum, NextValueNo, Vec) ||
1257 getValue(Record, OpNum, Type::Int32Ty, Idx))
Chris Lattner01ff65f2007-05-02 05:16:49 +00001258 return Error("Invalid EXTRACTELT record");
1259 I = new ExtractElementInst(Vec, Idx);
1260 break;
1261 }
1262
1263 case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval]
Chris Lattnerabfbf852007-05-06 00:21:25 +00001264 unsigned OpNum = 0;
1265 Value *Vec, *Elt, *Idx;
1266 if (getValueTypePair(Record, OpNum, NextValueNo, Vec) ||
1267 getValue(Record, OpNum,
1268 cast<VectorType>(Vec->getType())->getElementType(), Elt) ||
1269 getValue(Record, OpNum, Type::Int32Ty, Idx))
Chris Lattner01ff65f2007-05-02 05:16:49 +00001270 return Error("Invalid INSERTELT record");
1271 I = new InsertElementInst(Vec, Elt, Idx);
1272 break;
1273 }
1274
Chris Lattnerabfbf852007-05-06 00:21:25 +00001275 case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval]
1276 unsigned OpNum = 0;
1277 Value *Vec1, *Vec2, *Mask;
1278 if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) ||
1279 getValue(Record, OpNum, Vec1->getType(), Vec2))
1280 return Error("Invalid SHUFFLEVEC record");
1281
1282 const Type *MaskTy =
1283 VectorType::get(Type::Int32Ty,
1284 cast<VectorType>(Vec1->getType())->getNumElements());
1285
1286 if (getValue(Record, OpNum, MaskTy, Mask))
Chris Lattner01ff65f2007-05-02 05:16:49 +00001287 return Error("Invalid SHUFFLEVEC record");
1288 I = new ShuffleVectorInst(Vec1, Vec2, Mask);
1289 break;
1290 }
1291
1292 case bitc::FUNC_CODE_INST_CMP: { // CMP: [opty, opval, opval, pred]
Chris Lattner7337ab92007-05-06 00:00:00 +00001293 unsigned OpNum = 0;
1294 Value *LHS, *RHS;
1295 if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
1296 getValue(Record, OpNum, LHS->getType(), RHS) ||
1297 OpNum+1 != Record.size())
Chris Lattner01ff65f2007-05-02 05:16:49 +00001298 return Error("Invalid CMP record");
Chris Lattner7337ab92007-05-06 00:00:00 +00001299
1300 if (LHS->getType()->isFPOrFPVector())
1301 I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS);
Chris Lattner01ff65f2007-05-02 05:16:49 +00001302 else
Chris Lattner7337ab92007-05-06 00:00:00 +00001303 I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS);
Chris Lattner01ff65f2007-05-02 05:16:49 +00001304 break;
1305 }
1306
Chris Lattner231cbcb2007-05-02 04:27:25 +00001307 case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>]
1308 if (Record.size() == 0) {
1309 I = new ReturnInst();
1310 break;
Chris Lattner7337ab92007-05-06 00:00:00 +00001311 } else {
1312 unsigned OpNum = 0;
1313 Value *Op;
1314 if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
1315 OpNum != Record.size())
Chris Lattner2a98cca2007-05-03 18:58:09 +00001316 return Error("Invalid RET record");
Chris Lattner231cbcb2007-05-02 04:27:25 +00001317 I = new ReturnInst(Op);
1318 break;
1319 }
Chris Lattnerf4c8e522007-05-02 05:46:45 +00001320 case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#]
Chris Lattnerf61e6452007-05-03 22:09:51 +00001321 if (Record.size() != 1 && Record.size() != 3)
Chris Lattnerf4c8e522007-05-02 05:46:45 +00001322 return Error("Invalid BR record");
1323 BasicBlock *TrueDest = getBasicBlock(Record[0]);
1324 if (TrueDest == 0)
1325 return Error("Invalid BR record");
1326
1327 if (Record.size() == 1)
1328 I = new BranchInst(TrueDest);
1329 else {
1330 BasicBlock *FalseDest = getBasicBlock(Record[1]);
1331 Value *Cond = getFnValueByID(Record[2], Type::Int1Ty);
1332 if (FalseDest == 0 || Cond == 0)
1333 return Error("Invalid BR record");
1334 I = new BranchInst(TrueDest, FalseDest, Cond);
1335 }
1336 break;
1337 }
1338 case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, opval, n, n x ops]
1339 if (Record.size() < 3 || (Record.size() & 1) == 0)
1340 return Error("Invalid SWITCH record");
1341 const Type *OpTy = getTypeByID(Record[0]);
1342 Value *Cond = getFnValueByID(Record[1], OpTy);
1343 BasicBlock *Default = getBasicBlock(Record[2]);
1344 if (OpTy == 0 || Cond == 0 || Default == 0)
1345 return Error("Invalid SWITCH record");
1346 unsigned NumCases = (Record.size()-3)/2;
1347 SwitchInst *SI = new SwitchInst(Cond, Default, NumCases);
1348 for (unsigned i = 0, e = NumCases; i != e; ++i) {
1349 ConstantInt *CaseVal =
1350 dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy));
1351 BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]);
1352 if (CaseVal == 0 || DestBB == 0) {
1353 delete SI;
1354 return Error("Invalid SWITCH record!");
1355 }
1356 SI->addCase(CaseVal, DestBB);
1357 }
1358 I = SI;
1359 break;
1360 }
1361
Duncan Sandsdc024672007-11-27 13:23:08 +00001362 case bitc::FUNC_CODE_INST_INVOKE: {
1363 // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...]
Chris Lattnera9bb7132007-05-08 05:38:01 +00001364 if (Record.size() < 4) return Error("Invalid INVOKE record");
Duncan Sandsdc024672007-11-27 13:23:08 +00001365 const ParamAttrsList *PAL = getParamAttrs(Record[0]);
Chris Lattnera9bb7132007-05-08 05:38:01 +00001366 unsigned CCInfo = Record[1];
1367 BasicBlock *NormalBB = getBasicBlock(Record[2]);
1368 BasicBlock *UnwindBB = getBasicBlock(Record[3]);
Chris Lattner7337ab92007-05-06 00:00:00 +00001369
Chris Lattnera9bb7132007-05-08 05:38:01 +00001370 unsigned OpNum = 4;
Chris Lattner7337ab92007-05-06 00:00:00 +00001371 Value *Callee;
1372 if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
Chris Lattnerf4c8e522007-05-02 05:46:45 +00001373 return Error("Invalid INVOKE record");
1374
Chris Lattner7337ab92007-05-06 00:00:00 +00001375 const PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType());
1376 const FunctionType *FTy = !CalleeTy ? 0 :
Chris Lattnerf4c8e522007-05-02 05:46:45 +00001377 dyn_cast<FunctionType>(CalleeTy->getElementType());
1378
1379 // Check that the right number of fixed parameters are here.
Chris Lattner7337ab92007-05-06 00:00:00 +00001380 if (FTy == 0 || NormalBB == 0 || UnwindBB == 0 ||
1381 Record.size() < OpNum+FTy->getNumParams())
Chris Lattnerf4c8e522007-05-02 05:46:45 +00001382 return Error("Invalid INVOKE record");
Chris Lattner7337ab92007-05-06 00:00:00 +00001383
Chris Lattnerf4c8e522007-05-02 05:46:45 +00001384 SmallVector<Value*, 16> Ops;
Chris Lattner7337ab92007-05-06 00:00:00 +00001385 for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
1386 Ops.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i)));
1387 if (Ops.back() == 0) return Error("Invalid INVOKE record");
Chris Lattnerf4c8e522007-05-02 05:46:45 +00001388 }
1389
Chris Lattner7337ab92007-05-06 00:00:00 +00001390 if (!FTy->isVarArg()) {
1391 if (Record.size() != OpNum)
Chris Lattnerf4c8e522007-05-02 05:46:45 +00001392 return Error("Invalid INVOKE record");
Chris Lattnerf4c8e522007-05-02 05:46:45 +00001393 } else {
Chris Lattner7337ab92007-05-06 00:00:00 +00001394 // Read type/value pairs for varargs params.
1395 while (OpNum != Record.size()) {
1396 Value *Op;
1397 if (getValueTypePair(Record, OpNum, NextValueNo, Op))
1398 return Error("Invalid INVOKE record");
1399 Ops.push_back(Op);
1400 }
Chris Lattnerf4c8e522007-05-02 05:46:45 +00001401 }
1402
David Greenef1355a52007-08-27 19:04:21 +00001403 I = new InvokeInst(Callee, NormalBB, UnwindBB, Ops.begin(), Ops.end());
Chris Lattner76520192007-05-03 22:34:03 +00001404 cast<InvokeInst>(I)->setCallingConv(CCInfo);
Duncan Sandsdc024672007-11-27 13:23:08 +00001405 cast<InvokeInst>(I)->setParamAttrs(PAL);
Chris Lattnerf4c8e522007-05-02 05:46:45 +00001406 break;
1407 }
Chris Lattner231cbcb2007-05-02 04:27:25 +00001408 case bitc::FUNC_CODE_INST_UNWIND: // UNWIND
1409 I = new UnwindInst();
1410 break;
1411 case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE
1412 I = new UnreachableInst();
1413 break;
Chris Lattnerabfbf852007-05-06 00:21:25 +00001414 case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...]
Chris Lattner15e6d172007-05-04 19:11:41 +00001415 if (Record.size() < 1 || ((Record.size()-1)&1))
Chris Lattner2a98cca2007-05-03 18:58:09 +00001416 return Error("Invalid PHI record");
1417 const Type *Ty = getTypeByID(Record[0]);
1418 if (!Ty) return Error("Invalid PHI record");
1419
1420 PHINode *PN = new PHINode(Ty);
Chris Lattner15e6d172007-05-04 19:11:41 +00001421 PN->reserveOperandSpace(Record.size()-1);
Chris Lattner2a98cca2007-05-03 18:58:09 +00001422
Chris Lattner15e6d172007-05-04 19:11:41 +00001423 for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) {
1424 Value *V = getFnValueByID(Record[1+i], Ty);
1425 BasicBlock *BB = getBasicBlock(Record[2+i]);
Chris Lattner2a98cca2007-05-03 18:58:09 +00001426 if (!V || !BB) return Error("Invalid PHI record");
1427 PN->addIncoming(V, BB);
1428 }
1429 I = PN;
1430 break;
1431 }
1432
1433 case bitc::FUNC_CODE_INST_MALLOC: { // MALLOC: [instty, op, align]
1434 if (Record.size() < 3)
1435 return Error("Invalid MALLOC record");
1436 const PointerType *Ty =
1437 dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
1438 Value *Size = getFnValueByID(Record[1], Type::Int32Ty);
1439 unsigned Align = Record[2];
1440 if (!Ty || !Size) return Error("Invalid MALLOC record");
1441 I = new MallocInst(Ty->getElementType(), Size, (1 << Align) >> 1);
1442 break;
1443 }
Chris Lattnerabfbf852007-05-06 00:21:25 +00001444 case bitc::FUNC_CODE_INST_FREE: { // FREE: [op, opty]
1445 unsigned OpNum = 0;
1446 Value *Op;
1447 if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
1448 OpNum != Record.size())
Chris Lattner2a98cca2007-05-03 18:58:09 +00001449 return Error("Invalid FREE record");
1450 I = new FreeInst(Op);
1451 break;
1452 }
1453 case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, op, align]
1454 if (Record.size() < 3)
1455 return Error("Invalid ALLOCA record");
1456 const PointerType *Ty =
1457 dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
1458 Value *Size = getFnValueByID(Record[1], Type::Int32Ty);
1459 unsigned Align = Record[2];
1460 if (!Ty || !Size) return Error("Invalid ALLOCA record");
1461 I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1);
1462 break;
1463 }
Chris Lattner0579f7f2007-05-03 22:04:19 +00001464 case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol]
Chris Lattner7337ab92007-05-06 00:00:00 +00001465 unsigned OpNum = 0;
1466 Value *Op;
1467 if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
1468 OpNum+2 != Record.size())
Chris Lattnerabfbf852007-05-06 00:21:25 +00001469 return Error("Invalid LOAD record");
Chris Lattner7337ab92007-05-06 00:00:00 +00001470
1471 I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1);
Chris Lattnera7c49aa2007-05-01 07:01:57 +00001472 break;
Chris Lattner0579f7f2007-05-03 22:04:19 +00001473 }
Chris Lattnerabfbf852007-05-06 00:21:25 +00001474 case bitc::FUNC_CODE_INST_STORE: { // STORE:[val, valty, ptr, align, vol]
1475 unsigned OpNum = 0;
1476 Value *Val, *Ptr;
1477 if (getValueTypePair(Record, OpNum, NextValueNo, Val) ||
1478 getValue(Record, OpNum, PointerType::get(Val->getType()), Ptr) ||
1479 OpNum+2 != Record.size())
Chris Lattner0579f7f2007-05-03 22:04:19 +00001480 return Error("Invalid STORE record");
Chris Lattnerabfbf852007-05-06 00:21:25 +00001481
1482 I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1);
Chris Lattner0579f7f2007-05-03 22:04:19 +00001483 break;
1484 }
Duncan Sandsdc024672007-11-27 13:23:08 +00001485 case bitc::FUNC_CODE_INST_CALL: {
1486 // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...]
1487 if (Record.size() < 3)
Chris Lattner0579f7f2007-05-03 22:04:19 +00001488 return Error("Invalid CALL record");
Chris Lattner7337ab92007-05-06 00:00:00 +00001489
Duncan Sandsdc024672007-11-27 13:23:08 +00001490 const ParamAttrsList *PAL = getParamAttrs(Record[0]);
Chris Lattnera9bb7132007-05-08 05:38:01 +00001491 unsigned CCInfo = Record[1];
1492
1493 unsigned OpNum = 2;
Chris Lattner7337ab92007-05-06 00:00:00 +00001494 Value *Callee;
1495 if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
1496 return Error("Invalid CALL record");
1497
1498 const PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
Chris Lattner0579f7f2007-05-03 22:04:19 +00001499 const FunctionType *FTy = 0;
1500 if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType());
Chris Lattner7337ab92007-05-06 00:00:00 +00001501 if (!FTy || Record.size() < FTy->getNumParams()+OpNum)
Chris Lattner0579f7f2007-05-03 22:04:19 +00001502 return Error("Invalid CALL record");
1503
1504 SmallVector<Value*, 16> Args;
1505 // Read the fixed params.
Chris Lattner7337ab92007-05-06 00:00:00 +00001506 for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
Dale Johanneseneb57ea72007-11-05 21:20:28 +00001507 if (FTy->getParamType(i)->getTypeID()==Type::LabelTyID)
1508 Args.push_back(getBasicBlock(Record[OpNum]));
1509 else
1510 Args.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i)));
Chris Lattner0579f7f2007-05-03 22:04:19 +00001511 if (Args.back() == 0) return Error("Invalid CALL record");
1512 }
1513
Chris Lattner0579f7f2007-05-03 22:04:19 +00001514 // Read type/value pairs for varargs params.
Chris Lattner0579f7f2007-05-03 22:04:19 +00001515 if (!FTy->isVarArg()) {
Chris Lattner7337ab92007-05-06 00:00:00 +00001516 if (OpNum != Record.size())
Chris Lattner0579f7f2007-05-03 22:04:19 +00001517 return Error("Invalid CALL record");
1518 } else {
Chris Lattner7337ab92007-05-06 00:00:00 +00001519 while (OpNum != Record.size()) {
1520 Value *Op;
1521 if (getValueTypePair(Record, OpNum, NextValueNo, Op))
1522 return Error("Invalid CALL record");
1523 Args.push_back(Op);
Chris Lattner0579f7f2007-05-03 22:04:19 +00001524 }
1525 }
1526
David Greene52eec542007-08-01 03:43:44 +00001527 I = new CallInst(Callee, Args.begin(), Args.end());
Chris Lattner76520192007-05-03 22:34:03 +00001528 cast<CallInst>(I)->setCallingConv(CCInfo>>1);
1529 cast<CallInst>(I)->setTailCall(CCInfo & 1);
Duncan Sandsdc024672007-11-27 13:23:08 +00001530 cast<CallInst>(I)->setParamAttrs(PAL);
Chris Lattner0579f7f2007-05-03 22:04:19 +00001531 break;
1532 }
1533 case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty]
1534 if (Record.size() < 3)
1535 return Error("Invalid VAARG record");
1536 const Type *OpTy = getTypeByID(Record[0]);
1537 Value *Op = getFnValueByID(Record[1], OpTy);
1538 const Type *ResTy = getTypeByID(Record[2]);
1539 if (!OpTy || !Op || !ResTy)
1540 return Error("Invalid VAARG record");
1541 I = new VAArgInst(Op, ResTy);
1542 break;
1543 }
Chris Lattnera7c49aa2007-05-01 07:01:57 +00001544 }
1545
1546 // Add instruction to end of current BB. If there is no current BB, reject
1547 // this file.
1548 if (CurBB == 0) {
1549 delete I;
1550 return Error("Invalid instruction with no BB");
1551 }
1552 CurBB->getInstList().push_back(I);
1553
1554 // If this was a terminator instruction, move to the next block.
1555 if (isa<TerminatorInst>(I)) {
1556 ++CurBBNo;
1557 CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0;
1558 }
1559
1560 // Non-void values get registered in the value table for future use.
1561 if (I && I->getType() != Type::VoidTy)
1562 ValueList.AssignValue(I, NextValueNo++);
Chris Lattner980e5aa2007-05-01 05:52:21 +00001563 }
1564
Chris Lattnera7c49aa2007-05-01 07:01:57 +00001565 // Check the function list for unresolved values.
1566 if (Argument *A = dyn_cast<Argument>(ValueList.back())) {
1567 if (A->getParent() == 0) {
1568 // We found at least one unresolved value. Nuke them all to avoid leaks.
1569 for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){
1570 if ((A = dyn_cast<Argument>(ValueList.back())) && A->getParent() == 0) {
1571 A->replaceAllUsesWith(UndefValue::get(A->getType()));
1572 delete A;
1573 }
1574 }
Chris Lattner35a04702007-05-04 03:50:29 +00001575 return Error("Never resolved value found in function!");
Chris Lattnera7c49aa2007-05-01 07:01:57 +00001576 }
Chris Lattnera7c49aa2007-05-01 07:01:57 +00001577 }
Chris Lattner980e5aa2007-05-01 05:52:21 +00001578
1579 // Trim the value list down to the size it was before we parsed this function.
1580 ValueList.shrinkTo(ModuleValueListSize);
1581 std::vector<BasicBlock*>().swap(FunctionBBs);
1582
Chris Lattner48f84872007-05-01 04:59:48 +00001583 return false;
1584}
1585
Chris Lattnerb348bb82007-05-18 04:02:46 +00001586//===----------------------------------------------------------------------===//
1587// ModuleProvider implementation
1588//===----------------------------------------------------------------------===//
1589
1590
1591bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo) {
1592 // If it already is material, ignore the request.
Gabor Greifa99be512007-07-05 17:07:56 +00001593 if (!F->hasNotBeenReadFromBitcode()) return false;
Chris Lattnerb348bb82007-05-18 04:02:46 +00001594
1595 DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator DFII =
1596 DeferredFunctionInfo.find(F);
1597 assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!");
1598
1599 // Move the bit stream to the saved position of the deferred function body and
1600 // restore the real linkage type for the function.
1601 Stream.JumpToBit(DFII->second.first);
1602 F->setLinkage((GlobalValue::LinkageTypes)DFII->second.second);
1603
1604 if (ParseFunctionBody(F)) {
1605 if (ErrInfo) *ErrInfo = ErrorString;
1606 return true;
1607 }
Chandler Carruth69940402007-08-04 01:51:18 +00001608
1609 // Upgrade any old intrinsic calls in the function.
1610 for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(),
1611 E = UpgradedIntrinsics.end(); I != E; ++I) {
1612 if (I->first != I->second) {
1613 for (Value::use_iterator UI = I->first->use_begin(),
1614 UE = I->first->use_end(); UI != UE; ) {
1615 if (CallInst* CI = dyn_cast<CallInst>(*UI++))
1616 UpgradeIntrinsicCall(CI, I->second);
1617 }
1618 }
1619 }
Chris Lattnerb348bb82007-05-18 04:02:46 +00001620
1621 return false;
1622}
1623
1624void BitcodeReader::dematerializeFunction(Function *F) {
1625 // If this function isn't materialized, or if it is a proto, this is a noop.
Gabor Greifa99be512007-07-05 17:07:56 +00001626 if (F->hasNotBeenReadFromBitcode() || F->isDeclaration())
Chris Lattnerb348bb82007-05-18 04:02:46 +00001627 return;
1628
1629 assert(DeferredFunctionInfo.count(F) && "No info to read function later?");
1630
1631 // Just forget the function body, we can remat it later.
1632 F->deleteBody();
1633 F->setLinkage(GlobalValue::GhostLinkage);
1634}
1635
1636
1637Module *BitcodeReader::materializeModule(std::string *ErrInfo) {
1638 for (DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator I =
1639 DeferredFunctionInfo.begin(), E = DeferredFunctionInfo.end(); I != E;
1640 ++I) {
1641 Function *F = I->first;
Gabor Greifa99be512007-07-05 17:07:56 +00001642 if (F->hasNotBeenReadFromBitcode() &&
Chris Lattnerb348bb82007-05-18 04:02:46 +00001643 materializeFunction(F, ErrInfo))
1644 return 0;
1645 }
Chandler Carruth69940402007-08-04 01:51:18 +00001646
1647 // Upgrade any intrinsic calls that slipped through (should not happen!) and
1648 // delete the old functions to clean up. We can't do this unless the entire
1649 // module is materialized because there could always be another function body
1650 // with calls to the old function.
1651 for (std::vector<std::pair<Function*, Function*> >::iterator I =
1652 UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) {
1653 if (I->first != I->second) {
1654 for (Value::use_iterator UI = I->first->use_begin(),
1655 UE = I->first->use_end(); UI != UE; ) {
1656 if (CallInst* CI = dyn_cast<CallInst>(*UI++))
1657 UpgradeIntrinsicCall(CI, I->second);
1658 }
1659 ValueList.replaceUsesOfWith(I->first, I->second);
1660 I->first->eraseFromParent();
1661 }
1662 }
1663 std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics);
1664
Chris Lattnerb348bb82007-05-18 04:02:46 +00001665 return TheModule;
1666}
1667
1668
1669/// This method is provided by the parent ModuleProvde class and overriden
1670/// here. It simply releases the module from its provided and frees up our
1671/// state.
1672/// @brief Release our hold on the generated module
1673Module *BitcodeReader::releaseModule(std::string *ErrInfo) {
1674 // Since we're losing control of this Module, we must hand it back complete
1675 Module *M = ModuleProvider::releaseModule(ErrInfo);
1676 FreeState();
1677 return M;
1678}
1679
Chris Lattner48f84872007-05-01 04:59:48 +00001680
Chris Lattnerc453f762007-04-29 07:54:31 +00001681//===----------------------------------------------------------------------===//
1682// External interface
1683//===----------------------------------------------------------------------===//
1684
1685/// getBitcodeModuleProvider - lazy function-at-a-time loading from a file.
1686///
1687ModuleProvider *llvm::getBitcodeModuleProvider(MemoryBuffer *Buffer,
1688 std::string *ErrMsg) {
1689 BitcodeReader *R = new BitcodeReader(Buffer);
1690 if (R->ParseBitcode()) {
1691 if (ErrMsg)
1692 *ErrMsg = R->getErrorString();
1693
1694 // Don't let the BitcodeReader dtor delete 'Buffer'.
1695 R->releaseMemoryBuffer();
1696 delete R;
1697 return 0;
1698 }
1699 return R;
1700}
1701
1702/// ParseBitcodeFile - Read the specified bitcode file, returning the module.
1703/// If an error occurs, return null and fill in *ErrMsg if non-null.
1704Module *llvm::ParseBitcodeFile(MemoryBuffer *Buffer, std::string *ErrMsg){
1705 BitcodeReader *R;
1706 R = static_cast<BitcodeReader*>(getBitcodeModuleProvider(Buffer, ErrMsg));
1707 if (!R) return 0;
1708
Chris Lattnerb348bb82007-05-18 04:02:46 +00001709 // Read in the entire module.
1710 Module *M = R->materializeModule(ErrMsg);
1711
1712 // Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether
1713 // there was an error.
Chris Lattnerc453f762007-04-29 07:54:31 +00001714 R->releaseMemoryBuffer();
Chris Lattnerb348bb82007-05-18 04:02:46 +00001715
1716 // If there was no error, tell ModuleProvider not to delete it when its dtor
1717 // is run.
1718 if (M)
1719 M = R->releaseModule(ErrMsg);
1720
Chris Lattnerc453f762007-04-29 07:54:31 +00001721 delete R;
1722 return M;
1723}