1 //===- 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 
14 #include "BitcodeReader.h"
15 #include "llvm/Bitcode/BitstreamReader.h"
16 #include "llvm/Constants.h"
17 #include "llvm/DerivedTypes.h"
18 #include "llvm/Module.h"
19 #include "llvm/ADT/SmallString.h"
20 #include "llvm/Support/MathExtras.h"
21 using namespace llvm;
22 
23 /// ConvertToString - Convert a string from a record into an std::string, return
24 /// true on failure.
25 template<typename StrTy>
26 static bool ConvertToString(SmallVector<uint64_t, 64> &Record, unsigned Idx,
27                             StrTy &Result) {
28   if (Record.size() < Idx+1 || Record.size() < Record[Idx]+Idx+1)
29     return true;
30 
31   for (unsigned i = 0, e = Record[Idx]; i != e; ++i)
32     Result += (char)Record[Idx+i+1];
33   return false;
34 }
35 
36 static GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) {
37   switch (Val) {
38   default: // Map unknown/new linkages to external
39   case 0: return GlobalValue::ExternalLinkage;
40   case 1: return GlobalValue::WeakLinkage;
41   case 2: return GlobalValue::AppendingLinkage;
42   case 3: return GlobalValue::InternalLinkage;
43   case 4: return GlobalValue::LinkOnceLinkage;
44   case 5: return GlobalValue::DLLImportLinkage;
45   case 6: return GlobalValue::DLLExportLinkage;
46   case 7: return GlobalValue::ExternalWeakLinkage;
47   }
48 }
49 
50 static GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) {
51   switch (Val) {
52   default: // Map unknown visibilities to default.
53   case 0: return GlobalValue::DefaultVisibility;
54   case 1: return GlobalValue::HiddenVisibility;
55   }
56 }
57 
58 static int GetDecodedCastOpcode(unsigned Val) {
59   switch (Val) {
60   default: return -1;
61   case bitc::CAST_TRUNC   : return Instruction::Trunc;
62   case bitc::CAST_ZEXT    : return Instruction::ZExt;
63   case bitc::CAST_SEXT    : return Instruction::SExt;
64   case bitc::CAST_FPTOUI  : return Instruction::FPToUI;
65   case bitc::CAST_FPTOSI  : return Instruction::FPToSI;
66   case bitc::CAST_UITOFP  : return Instruction::UIToFP;
67   case bitc::CAST_SITOFP  : return Instruction::SIToFP;
68   case bitc::CAST_FPTRUNC : return Instruction::FPTrunc;
69   case bitc::CAST_FPEXT   : return Instruction::FPExt;
70   case bitc::CAST_PTRTOINT: return Instruction::PtrToInt;
71   case bitc::CAST_INTTOPTR: return Instruction::IntToPtr;
72   case bitc::CAST_BITCAST : return Instruction::BitCast;
73   }
74 }
75 static int GetDecodedBinaryOpcode(unsigned Val, const Type *Ty) {
76   switch (Val) {
77   default: return -1;
78   case bitc::BINOP_ADD:  return Instruction::Add;
79   case bitc::BINOP_SUB:  return Instruction::Sub;
80   case bitc::BINOP_MUL:  return Instruction::Mul;
81   case bitc::BINOP_UDIV: return Instruction::UDiv;
82   case bitc::BINOP_SDIV:
83     return Ty->isFPOrFPVector() ? Instruction::FDiv : Instruction::SDiv;
84   case bitc::BINOP_UREM: return Instruction::URem;
85   case bitc::BINOP_SREM:
86     return Ty->isFPOrFPVector() ? Instruction::FRem : Instruction::SRem;
87   case bitc::BINOP_SHL:  return Instruction::Shl;
88   case bitc::BINOP_LSHR: return Instruction::LShr;
89   case bitc::BINOP_ASHR: return Instruction::AShr;
90   case bitc::BINOP_AND:  return Instruction::And;
91   case bitc::BINOP_OR:   return Instruction::Or;
92   case bitc::BINOP_XOR:  return Instruction::Xor;
93   }
94 }
95 
96 
97 namespace {
98   /// @brief A class for maintaining the slot number definition
99   /// as a placeholder for the actual definition for forward constants defs.
100   class ConstantPlaceHolder : public ConstantExpr {
101     ConstantPlaceHolder();                       // DO NOT IMPLEMENT
102     void operator=(const ConstantPlaceHolder &); // DO NOT IMPLEMENT
103   public:
104     Use Op;
105     ConstantPlaceHolder(const Type *Ty)
106       : ConstantExpr(Ty, Instruction::UserOp1, &Op, 1),
107         Op(UndefValue::get(Type::Int32Ty), this) {
108     }
109   };
110 }
111 
112 Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx,
113                                                     const Type *Ty) {
114   if (Idx >= size()) {
115     // Insert a bunch of null values.
116     Uses.resize(Idx+1);
117     OperandList = &Uses[0];
118     NumOperands = Idx+1;
119   }
120 
121   if (Uses[Idx]) {
122     assert(Ty == getOperand(Idx)->getType() &&
123            "Type mismatch in constant table!");
124     return cast<Constant>(getOperand(Idx));
125   }
126 
127   // Create and return a placeholder, which will later be RAUW'd.
128   Constant *C = new ConstantPlaceHolder(Ty);
129   Uses[Idx].init(C, this);
130   return C;
131 }
132 
133 
134 const Type *BitcodeReader::getTypeByID(unsigned ID, bool isTypeTable) {
135   // If the TypeID is in range, return it.
136   if (ID < TypeList.size())
137     return TypeList[ID].get();
138   if (!isTypeTable) return 0;
139 
140   // The type table allows forward references.  Push as many Opaque types as
141   // needed to get up to ID.
142   while (TypeList.size() <= ID)
143     TypeList.push_back(OpaqueType::get());
144   return TypeList.back().get();
145 }
146 
147 
148 bool BitcodeReader::ParseTypeTable(BitstreamReader &Stream) {
149   if (Stream.EnterSubBlock())
150     return Error("Malformed block record");
151 
152   if (!TypeList.empty())
153     return Error("Multiple TYPE_BLOCKs found!");
154 
155   SmallVector<uint64_t, 64> Record;
156   unsigned NumRecords = 0;
157 
158   // Read all the records for this type table.
159   while (1) {
160     unsigned Code = Stream.ReadCode();
161     if (Code == bitc::END_BLOCK) {
162       if (NumRecords != TypeList.size())
163         return Error("Invalid type forward reference in TYPE_BLOCK");
164       if (Stream.ReadBlockEnd())
165         return Error("Error at end of type table block");
166       return false;
167     }
168 
169     if (Code == bitc::ENTER_SUBBLOCK) {
170       // No known subblocks, always skip them.
171       Stream.ReadSubBlockID();
172       if (Stream.SkipBlock())
173         return Error("Malformed block record");
174       continue;
175     }
176 
177     if (Code == bitc::DEFINE_ABBREV) {
178       Stream.ReadAbbrevRecord();
179       continue;
180     }
181 
182     // Read a record.
183     Record.clear();
184     const Type *ResultTy = 0;
185     switch (Stream.ReadRecord(Code, Record)) {
186     default:  // Default behavior: unknown type.
187       ResultTy = 0;
188       break;
189     case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries]
190       // TYPE_CODE_NUMENTRY contains a count of the number of types in the
191       // type list.  This allows us to reserve space.
192       if (Record.size() < 1)
193         return Error("Invalid TYPE_CODE_NUMENTRY record");
194       TypeList.reserve(Record[0]);
195       continue;
196     case bitc::TYPE_CODE_META:      // TYPE_CODE_META: [metacode]...
197       // No metadata supported yet.
198       if (Record.size() < 1)
199         return Error("Invalid TYPE_CODE_META record");
200       continue;
201 
202     case bitc::TYPE_CODE_VOID:      // VOID
203       ResultTy = Type::VoidTy;
204       break;
205     case bitc::TYPE_CODE_FLOAT:     // FLOAT
206       ResultTy = Type::FloatTy;
207       break;
208     case bitc::TYPE_CODE_DOUBLE:    // DOUBLE
209       ResultTy = Type::DoubleTy;
210       break;
211     case bitc::TYPE_CODE_LABEL:     // LABEL
212       ResultTy = Type::LabelTy;
213       break;
214     case bitc::TYPE_CODE_OPAQUE:    // OPAQUE
215       ResultTy = 0;
216       break;
217     case bitc::TYPE_CODE_INTEGER:   // INTEGER: [width]
218       if (Record.size() < 1)
219         return Error("Invalid Integer type record");
220 
221       ResultTy = IntegerType::get(Record[0]);
222       break;
223     case bitc::TYPE_CODE_POINTER:   // POINTER: [pointee type]
224       if (Record.size() < 1)
225         return Error("Invalid POINTER type record");
226       ResultTy = PointerType::get(getTypeByID(Record[0], true));
227       break;
228     case bitc::TYPE_CODE_FUNCTION: {
229       // FUNCTION: [vararg, retty, #pararms, paramty N]
230       if (Record.size() < 3 || Record.size() < Record[2]+3)
231         return Error("Invalid FUNCTION type record");
232       std::vector<const Type*> ArgTys;
233       for (unsigned i = 0, e = Record[2]; i != e; ++i)
234         ArgTys.push_back(getTypeByID(Record[3+i], true));
235 
236       // FIXME: PARAM TYS.
237       ResultTy = FunctionType::get(getTypeByID(Record[1], true), ArgTys,
238                                    Record[0]);
239       break;
240     }
241     case bitc::TYPE_CODE_STRUCT: {  // STRUCT: [ispacked, #elts, eltty x N]
242       if (Record.size() < 2 || Record.size() < Record[1]+2)
243         return Error("Invalid STRUCT type record");
244       std::vector<const Type*> EltTys;
245       for (unsigned i = 0, e = Record[1]; i != e; ++i)
246         EltTys.push_back(getTypeByID(Record[2+i], true));
247       ResultTy = StructType::get(EltTys, Record[0]);
248       break;
249     }
250     case bitc::TYPE_CODE_ARRAY:     // ARRAY: [numelts, eltty]
251       if (Record.size() < 2)
252         return Error("Invalid ARRAY type record");
253       ResultTy = ArrayType::get(getTypeByID(Record[1], true), Record[0]);
254       break;
255     case bitc::TYPE_CODE_VECTOR:    // VECTOR: [numelts, eltty]
256       if (Record.size() < 2)
257         return Error("Invalid VECTOR type record");
258       ResultTy = VectorType::get(getTypeByID(Record[1], true), Record[0]);
259       break;
260     }
261 
262     if (NumRecords == TypeList.size()) {
263       // If this is a new type slot, just append it.
264       TypeList.push_back(ResultTy ? ResultTy : OpaqueType::get());
265       ++NumRecords;
266     } else if (ResultTy == 0) {
267       // Otherwise, this was forward referenced, so an opaque type was created,
268       // but the result type is actually just an opaque.  Leave the one we
269       // created previously.
270       ++NumRecords;
271     } else {
272       // Otherwise, this was forward referenced, so an opaque type was created.
273       // Resolve the opaque type to the real type now.
274       assert(NumRecords < TypeList.size() && "Typelist imbalance");
275       const OpaqueType *OldTy = cast<OpaqueType>(TypeList[NumRecords++].get());
276 
277       // Don't directly push the new type on the Tab. Instead we want to replace
278       // the opaque type we previously inserted with the new concrete value. The
279       // refinement from the abstract (opaque) type to the new type causes all
280       // uses of the abstract type to use the concrete type (NewTy). This will
281       // also cause the opaque type to be deleted.
282       const_cast<OpaqueType*>(OldTy)->refineAbstractTypeTo(ResultTy);
283 
284       // This should have replaced the old opaque type with the new type in the
285       // value table... or with a preexisting type that was already in the
286       // system.  Let's just make sure it did.
287       assert(TypeList[NumRecords-1].get() != OldTy &&
288              "refineAbstractType didn't work!");
289     }
290   }
291 }
292 
293 
294 bool BitcodeReader::ParseTypeSymbolTable(BitstreamReader &Stream) {
295   if (Stream.EnterSubBlock())
296     return Error("Malformed block record");
297 
298   SmallVector<uint64_t, 64> Record;
299 
300   // Read all the records for this type table.
301   std::string TypeName;
302   while (1) {
303     unsigned Code = Stream.ReadCode();
304     if (Code == bitc::END_BLOCK) {
305       if (Stream.ReadBlockEnd())
306         return Error("Error at end of type symbol table block");
307       return false;
308     }
309 
310     if (Code == bitc::ENTER_SUBBLOCK) {
311       // No known subblocks, always skip them.
312       Stream.ReadSubBlockID();
313       if (Stream.SkipBlock())
314         return Error("Malformed block record");
315       continue;
316     }
317 
318     if (Code == bitc::DEFINE_ABBREV) {
319       Stream.ReadAbbrevRecord();
320       continue;
321     }
322 
323     // Read a record.
324     Record.clear();
325     switch (Stream.ReadRecord(Code, Record)) {
326     default:  // Default behavior: unknown type.
327       break;
328     case bitc::TST_CODE_ENTRY:    // TST_ENTRY: [typeid, namelen, namechar x N]
329       if (ConvertToString(Record, 1, TypeName))
330         return Error("Invalid TST_ENTRY record");
331       unsigned TypeID = Record[0];
332       if (TypeID >= TypeList.size())
333         return Error("Invalid Type ID in TST_ENTRY record");
334 
335       TheModule->addTypeName(TypeName, TypeList[TypeID].get());
336       TypeName.clear();
337       break;
338     }
339   }
340 }
341 
342 bool BitcodeReader::ParseValueSymbolTable(BitstreamReader &Stream) {
343   if (Stream.EnterSubBlock())
344     return Error("Malformed block record");
345 
346   SmallVector<uint64_t, 64> Record;
347 
348   // Read all the records for this value table.
349   SmallString<128> ValueName;
350   while (1) {
351     unsigned Code = Stream.ReadCode();
352     if (Code == bitc::END_BLOCK) {
353       if (Stream.ReadBlockEnd())
354         return Error("Error at end of value symbol table block");
355       return false;
356     }
357     if (Code == bitc::ENTER_SUBBLOCK) {
358       // No known subblocks, always skip them.
359       Stream.ReadSubBlockID();
360       if (Stream.SkipBlock())
361         return Error("Malformed block record");
362       continue;
363     }
364 
365     if (Code == bitc::DEFINE_ABBREV) {
366       Stream.ReadAbbrevRecord();
367       continue;
368     }
369 
370     // Read a record.
371     Record.clear();
372     switch (Stream.ReadRecord(Code, Record)) {
373     default:  // Default behavior: unknown type.
374       break;
375     case bitc::TST_CODE_ENTRY:    // VST_ENTRY: [valueid, namelen, namechar x N]
376       if (ConvertToString(Record, 1, ValueName))
377         return Error("Invalid TST_ENTRY record");
378       unsigned ValueID = Record[0];
379       if (ValueID >= ValueList.size())
380         return Error("Invalid Value ID in VST_ENTRY record");
381       Value *V = ValueList[ValueID];
382 
383       V->setName(&ValueName[0], ValueName.size());
384       ValueName.clear();
385       break;
386     }
387   }
388 }
389 
390 /// DecodeSignRotatedValue - Decode a signed value stored with the sign bit in
391 /// the LSB for dense VBR encoding.
392 static uint64_t DecodeSignRotatedValue(uint64_t V) {
393   if ((V & 1) == 0)
394     return V >> 1;
395   if (V != 1)
396     return -(V >> 1);
397   // There is no such thing as -0 with integers.  "-0" really means MININT.
398   return 1ULL << 63;
399 }
400 
401 bool BitcodeReader::ParseConstants(BitstreamReader &Stream) {
402   if (Stream.EnterSubBlock())
403     return Error("Malformed block record");
404 
405   SmallVector<uint64_t, 64> Record;
406 
407   // Read all the records for this value table.
408   const Type *CurTy = Type::Int32Ty;
409   unsigned NextCstNo = ValueList.size();
410   while (1) {
411     unsigned Code = Stream.ReadCode();
412     if (Code == bitc::END_BLOCK) {
413       // If there are global var inits to process, do so now.
414       if (!GlobalInits.empty()) {
415         while (!GlobalInits.empty()) {
416           unsigned ValID = GlobalInits.back().second;
417           if (ValID >= ValueList.size())
418             return Error("Invalid value ID for global var init!");
419           if (Constant *C = dyn_cast<Constant>(ValueList[ValID]))
420             GlobalInits.back().first->setInitializer(C);
421           else
422             return Error("Global variable initializer is not a constant!");
423           GlobalInits.pop_back();
424         }
425       }
426 
427       if (NextCstNo != ValueList.size())
428         return Error("Invalid constant reference!");
429 
430       if (Stream.ReadBlockEnd())
431         return Error("Error at end of constants block");
432       return false;
433     }
434 
435     if (Code == bitc::ENTER_SUBBLOCK) {
436       // No known subblocks, always skip them.
437       Stream.ReadSubBlockID();
438       if (Stream.SkipBlock())
439         return Error("Malformed block record");
440       continue;
441     }
442 
443     if (Code == bitc::DEFINE_ABBREV) {
444       Stream.ReadAbbrevRecord();
445       continue;
446     }
447 
448     // Read a record.
449     Record.clear();
450     Value *V = 0;
451     switch (Stream.ReadRecord(Code, Record)) {
452     default:  // Default behavior: unknown constant
453     case bitc::CST_CODE_UNDEF:     // UNDEF
454       V = UndefValue::get(CurTy);
455       break;
456     case bitc::CST_CODE_SETTYPE:   // SETTYPE: [typeid]
457       if (Record.empty())
458         return Error("Malformed CST_SETTYPE record");
459       if (Record[0] >= TypeList.size())
460         return Error("Invalid Type ID in CST_SETTYPE record");
461       CurTy = TypeList[Record[0]];
462       continue;  // Skip the ValueList manipulation.
463     case bitc::CST_CODE_NULL:      // NULL
464       V = Constant::getNullValue(CurTy);
465       break;
466     case bitc::CST_CODE_INTEGER:   // INTEGER: [intval]
467       if (!isa<IntegerType>(CurTy) || Record.empty())
468         return Error("Invalid CST_INTEGER record");
469       V = ConstantInt::get(CurTy, DecodeSignRotatedValue(Record[0]));
470       break;
471     case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n, n x intval]
472       if (!isa<IntegerType>(CurTy) || Record.empty() ||
473           Record.size() < Record[0]+1)
474         return Error("Invalid WIDE_INTEGER record");
475 
476       unsigned NumWords = Record[0];
477       SmallVector<uint64_t, 8> Words;
478       Words.resize(NumWords);
479       for (unsigned i = 0; i != NumWords; ++i)
480         Words[i] = DecodeSignRotatedValue(Record[i+1]);
481       V = ConstantInt::get(APInt(cast<IntegerType>(CurTy)->getBitWidth(),
482                                  NumWords, &Words[0]));
483       break;
484     }
485     case bitc::CST_CODE_FLOAT:     // FLOAT: [fpval]
486       if (Record.empty())
487         return Error("Invalid FLOAT record");
488       if (CurTy == Type::FloatTy)
489         V = ConstantFP::get(CurTy, BitsToFloat(Record[0]));
490       else if (CurTy == Type::DoubleTy)
491         V = ConstantFP::get(CurTy, BitsToDouble(Record[0]));
492       else
493         V = UndefValue::get(CurTy);
494       break;
495 
496     case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n, n x value number]
497       if (Record.empty() || Record.size() < Record[0]+1)
498         return Error("Invalid CST_AGGREGATE record");
499 
500       unsigned Size = Record[0];
501       std::vector<Constant*> Elts;
502 
503       if (const StructType *STy = dyn_cast<StructType>(CurTy)) {
504         for (unsigned i = 0; i != Size; ++i)
505           Elts.push_back(ValueList.getConstantFwdRef(Record[i+1],
506                                                      STy->getElementType(i)));
507         V = ConstantStruct::get(STy, Elts);
508       } else if (const ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) {
509         const Type *EltTy = ATy->getElementType();
510         for (unsigned i = 0; i != Size; ++i)
511           Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], EltTy));
512         V = ConstantArray::get(ATy, Elts);
513       } else if (const VectorType *VTy = dyn_cast<VectorType>(CurTy)) {
514         const Type *EltTy = VTy->getElementType();
515         for (unsigned i = 0; i != Size; ++i)
516           Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], EltTy));
517         V = ConstantVector::get(Elts);
518       } else {
519         V = UndefValue::get(CurTy);
520       }
521       break;
522     }
523 
524     case bitc::CST_CODE_CE_BINOP: {  // CE_BINOP: [opcode, opval, opval]
525       if (Record.size() < 3) return Error("Invalid CE_BINOP record");
526       int Opc = GetDecodedBinaryOpcode(Record[0], CurTy);
527       if (Opc < 0) {
528         V = UndefValue::get(CurTy);  // Unknown binop.
529       } else {
530         Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy);
531         Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy);
532         V = ConstantExpr::get(Opc, LHS, RHS);
533       }
534       break;
535     }
536     case bitc::CST_CODE_CE_CAST: {  // CE_CAST: [opcode, opty, opval]
537       if (Record.size() < 3) return Error("Invalid CE_CAST record");
538       int Opc = GetDecodedCastOpcode(Record[0]);
539       if (Opc < 0) {
540         V = UndefValue::get(CurTy);  // Unknown cast.
541       } else {
542         const Type *OpTy = getTypeByID(Record[1]);
543         Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy);
544         V = ConstantExpr::getCast(Opc, Op, CurTy);
545       }
546       break;
547     }
548     case bitc::CST_CODE_CE_GEP: {  // CE_GEP:        [n x operands]
549       if ((Record.size() & 1) == 0) return Error("Invalid CE_GEP record");
550       SmallVector<Constant*, 16> Elts;
551       for (unsigned i = 1, e = Record.size(); i != e; i += 2) {
552         const Type *ElTy = getTypeByID(Record[i]);
553         if (!ElTy) return Error("Invalid CE_GEP record");
554         Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy));
555       }
556       V = ConstantExpr::getGetElementPtr(Elts[0], &Elts[1], Elts.size()-1);
557       break;
558     }
559     case bitc::CST_CODE_CE_SELECT:  // CE_SELECT: [opval#, opval#, opval#]
560       if (Record.size() < 3) return Error("Invalid CE_SELECT record");
561       V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0],
562                                                               Type::Int1Ty),
563                                   ValueList.getConstantFwdRef(Record[1],CurTy),
564                                   ValueList.getConstantFwdRef(Record[2],CurTy));
565       break;
566     case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval]
567       if (Record.size() < 3) return Error("Invalid CE_EXTRACTELT record");
568       const VectorType *OpTy =
569         dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
570       if (OpTy == 0) return Error("Invalid CE_EXTRACTELT record");
571       Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
572       Constant *Op1 = ValueList.getConstantFwdRef(Record[2],
573                                                   OpTy->getElementType());
574       V = ConstantExpr::getExtractElement(Op0, Op1);
575       break;
576     }
577     case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval]
578       const VectorType *OpTy = dyn_cast<VectorType>(CurTy);
579       if (Record.size() < 3 || OpTy == 0)
580         return Error("Invalid CE_INSERTELT record");
581       Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
582       Constant *Op1 = ValueList.getConstantFwdRef(Record[1],
583                                                   OpTy->getElementType());
584       Constant *Op2 = ValueList.getConstantFwdRef(Record[2], Type::Int32Ty);
585       V = ConstantExpr::getInsertElement(Op0, Op1, Op2);
586       break;
587     }
588     case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval]
589       const VectorType *OpTy = dyn_cast<VectorType>(CurTy);
590       if (Record.size() < 3 || OpTy == 0)
591         return Error("Invalid CE_INSERTELT record");
592       Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
593       Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy);
594       const Type *ShufTy=VectorType::get(Type::Int32Ty, OpTy->getNumElements());
595       Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy);
596       V = ConstantExpr::getShuffleVector(Op0, Op1, Op2);
597       break;
598     }
599     case bitc::CST_CODE_CE_CMP: {     // CE_CMP: [opty, opval, opval, pred]
600       if (Record.size() < 4) return Error("Invalid CE_CMP record");
601       const Type *OpTy = getTypeByID(Record[0]);
602       if (OpTy == 0) return Error("Invalid CE_CMP record");
603       Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
604       Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
605 
606       if (OpTy->isFloatingPoint())
607         V = ConstantExpr::getFCmp(Record[3], Op0, Op1);
608       else
609         V = ConstantExpr::getICmp(Record[3], Op0, Op1);
610       break;
611     }
612     }
613 
614     if (NextCstNo == ValueList.size())
615       ValueList.push_back(V);
616     else if (ValueList[NextCstNo] == 0)
617       ValueList.initVal(NextCstNo, V);
618     else {
619       // If there was a forward reference to this constant,
620       Value *OldV = ValueList[NextCstNo];
621       ValueList.setOperand(NextCstNo, V);
622       OldV->replaceAllUsesWith(V);
623       delete OldV;
624     }
625 
626     ++NextCstNo;
627   }
628 }
629 
630 bool BitcodeReader::ParseModule(BitstreamReader &Stream,
631                                 const std::string &ModuleID) {
632   // Reject multiple MODULE_BLOCK's in a single bitstream.
633   if (TheModule)
634     return Error("Multiple MODULE_BLOCKs in same stream");
635 
636   if (Stream.EnterSubBlock())
637     return Error("Malformed block record");
638 
639   // Otherwise, create the module.
640   TheModule = new Module(ModuleID);
641 
642   SmallVector<uint64_t, 64> Record;
643   std::vector<std::string> SectionTable;
644 
645   // Read all the records for this module.
646   while (!Stream.AtEndOfStream()) {
647     unsigned Code = Stream.ReadCode();
648     if (Code == bitc::END_BLOCK) {
649       if (!GlobalInits.empty())
650         return Error("Malformed global initializer set");
651       if (Stream.ReadBlockEnd())
652         return Error("Error at end of module block");
653       return false;
654     }
655 
656     if (Code == bitc::ENTER_SUBBLOCK) {
657       switch (Stream.ReadSubBlockID()) {
658       default:  // Skip unknown content.
659         if (Stream.SkipBlock())
660           return Error("Malformed block record");
661         break;
662       case bitc::TYPE_BLOCK_ID:
663         if (ParseTypeTable(Stream))
664           return true;
665         break;
666       case bitc::TYPE_SYMTAB_BLOCK_ID:
667         if (ParseTypeSymbolTable(Stream))
668           return true;
669         break;
670       case bitc::VALUE_SYMTAB_BLOCK_ID:
671         if (ParseValueSymbolTable(Stream))
672           return true;
673         break;
674       case bitc::CONSTANTS_BLOCK_ID:
675         if (ParseConstants(Stream))
676           return true;
677         break;
678       }
679       continue;
680     }
681 
682     if (Code == bitc::DEFINE_ABBREV) {
683       Stream.ReadAbbrevRecord();
684       continue;
685     }
686 
687     // Read a record.
688     switch (Stream.ReadRecord(Code, Record)) {
689     default: break;  // Default behavior, ignore unknown content.
690     case bitc::MODULE_CODE_VERSION:  // VERSION: [version#]
691       if (Record.size() < 1)
692         return Error("Malformed MODULE_CODE_VERSION");
693       // Only version #0 is supported so far.
694       if (Record[0] != 0)
695         return Error("Unknown bitstream version!");
696       break;
697     case bitc::MODULE_CODE_TRIPLE: {  // TRIPLE: [strlen, strchr x N]
698       std::string S;
699       if (ConvertToString(Record, 0, S))
700         return Error("Invalid MODULE_CODE_TRIPLE record");
701       TheModule->setTargetTriple(S);
702       break;
703     }
704     case bitc::MODULE_CODE_DATALAYOUT: {  // DATALAYOUT: [strlen, strchr x N]
705       std::string S;
706       if (ConvertToString(Record, 0, S))
707         return Error("Invalid MODULE_CODE_DATALAYOUT record");
708       TheModule->setDataLayout(S);
709       break;
710     }
711     case bitc::MODULE_CODE_ASM: {  // ASM: [strlen, strchr x N]
712       std::string S;
713       if (ConvertToString(Record, 0, S))
714         return Error("Invalid MODULE_CODE_ASM record");
715       TheModule->setModuleInlineAsm(S);
716       break;
717     }
718     case bitc::MODULE_CODE_DEPLIB: {  // DEPLIB: [strlen, strchr x N]
719       std::string S;
720       if (ConvertToString(Record, 0, S))
721         return Error("Invalid MODULE_CODE_DEPLIB record");
722       TheModule->addLibrary(S);
723       break;
724     }
725     case bitc::MODULE_CODE_SECTIONNAME: {  // SECTIONNAME: [strlen, strchr x N]
726       std::string S;
727       if (ConvertToString(Record, 0, S))
728         return Error("Invalid MODULE_CODE_SECTIONNAME record");
729       SectionTable.push_back(S);
730       break;
731     }
732     // GLOBALVAR: [type, isconst, initid,
733     //             linkage, alignment, section, visibility, threadlocal]
734     case bitc::MODULE_CODE_GLOBALVAR: {
735       if (Record.size() < 6)
736         return Error("Invalid MODULE_CODE_GLOBALVAR record");
737       const Type *Ty = getTypeByID(Record[0]);
738       if (!isa<PointerType>(Ty))
739         return Error("Global not a pointer type!");
740       Ty = cast<PointerType>(Ty)->getElementType();
741 
742       bool isConstant = Record[1];
743       GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]);
744       unsigned Alignment = (1 << Record[4]) >> 1;
745       std::string Section;
746       if (Record[5]) {
747         if (Record[5]-1 >= SectionTable.size())
748           return Error("Invalid section ID");
749         Section = SectionTable[Record[5]-1];
750       }
751       GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility;
752       if (Record.size() >= 6) Visibility = GetDecodedVisibility(Record[6]);
753       bool isThreadLocal = false;
754       if (Record.size() >= 7) isThreadLocal = Record[7];
755 
756       GlobalVariable *NewGV =
757         new GlobalVariable(Ty, isConstant, Linkage, 0, "", TheModule);
758       NewGV->setAlignment(Alignment);
759       if (!Section.empty())
760         NewGV->setSection(Section);
761       NewGV->setVisibility(Visibility);
762       NewGV->setThreadLocal(isThreadLocal);
763 
764       ValueList.push_back(NewGV);
765 
766       // Remember which value to use for the global initializer.
767       if (unsigned InitID = Record[2])
768         GlobalInits.push_back(std::make_pair(NewGV, InitID-1));
769       break;
770     }
771     // FUNCTION:  [type, callingconv, isproto, linkage, alignment, section,
772     //             visibility]
773     case bitc::MODULE_CODE_FUNCTION: {
774       if (Record.size() < 7)
775         return Error("Invalid MODULE_CODE_FUNCTION record");
776       const Type *Ty = getTypeByID(Record[0]);
777       if (!isa<PointerType>(Ty))
778         return Error("Function not a pointer type!");
779       const FunctionType *FTy =
780         dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType());
781       if (!FTy)
782         return Error("Function not a pointer to function type!");
783 
784       Function *Func = new Function(FTy, GlobalValue::ExternalLinkage,
785                                     "", TheModule);
786 
787       Func->setCallingConv(Record[1]);
788       Func->setLinkage(GetDecodedLinkage(Record[3]));
789       Func->setAlignment((1 << Record[4]) >> 1);
790       if (Record[5]) {
791         if (Record[5]-1 >= SectionTable.size())
792           return Error("Invalid section ID");
793         Func->setSection(SectionTable[Record[5]-1]);
794       }
795       Func->setVisibility(GetDecodedVisibility(Record[6]));
796 
797       ValueList.push_back(Func);
798       // TODO: remember initializer/global pair for later substitution.
799       break;
800     }
801     }
802     Record.clear();
803   }
804 
805   return Error("Premature end of bitstream");
806 }
807 
808 
809 bool BitcodeReader::ParseBitcode(unsigned char *Buf, unsigned Length,
810                                  const std::string &ModuleID) {
811   TheModule = 0;
812 
813   if (Length & 3)
814     return Error("Bitcode stream should be a multiple of 4 bytes in length");
815 
816   BitstreamReader Stream(Buf, Buf+Length);
817 
818   // Sniff for the signature.
819   if (Stream.Read(8) != 'B' ||
820       Stream.Read(8) != 'C' ||
821       Stream.Read(4) != 0x0 ||
822       Stream.Read(4) != 0xC ||
823       Stream.Read(4) != 0xE ||
824       Stream.Read(4) != 0xD)
825     return Error("Invalid bitcode signature");
826 
827   // We expect a number of well-defined blocks, though we don't necessarily
828   // need to understand them all.
829   while (!Stream.AtEndOfStream()) {
830     unsigned Code = Stream.ReadCode();
831 
832     if (Code != bitc::ENTER_SUBBLOCK)
833       return Error("Invalid record at top-level");
834 
835     unsigned BlockID = Stream.ReadSubBlockID();
836 
837     // We only know the MODULE subblock ID.
838     if (BlockID == bitc::MODULE_BLOCK_ID) {
839       if (ParseModule(Stream, ModuleID))
840         return true;
841     } else if (Stream.SkipBlock()) {
842       return Error("Malformed block record");
843     }
844   }
845 
846   return false;
847 }
848