lib/Bitcode/Reader/BitcodeReader.cpp

   1 //===- BitcodeReader.cpp - Internal BitcodeReader implementation ----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This header defines the BitcodeReader class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Bitcode/ReaderWriter.h"
  15 #include "BitcodeReader.h"
  16 #include "llvm/Constants.h"
  17 #include "llvm/DerivedTypes.h"
  18 #include "llvm/InlineAsm.h"
  19 #include "llvm/Instructions.h"
  20 #include "llvm/MDNode.h"
  21 #include "llvm/Module.h"
  22 #include "llvm/AutoUpgrade.h"
  23 #include "llvm/ADT/SmallString.h"
  24 #include "llvm/ADT/SmallVector.h"
  25 #include "llvm/Support/MathExtras.h"
  26 #include "llvm/Support/MemoryBuffer.h"
  27 #include "llvm/OperandTraits.h"
  28 using namespace llvm;
  29
  30 void BitcodeReader::FreeState() {
  31   delete Buffer;
  32   Buffer = 0;
  33   std::vector<PATypeHolder>().swap(TypeList);
  34   ValueList.clear();
  35
  36   std::vector<AttrListPtr>().swap(MAttributes);
  37   std::vector<BasicBlock*>().swap(FunctionBBs);
  38   std::vector<Function*>().swap(FunctionsWithBodies);
  39   DeferredFunctionInfo.clear();
  40 }
  41
  42 //===----------------------------------------------------------------------===//
  43 //  Helper functions to implement forward reference resolution, etc.
  44 //===----------------------------------------------------------------------===//
  45
  46 /// ConvertToString - Convert a string from a record into an std::string, return
  47 /// true on failure.
  48 template<typename StrTy>
  49 static bool ConvertToString(SmallVector<uint64_t, 64> &Record, unsigned Idx,
  50                             StrTy &Result) {
  51   if (Idx > Record.size())
  52     return true;
  53
  54   for (unsigned i = Idx, e = Record.size(); i != e; ++i)
  55     Result += (char)Record[i];
  56   return false;
  57 }
  58
  59 static GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) {
  60   switch (Val) {
  61   default: // Map unknown/new linkages to external
  62   case 0: return GlobalValue::ExternalLinkage;
  63   case 1: return GlobalValue::WeakAnyLinkage;
  64   case 2: return GlobalValue::AppendingLinkage;
  65   case 3: return GlobalValue::InternalLinkage;
  66   case 4: return GlobalValue::LinkOnceAnyLinkage;
  67   case 5: return GlobalValue::DLLImportLinkage;
  68   case 6: return GlobalValue::DLLExportLinkage;
  69   case 7: return GlobalValue::ExternalWeakLinkage;
  70   case 8: return GlobalValue::CommonLinkage;
  71   case 9: return GlobalValue::PrivateLinkage;
  72   case 10: return GlobalValue::WeakODRLinkage;
  73   case 11: return GlobalValue::LinkOnceODRLinkage;
  74   case 12: return GlobalValue::AvailableExternallyLinkage;
  75   }
  76 }
  77
  78 static GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) {
  79   switch (Val) {
  80   default: // Map unknown visibilities to default.
  81   case 0: return GlobalValue::DefaultVisibility;
  82   case 1: return GlobalValue::HiddenVisibility;
  83   case 2: return GlobalValue::ProtectedVisibility;
  84   }
  85 }
  86
  87 static int GetDecodedCastOpcode(unsigned Val) {
  88   switch (Val) {
  89   default: return -1;
  90   case bitc::CAST_TRUNC   : return Instruction::Trunc;
  91   case bitc::CAST_ZEXT    : return Instruction::ZExt;
  92   case bitc::CAST_SEXT    : return Instruction::SExt;
  93   case bitc::CAST_FPTOUI  : return Instruction::FPToUI;
  94   case bitc::CAST_FPTOSI  : return Instruction::FPToSI;
  95   case bitc::CAST_UITOFP  : return Instruction::UIToFP;
  96   case bitc::CAST_SITOFP  : return Instruction::SIToFP;
  97   case bitc::CAST_FPTRUNC : return Instruction::FPTrunc;
  98   case bitc::CAST_FPEXT   : return Instruction::FPExt;
  99   case bitc::CAST_PTRTOINT: return Instruction::PtrToInt;
 100   case bitc::CAST_INTTOPTR: return Instruction::IntToPtr;
 101   case bitc::CAST_BITCAST : return Instruction::BitCast;
 102   }
 103 }
 104 static int GetDecodedBinaryOpcode(unsigned Val, const Type *Ty) {
 105   switch (Val) {
 106   default: return -1;
 107   case bitc::BINOP_ADD:  return Instruction::Add;
 108   case bitc::BINOP_SUB:  return Instruction::Sub;
 109   case bitc::BINOP_MUL:  return Instruction::Mul;
 110   case bitc::BINOP_UDIV: return Instruction::UDiv;
 111   case bitc::BINOP_SDIV:
 112     return Ty->isFPOrFPVector() ? Instruction::FDiv : Instruction::SDiv;
 113   case bitc::BINOP_UREM: return Instruction::URem;
 114   case bitc::BINOP_SREM:
 115     return Ty->isFPOrFPVector() ? Instruction::FRem : Instruction::SRem;
 116   case bitc::BINOP_SHL:  return Instruction::Shl;
 117   case bitc::BINOP_LSHR: return Instruction::LShr;
 118   case bitc::BINOP_ASHR: return Instruction::AShr;
 119   case bitc::BINOP_AND:  return Instruction::And;
 120   case bitc::BINOP_OR:   return Instruction::Or;
 121   case bitc::BINOP_XOR:  return Instruction::Xor;
 122   }
 123 }
 124
 125 namespace llvm {
 126 namespace {
 127   /// @brief A class for maintaining the slot number definition
 128   /// as a placeholder for the actual definition for forward constants defs.
 129   class ConstantPlaceHolder : public ConstantExpr {
 130     ConstantPlaceHolder();                       // DO NOT IMPLEMENT
 131     void operator=(const ConstantPlaceHolder &); // DO NOT IMPLEMENT
 132   public:
 133     // allocate space for exactly one operand
 134     void *operator new(size_t s) {
 135       return User::operator new(s, 1);
 136     }
 137     explicit ConstantPlaceHolder(const Type *Ty)
 138       : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) {
 139       Op<0>() = UndefValue::get(Type::Int32Ty);
 140     }
 141
 142     /// @brief Methods to support type inquiry through isa, cast, and dyn_cast.
 143     static inline bool classof(const ConstantPlaceHolder *) { return true; }
 144     static bool classof(const Value *V) {
 145       return isa<ConstantExpr>(V) &&
 146              cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1;
 147     }
 148
 149
 150     /// Provide fast operand accessors
 151     //DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 152   };
 153 }
 154
 155 // FIXME: can we inherit this from ConstantExpr?
 156 template <>
 157 struct OperandTraits<ConstantPlaceHolder> : FixedNumOperandTraits<1> {
 158 };
 159 }
 160
 161
 162 void BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) {
 163   if (Idx == size()) {
 164     push_back(V);
 165     return;
 166   }
 167
 168   if (Idx >= size())
 169     resize(Idx+1);
 170
 171   WeakVH &OldV = ValuePtrs[Idx];
 172   if (OldV == 0) {
 173     OldV = V;
 174     return;
 175   }
 176
 177   // Handle constants and non-constants (e.g. instrs) differently for
 178   // efficiency.
 179   if (Constant *PHC = dyn_cast<Constant>(&*OldV)) {
 180     ResolveConstants.push_back(std::make_pair(PHC, Idx));
 181     OldV = V;
 182   } else {
 183     // If there was a forward reference to this value, replace it.
 184     Value *PrevVal = OldV;
 185     OldV->replaceAllUsesWith(V);
 186     delete PrevVal;
 187   }
 188 }
 189
 190
 191 Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx,
 192                                                     const Type *Ty) {
 193   if (Idx >= size())
 194     resize(Idx + 1);
 195
 196   if (Value *V = ValuePtrs[Idx]) {
 197     assert(Ty == V->getType() && "Type mismatch in constant table!");
 198     return cast<Constant>(V);
 199   }
 200
 201   // Create and return a placeholder, which will later be RAUW'd.
 202   Constant *C = new ConstantPlaceHolder(Ty);
 203   ValuePtrs[Idx] = C;
 204   return C;
 205 }
 206
 207 Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, const Type *Ty) {
 208   if (Idx >= size())
 209     resize(Idx + 1);
 210
 211   if (Value *V = ValuePtrs[Idx]) {
 212     assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!");
 213     return V;
 214   }
 215
 216   // No type specified, must be invalid reference.
 217   if (Ty == 0) return 0;
 218
 219   // Create and return a placeholder, which will later be RAUW'd.
 220   Value *V = new Argument(Ty);
 221   ValuePtrs[Idx] = V;
 222   return V;
 223 }
 224
 225 /// ResolveConstantForwardRefs - Once all constants are read, this method bulk
 226 /// resolves any forward references.  The idea behind this is that we sometimes
 227 /// get constants (such as large arrays) which reference *many* forward ref
 228 /// constants.  Replacing each of these causes a lot of thrashing when
 229 /// building/reuniquing the constant.  Instead of doing this, we look at all the
 230 /// uses and rewrite all the place holders at once for any constant that uses
 231 /// a placeholder.
 232 void BitcodeReaderValueList::ResolveConstantForwardRefs() {
 233   // Sort the values by-pointer so that they are efficient to look up with a
 234   // binary search.
 235   std::sort(ResolveConstants.begin(), ResolveConstants.end());
 236
 237   SmallVector<Constant*, 64> NewOps;
 238
 239   while (!ResolveConstants.empty()) {
 240     Value *RealVal = operator[](ResolveConstants.back().second);
 241     Constant *Placeholder = ResolveConstants.back().first;
 242     ResolveConstants.pop_back();
 243
 244     // Loop over all users of the placeholder, updating them to reference the
 245     // new value.  If they reference more than one placeholder, update them all
 246     // at once.
 247     while (!Placeholder->use_empty()) {
 248       Value::use_iterator UI = Placeholder->use_begin();
 249
 250       // If the using object isn't uniqued, just update the operands.  This
 251       // handles instructions and initializers for global variables.
 252       if (!isa<Constant>(*UI) || isa<GlobalValue>(*UI)) {
 253         UI.getUse().set(RealVal);
 254         continue;
 255       }
 256
 257       // Otherwise, we have a constant that uses the placeholder.  Replace that
 258       // constant with a new constant that has *all* placeholder uses updated.
 259       Constant *UserC = cast<Constant>(*UI);
 260       for (User::op_iterator I = UserC->op_begin(), E = UserC->op_end();
 261            I != E; ++I) {
 262         Value *NewOp;
 263         if (!isa<ConstantPlaceHolder>(*I)) {
 264           // Not a placeholder reference.
 265           NewOp = *I;
 266         } else if (*I == Placeholder) {
 267           // Common case is that it just references this one placeholder.
 268           NewOp = RealVal;
 269         } else {
 270           // Otherwise, look up the placeholder in ResolveConstants.
 271           ResolveConstantsTy::iterator It =
 272             std::lower_bound(ResolveConstants.begin(), ResolveConstants.end(),
 273                              std::pair<Constant*, unsigned>(cast<Constant>(*I),
 274                                                             0));
 275           assert(It != ResolveConstants.end() && It->first == *I);
 276           NewOp = operator[](It->second);
 277         }
 278
 279         NewOps.push_back(cast<Constant>(NewOp));
 280       }
 281
 282       // Make the new constant.
 283       Constant *NewC;
 284       if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) {
 285         NewC = ConstantArray::get(UserCA->getType(), &NewOps[0], NewOps.size());
 286       } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) {
 287         NewC = ConstantStruct::get(&NewOps[0], NewOps.size(),
 288                                    UserCS->getType()->isPacked());
 289       } else if (isa<ConstantVector>(UserC)) {
 290         NewC = ConstantVector::get(&NewOps[0], NewOps.size());
 291       } else {
 292         assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr.");
 293         NewC = cast<ConstantExpr>(UserC)->getWithOperands(&NewOps[0],
 294                                                           NewOps.size());
 295       }
 296
 297       UserC->replaceAllUsesWith(NewC);
 298       UserC->destroyConstant();
 299       NewOps.clear();
 300     }
 301
 302     // Update all ValueHandles, they should be the only users at this point.
 303     Placeholder->replaceAllUsesWith(RealVal);
 304     delete Placeholder;
 305   }
 306 }
 307
 308
 309 const Type *BitcodeReader::getTypeByID(unsigned ID, bool isTypeTable) {
 310   // If the TypeID is in range, return it.
 311   if (ID < TypeList.size())
 312     return TypeList[ID].get();
 313   if (!isTypeTable) return 0;
 314
 315   // The type table allows forward references.  Push as many Opaque types as
 316   // needed to get up to ID.
 317   while (TypeList.size() <= ID)
 318     TypeList.push_back(OpaqueType::get());
 319   return TypeList.back().get();
 320 }
 321
 322 //===----------------------------------------------------------------------===//
 323 //  Functions for parsing blocks from the bitcode file
 324 //===----------------------------------------------------------------------===//
 325
 326 bool BitcodeReader::ParseAttributeBlock() {
 327   if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))
 328     return Error("Malformed block record");
 329
 330   if (!MAttributes.empty())
 331     return Error("Multiple PARAMATTR blocks found!");
 332
 333   SmallVector<uint64_t, 64> Record;
 334
 335   SmallVector<AttributeWithIndex, 8> Attrs;
 336
 337   // Read all the records.
 338   while (1) {
 339     unsigned Code = Stream.ReadCode();
 340     if (Code == bitc::END_BLOCK) {
 341       if (Stream.ReadBlockEnd())
 342         return Error("Error at end of PARAMATTR block");
 343       return false;
 344     }
 345
 346     if (Code == bitc::ENTER_SUBBLOCK) {
 347       // No known subblocks, always skip them.
 348       Stream.ReadSubBlockID();
 349       if (Stream.SkipBlock())
 350         return Error("Malformed block record");
 351       continue;
 352     }
 353
 354     if (Code == bitc::DEFINE_ABBREV) {
 355       Stream.ReadAbbrevRecord();
 356       continue;
 357     }
 358
 359     // Read a record.
 360     Record.clear();
 361     switch (Stream.ReadRecord(Code, Record)) {
 362     default:  // Default behavior: ignore.
 363       break;
 364     case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [paramidx0, attr0, ...]
 365       if (Record.size() & 1)
 366         return Error("Invalid ENTRY record");
 367
 368       // FIXME : Remove this autoupgrade code in LLVM 3.0.
 369       // If Function attributes are using index 0 then transfer them
 370       // to index ~0. Index 0 is used for return value attributes but used to be
 371       // used for function attributes.
 372       Attributes RetAttribute = Attribute::None;
 373       Attributes FnAttribute = Attribute::None;
 374       for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
 375         // FIXME: remove in LLVM 3.0
 376         // The alignment is stored as a 16-bit raw value from bits 31--16.
 377         // We shift the bits above 31 down by 11 bits.
 378
 379         unsigned Alignment = (Record[i+1] & (0xffffull << 16)) >> 16;
 380         if (Alignment && !isPowerOf2_32(Alignment))
 381           return Error("Alignment is not a power of two.");
 382
 383         Attributes ReconstitutedAttr = Record[i+1] & 0xffff;
 384         if (Alignment)
 385           ReconstitutedAttr |= Attribute::constructAlignmentFromInt(Alignment);
 386         ReconstitutedAttr |= (Record[i+1] & (0xffffull << 32)) >> 11;
 387         Record[i+1] = ReconstitutedAttr;
 388
 389         if (Record[i] == 0)
 390           RetAttribute = Record[i+1];
 391         else if (Record[i] == ~0U)
 392           FnAttribute = Record[i+1];
 393       }
 394
 395       unsigned OldRetAttrs = (Attribute::NoUnwind|Attribute::NoReturn|
 396                               Attribute::ReadOnly|Attribute::ReadNone);
 397
 398       if (FnAttribute == Attribute::None && RetAttribute != Attribute::None &&
 399           (RetAttribute & OldRetAttrs) != 0) {
 400         if (FnAttribute == Attribute::None) { // add a slot so they get added.
 401           Record.push_back(~0U);
 402           Record.push_back(0);
 403         }
 404
 405         FnAttribute  |= RetAttribute & OldRetAttrs;
 406         RetAttribute &= ~OldRetAttrs;
 407       }
 408
 409       for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
 410         if (Record[i] == 0) {
 411           if (RetAttribute != Attribute::None)
 412             Attrs.push_back(AttributeWithIndex::get(0, RetAttribute));
 413         } else if (Record[i] == ~0U) {
 414           if (FnAttribute != Attribute::None)
 415             Attrs.push_back(AttributeWithIndex::get(~0U, FnAttribute));
 416         } else if (Record[i+1] != Attribute::None)
 417           Attrs.push_back(AttributeWithIndex::get(Record[i], Record[i+1]));
 418       }
 419
 420       MAttributes.push_back(AttrListPtr::get(Attrs.begin(), Attrs.end()));
 421       Attrs.clear();
 422       break;
 423     }
 424     }
 425   }
 426 }
 427
 428
 429 bool BitcodeReader::ParseTypeTable() {
 430   if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID))
 431     return Error("Malformed block record");
 432
 433   if (!TypeList.empty())
 434     return Error("Multiple TYPE_BLOCKs found!");
 435
 436   SmallVector<uint64_t, 64> Record;
 437   unsigned NumRecords = 0;
 438
 439   // Read all the records for this type table.
 440   while (1) {
 441     unsigned Code = Stream.ReadCode();
 442     if (Code == bitc::END_BLOCK) {
 443       if (NumRecords != TypeList.size())
 444         return Error("Invalid type forward reference in TYPE_BLOCK");
 445       if (Stream.ReadBlockEnd())
 446         return Error("Error at end of type table block");
 447       return false;
 448     }
 449
 450     if (Code == bitc::ENTER_SUBBLOCK) {
 451       // No known subblocks, always skip them.
 452       Stream.ReadSubBlockID();
 453       if (Stream.SkipBlock())
 454         return Error("Malformed block record");
 455       continue;
 456     }
 457
 458     if (Code == bitc::DEFINE_ABBREV) {
 459       Stream.ReadAbbrevRecord();
 460       continue;
 461     }
 462
 463     // Read a record.
 464     Record.clear();
 465     const Type *ResultTy = 0;
 466     switch (Stream.ReadRecord(Code, Record)) {
 467     default:  // Default behavior: unknown type.
 468       ResultTy = 0;
 469       break;
 470     case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries]
 471       // TYPE_CODE_NUMENTRY contains a count of the number of types in the
 472       // type list.  This allows us to reserve space.
 473       if (Record.size() < 1)
 474         return Error("Invalid TYPE_CODE_NUMENTRY record");
 475       TypeList.reserve(Record[0]);
 476       continue;
 477     case bitc::TYPE_CODE_VOID:      // VOID
 478       ResultTy = Type::VoidTy;
 479       break;
 480     case bitc::TYPE_CODE_FLOAT:     // FLOAT
 481       ResultTy = Type::FloatTy;
 482       break;
 483     case bitc::TYPE_CODE_DOUBLE:    // DOUBLE
 484       ResultTy = Type::DoubleTy;
 485       break;
 486     case bitc::TYPE_CODE_X86_FP80:  // X86_FP80
 487       ResultTy = Type::X86_FP80Ty;
 488       break;
 489     case bitc::TYPE_CODE_FP128:     // FP128
 490       ResultTy = Type::FP128Ty;
 491       break;
 492     case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128
 493       ResultTy = Type::PPC_FP128Ty;
 494       break;
 495     case bitc::TYPE_CODE_LABEL:     // LABEL
 496       ResultTy = Type::LabelTy;
 497       break;
 498     case bitc::TYPE_CODE_OPAQUE:    // OPAQUE
 499       ResultTy = 0;
 500       break;
 501     case bitc::TYPE_CODE_INTEGER:   // INTEGER: [width]
 502       if (Record.size() < 1)
 503         return Error("Invalid Integer type record");
 504
 505       ResultTy = IntegerType::get(Record[0]);
 506       break;
 507     case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or
 508                                     //          [pointee type, address space]
 509       if (Record.size() < 1)
 510         return Error("Invalid POINTER type record");
 511       unsigned AddressSpace = 0;
 512       if (Record.size() == 2)
 513         AddressSpace = Record[1];
 514       ResultTy = PointerType::get(getTypeByID(Record[0], true), AddressSpace);
 515       break;
 516     }
 517     case bitc::TYPE_CODE_FUNCTION: {
 518       // FIXME: attrid is dead, remove it in LLVM 3.0
 519       // FUNCTION: [vararg, attrid, retty, paramty x N]
 520       if (Record.size() < 3)
 521         return Error("Invalid FUNCTION type record");
 522       std::vector<const Type*> ArgTys;
 523       for (unsigned i = 3, e = Record.size(); i != e; ++i)
 524         ArgTys.push_back(getTypeByID(Record[i], true));
 525
 526       ResultTy = FunctionType::get(getTypeByID(Record[2], true), ArgTys,
 527                                    Record[0]);
 528       break;
 529     }
 530     case bitc::TYPE_CODE_STRUCT: {  // STRUCT: [ispacked, eltty x N]
 531       if (Record.size() < 1)
 532         return Error("Invalid STRUCT type record");
 533       std::vector<const Type*> EltTys;
 534       for (unsigned i = 1, e = Record.size(); i != e; ++i)
 535         EltTys.push_back(getTypeByID(Record[i], true));
 536       ResultTy = StructType::get(EltTys, Record[0]);
 537       break;
 538     }
 539     case bitc::TYPE_CODE_ARRAY:     // ARRAY: [numelts, eltty]
 540       if (Record.size() < 2)
 541         return Error("Invalid ARRAY type record");
 542       ResultTy = ArrayType::get(getTypeByID(Record[1], true), Record[0]);
 543       break;
 544     case bitc::TYPE_CODE_VECTOR:    // VECTOR: [numelts, eltty]
 545       if (Record.size() < 2)
 546         return Error("Invalid VECTOR type record");
 547       ResultTy = VectorType::get(getTypeByID(Record[1], true), Record[0]);
 548       break;
 549     }
 550
 551     if (NumRecords == TypeList.size()) {
 552       // If this is a new type slot, just append it.
 553       TypeList.push_back(ResultTy ? ResultTy : OpaqueType::get());
 554       ++NumRecords;
 555     } else if (ResultTy == 0) {
 556       // Otherwise, this was forward referenced, so an opaque type was created,
 557       // but the result type is actually just an opaque.  Leave the one we
 558       // created previously.
 559       ++NumRecords;
 560     } else {
 561       // Otherwise, this was forward referenced, so an opaque type was created.
 562       // Resolve the opaque type to the real type now.
 563       assert(NumRecords < TypeList.size() && "Typelist imbalance");
 564       const OpaqueType *OldTy = cast<OpaqueType>(TypeList[NumRecords++].get());
 565
 566       // Don't directly push the new type on the Tab. Instead we want to replace
 567       // the opaque type we previously inserted with the new concrete value. The
 568       // refinement from the abstract (opaque) type to the new type causes all
 569       // uses of the abstract type to use the concrete type (NewTy). This will
 570       // also cause the opaque type to be deleted.
 571       const_cast<OpaqueType*>(OldTy)->refineAbstractTypeTo(ResultTy);
 572
 573       // This should have replaced the old opaque type with the new type in the
 574       // value table... or with a preexisting type that was already in the
 575       // system.  Let's just make sure it did.
 576       assert(TypeList[NumRecords-1].get() != OldTy &&
 577              "refineAbstractType didn't work!");
 578     }
 579   }
 580 }
 581
 582
 583 bool BitcodeReader::ParseTypeSymbolTable() {
 584   if (Stream.EnterSubBlock(bitc::TYPE_SYMTAB_BLOCK_ID))
 585     return Error("Malformed block record");
 586
 587   SmallVector<uint64_t, 64> Record;
 588
 589   // Read all the records for this type table.
 590   std::string TypeName;
 591   while (1) {
 592     unsigned Code = Stream.ReadCode();
 593     if (Code == bitc::END_BLOCK) {
 594       if (Stream.ReadBlockEnd())
 595         return Error("Error at end of type symbol table block");
 596       return false;
 597     }
 598
 599     if (Code == bitc::ENTER_SUBBLOCK) {
 600       // No known subblocks, always skip them.
 601       Stream.ReadSubBlockID();
 602       if (Stream.SkipBlock())
 603         return Error("Malformed block record");
 604       continue;
 605     }
 606
 607     if (Code == bitc::DEFINE_ABBREV) {
 608       Stream.ReadAbbrevRecord();
 609       continue;
 610     }
 611
 612     // Read a record.
 613     Record.clear();
 614     switch (Stream.ReadRecord(Code, Record)) {
 615     default:  // Default behavior: unknown type.
 616       break;
 617     case bitc::TST_CODE_ENTRY:    // TST_ENTRY: [typeid, namechar x N]
 618       if (ConvertToString(Record, 1, TypeName))
 619         return Error("Invalid TST_ENTRY record");
 620       unsigned TypeID = Record[0];
 621       if (TypeID >= TypeList.size())
 622         return Error("Invalid Type ID in TST_ENTRY record");
 623
 624       TheModule->addTypeName(TypeName, TypeList[TypeID].get());
 625       TypeName.clear();
 626       break;
 627     }
 628   }
 629 }
 630
 631 bool BitcodeReader::ParseValueSymbolTable() {
 632   if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
 633     return Error("Malformed block record");
 634
 635   SmallVector<uint64_t, 64> Record;
 636
 637   // Read all the records for this value table.
 638   SmallString<128> ValueName;
 639   while (1) {
 640     unsigned Code = Stream.ReadCode();
 641     if (Code == bitc::END_BLOCK) {
 642       if (Stream.ReadBlockEnd())
 643         return Error("Error at end of value symbol table block");
 644       return false;
 645     }
 646     if (Code == bitc::ENTER_SUBBLOCK) {
 647       // No known subblocks, always skip them.
 648       Stream.ReadSubBlockID();
 649       if (Stream.SkipBlock())
 650         return Error("Malformed block record");
 651       continue;
 652     }
 653
 654     if (Code == bitc::DEFINE_ABBREV) {
 655       Stream.ReadAbbrevRecord();
 656       continue;
 657     }
 658
 659     // Read a record.
 660     Record.clear();
 661     switch (Stream.ReadRecord(Code, Record)) {
 662     default:  // Default behavior: unknown type.
 663       break;
 664     case bitc::VST_CODE_ENTRY: {  // VST_ENTRY: [valueid, namechar x N]
 665       if (ConvertToString(Record, 1, ValueName))
 666         return Error("Invalid TST_ENTRY record");
 667       unsigned ValueID = Record[0];
 668       if (ValueID >= ValueList.size())
 669         return Error("Invalid Value ID in VST_ENTRY record");
 670       Value *V = ValueList[ValueID];
 671
 672       V->setName(&ValueName[0], ValueName.size());
 673       ValueName.clear();
 674       break;
 675     }
 676     case bitc::VST_CODE_BBENTRY: {
 677       if (ConvertToString(Record, 1, ValueName))
 678         return Error("Invalid VST_BBENTRY record");
 679       BasicBlock *BB = getBasicBlock(Record[0]);
 680       if (BB == 0)
 681         return Error("Invalid BB ID in VST_BBENTRY record");
 682
 683       BB->setName(&ValueName[0], ValueName.size());
 684       ValueName.clear();
 685       break;
 686     }
 687     }
 688   }
 689 }
 690
 691 /// DecodeSignRotatedValue - Decode a signed value stored with the sign bit in
 692 /// the LSB for dense VBR encoding.
 693 static uint64_t DecodeSignRotatedValue(uint64_t V) {
 694   if ((V & 1) == 0)
 695     return V >> 1;
 696   if (V != 1)
 697     return -(V >> 1);
 698   // There is no such thing as -0 with integers.  "-0" really means MININT.
 699   return 1ULL << 63;
 700 }
 701
 702 /// ResolveGlobalAndAliasInits - Resolve all of the initializers for global
 703 /// values and aliases that we can.
 704 bool BitcodeReader::ResolveGlobalAndAliasInits() {
 705   std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist;
 706   std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist;
 707
 708   GlobalInitWorklist.swap(GlobalInits);
 709   AliasInitWorklist.swap(AliasInits);
 710
 711   while (!GlobalInitWorklist.empty()) {
 712     unsigned ValID = GlobalInitWorklist.back().second;
 713     if (ValID >= ValueList.size()) {
 714       // Not ready to resolve this yet, it requires something later in the file.
 715       GlobalInits.push_back(GlobalInitWorklist.back());
 716     } else {
 717       if (Constant *C = dyn_cast<Constant>(ValueList[ValID]))
 718         GlobalInitWorklist.back().first->setInitializer(C);
 719       else
 720         return Error("Global variable initializer is not a constant!");
 721     }
 722     GlobalInitWorklist.pop_back();
 723   }
 724
 725   while (!AliasInitWorklist.empty()) {
 726     unsigned ValID = AliasInitWorklist.back().second;
 727     if (ValID >= ValueList.size()) {
 728       AliasInits.push_back(AliasInitWorklist.back());
 729     } else {
 730       if (Constant *C = dyn_cast<Constant>(ValueList[ValID]))
 731         AliasInitWorklist.back().first->setAliasee(C);
 732       else
 733         return Error("Alias initializer is not a constant!");
 734     }
 735     AliasInitWorklist.pop_back();
 736   }
 737   return false;
 738 }
 739
 740
 741 bool BitcodeReader::ParseConstants() {
 742   if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))
 743     return Error("Malformed block record");
 744
 745   SmallVector<uint64_t, 64> Record;
 746
 747   // Read all the records for this value table.
 748   const Type *CurTy = Type::Int32Ty;
 749   unsigned NextCstNo = ValueList.size();
 750   while (1) {
 751     unsigned Code = Stream.ReadCode();
 752     if (Code == bitc::END_BLOCK)
 753       break;
 754
 755     if (Code == bitc::ENTER_SUBBLOCK) {
 756       // No known subblocks, always skip them.
 757       Stream.ReadSubBlockID();
 758       if (Stream.SkipBlock())
 759         return Error("Malformed block record");
 760       continue;
 761     }
 762
 763     if (Code == bitc::DEFINE_ABBREV) {
 764       Stream.ReadAbbrevRecord();
 765       continue;
 766     }
 767
 768     // Read a record.
 769     Record.clear();
 770     Value *V = 0;
 771     switch (Stream.ReadRecord(Code, Record)) {
 772     default:  // Default behavior: unknown constant
 773     case bitc::CST_CODE_UNDEF:     // UNDEF
 774       V = UndefValue::get(CurTy);
 775       break;
 776     case bitc::CST_CODE_SETTYPE:   // SETTYPE: [typeid]
 777       if (Record.empty())
 778         return Error("Malformed CST_SETTYPE record");
 779       if (Record[0] >= TypeList.size())
 780         return Error("Invalid Type ID in CST_SETTYPE record");
 781       CurTy = TypeList[Record[0]];
 782       continue;  // Skip the ValueList manipulation.
 783     case bitc::CST_CODE_NULL:      // NULL
 784       V = Constant::getNullValue(CurTy);
 785       break;
 786     case bitc::CST_CODE_INTEGER:   // INTEGER: [intval]
 787       if (!isa<IntegerType>(CurTy) || Record.empty())
 788         return Error("Invalid CST_INTEGER record");
 789       V = ConstantInt::get(CurTy, DecodeSignRotatedValue(Record[0]));
 790       break;
 791     case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval]
 792       if (!isa<IntegerType>(CurTy) || Record.empty())
 793         return Error("Invalid WIDE_INTEGER record");
 794
 795       unsigned NumWords = Record.size();
 796       SmallVector<uint64_t, 8> Words;
 797       Words.resize(NumWords);
 798       for (unsigned i = 0; i != NumWords; ++i)
 799         Words[i] = DecodeSignRotatedValue(Record[i]);
 800       V = ConstantInt::get(APInt(cast<IntegerType>(CurTy)->getBitWidth(),
 801                                  NumWords, &Words[0]));
 802       break;
 803     }
 804     case bitc::CST_CODE_FLOAT: {    // FLOAT: [fpval]
 805       if (Record.empty())
 806         return Error("Invalid FLOAT record");
 807       if (CurTy == Type::FloatTy)
 808         V = ConstantFP::get(APFloat(APInt(32, (uint32_t)Record[0])));
 809       else if (CurTy == Type::DoubleTy)
 810         V = ConstantFP::get(APFloat(APInt(64, Record[0])));
 811       else if (CurTy == Type::X86_FP80Ty) {
 812         // Bits are not stored the same way as a normal i80 APInt, compensate.
 813         uint64_t Rearrange[2];
 814         Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16);
 815         Rearrange[1] = Record[0] >> 48;
 816         V = ConstantFP::get(APFloat(APInt(80, 2, Rearrange)));
 817       } else if (CurTy == Type::FP128Ty)
 818         V = ConstantFP::get(APFloat(APInt(128, 2, &Record[0]), true));
 819       else if (CurTy == Type::PPC_FP128Ty)
 820         V = ConstantFP::get(APFloat(APInt(128, 2, &Record[0])));
 821       else
 822         V = UndefValue::get(CurTy);
 823       break;
 824     }
 825
 826     case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number]
 827       if (Record.empty())
 828         return Error("Invalid CST_AGGREGATE record");
 829
 830       unsigned Size = Record.size();
 831       std::vector<Constant*> Elts;
 832
 833       if (const StructType *STy = dyn_cast<StructType>(CurTy)) {
 834         for (unsigned i = 0; i != Size; ++i)
 835           Elts.push_back(ValueList.getConstantFwdRef(Record[i],
 836                                                      STy->getElementType(i)));
 837         V = ConstantStruct::get(STy, Elts);
 838       } else if (const ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) {
 839         const Type *EltTy = ATy->getElementType();
 840         for (unsigned i = 0; i != Size; ++i)
 841           Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
 842         V = ConstantArray::get(ATy, Elts);
 843       } else if (const VectorType *VTy = dyn_cast<VectorType>(CurTy)) {
 844         const Type *EltTy = VTy->getElementType();
 845         for (unsigned i = 0; i != Size; ++i)
 846           Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
 847         V = ConstantVector::get(Elts);
 848       } else {
 849         V = UndefValue::get(CurTy);
 850       }
 851       break;
 852     }
 853     case bitc::CST_CODE_STRING: { // STRING: [values]
 854       if (Record.empty())
 855         return Error("Invalid CST_AGGREGATE record");
 856
 857       const ArrayType *ATy = cast<ArrayType>(CurTy);
 858       const Type *EltTy = ATy->getElementType();
 859
 860       unsigned Size = Record.size();
 861       std::vector<Constant*> Elts;
 862       for (unsigned i = 0; i != Size; ++i)
 863         Elts.push_back(ConstantInt::get(EltTy, Record[i]));
 864       V = ConstantArray::get(ATy, Elts);
 865       break;
 866     }
 867     case bitc::CST_CODE_CSTRING: { // CSTRING: [values]
 868       if (Record.empty())
 869         return Error("Invalid CST_AGGREGATE record");
 870
 871       const ArrayType *ATy = cast<ArrayType>(CurTy);
 872       const Type *EltTy = ATy->getElementType();
 873
 874       unsigned Size = Record.size();
 875       std::vector<Constant*> Elts;
 876       for (unsigned i = 0; i != Size; ++i)
 877         Elts.push_back(ConstantInt::get(EltTy, Record[i]));
 878       Elts.push_back(Constant::getNullValue(EltTy));
 879       V = ConstantArray::get(ATy, Elts);
 880       break;
 881     }
 882     case bitc::CST_CODE_CE_BINOP: {  // CE_BINOP: [opcode, opval, opval]
 883       if (Record.size() < 3) return Error("Invalid CE_BINOP record");
 884       int Opc = GetDecodedBinaryOpcode(Record[0], CurTy);
 885       if (Opc < 0) {
 886         V = UndefValue::get(CurTy);  // Unknown binop.
 887       } else {
 888         Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy);
 889         Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy);
 890         V = ConstantExpr::get(Opc, LHS, RHS);
 891       }
 892       break;
 893     }
 894     case bitc::CST_CODE_CE_CAST: {  // CE_CAST: [opcode, opty, opval]
 895       if (Record.size() < 3) return Error("Invalid CE_CAST record");
 896       int Opc = GetDecodedCastOpcode(Record[0]);
 897       if (Opc < 0) {
 898         V = UndefValue::get(CurTy);  // Unknown cast.
 899       } else {
 900         const Type *OpTy = getTypeByID(Record[1]);
 901         if (!OpTy) return Error("Invalid CE_CAST record");
 902         Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy);
 903         V = ConstantExpr::getCast(Opc, Op, CurTy);
 904       }
 905       break;
 906     }
 907     case bitc::CST_CODE_CE_GEP: {  // CE_GEP:        [n x operands]
 908       if (Record.size() & 1) return Error("Invalid CE_GEP record");
 909       SmallVector<Constant*, 16> Elts;
 910       for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
 911         const Type *ElTy = getTypeByID(Record[i]);
 912         if (!ElTy) return Error("Invalid CE_GEP record");
 913         Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy));
 914       }
 915       V = ConstantExpr::getGetElementPtr(Elts[0], &Elts[1], Elts.size()-1);
 916       break;
 917     }
 918     case bitc::CST_CODE_CE_SELECT:  // CE_SELECT: [opval#, opval#, opval#]
 919       if (Record.size() < 3) return Error("Invalid CE_SELECT record");
 920       V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0],
 921                                                               Type::Int1Ty),
 922                                   ValueList.getConstantFwdRef(Record[1],CurTy),
 923                                   ValueList.getConstantFwdRef(Record[2],CurTy));
 924       break;
 925     case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval]
 926       if (Record.size() < 3) return Error("Invalid CE_EXTRACTELT record");
 927       const VectorType *OpTy =
 928         dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
 929       if (OpTy == 0) return Error("Invalid CE_EXTRACTELT record");
 930       Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
 931       Constant *Op1 = ValueList.getConstantFwdRef(Record[2], Type::Int32Ty);
 932       V = ConstantExpr::getExtractElement(Op0, Op1);
 933       break;
 934     }
 935     case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval]
 936       const VectorType *OpTy = dyn_cast<VectorType>(CurTy);
 937       if (Record.size() < 3 || OpTy == 0)
 938         return Error("Invalid CE_INSERTELT record");
 939       Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
 940       Constant *Op1 = ValueList.getConstantFwdRef(Record[1],
 941                                                   OpTy->getElementType());
 942       Constant *Op2 = ValueList.getConstantFwdRef(Record[2], Type::Int32Ty);
 943       V = ConstantExpr::getInsertElement(Op0, Op1, Op2);
 944       break;
 945     }
 946     case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval]
 947       const VectorType *OpTy = dyn_cast<VectorType>(CurTy);
 948       if (Record.size() < 3 || OpTy == 0)
 949         return Error("Invalid CE_SHUFFLEVEC record");
 950       Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
 951       Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy);
 952       const Type *ShufTy=VectorType::get(Type::Int32Ty, OpTy->getNumElements());
 953       Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy);
 954       V = ConstantExpr::getShuffleVector(Op0, Op1, Op2);
 955       break;
 956     }
 957     case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval]
 958       const VectorType *RTy = dyn_cast<VectorType>(CurTy);
 959       const VectorType *OpTy = dyn_cast<VectorType>(getTypeByID(Record[0]));
 960       if (Record.size() < 4 || RTy == 0 || OpTy == 0)
 961         return Error("Invalid CE_SHUFVEC_EX record");
 962       Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
 963       Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
 964       const Type *ShufTy=VectorType::get(Type::Int32Ty, RTy->getNumElements());
 965       Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy);
 966       V = ConstantExpr::getShuffleVector(Op0, Op1, Op2);
 967       break;
 968     }
 969     case bitc::CST_CODE_CE_CMP: {     // CE_CMP: [opty, opval, opval, pred]
 970       if (Record.size() < 4) return Error("Invalid CE_CMP record");
 971       const Type *OpTy = getTypeByID(Record[0]);
 972       if (OpTy == 0) return Error("Invalid CE_CMP record");
 973       Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
 974       Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
 975
 976       if (OpTy->isFloatingPoint())
 977         V = ConstantExpr::getFCmp(Record[3], Op0, Op1);
 978       else if (!isa<VectorType>(OpTy))
 979         V = ConstantExpr::getICmp(Record[3], Op0, Op1);
 980       else if (OpTy->isFPOrFPVector())
 981         V = ConstantExpr::getVFCmp(Record[3], Op0, Op1);
 982       else
 983         V = ConstantExpr::getVICmp(Record[3], Op0, Op1);
 984       break;
 985     }
 986     case bitc::CST_CODE_INLINEASM: {
 987       if (Record.size() < 2) return Error("Invalid INLINEASM record");
 988       std::string AsmStr, ConstrStr;
 989       bool HasSideEffects = Record[0];
 990       unsigned AsmStrSize = Record[1];
 991       if (2+AsmStrSize >= Record.size())
 992         return Error("Invalid INLINEASM record");
 993       unsigned ConstStrSize = Record[2+AsmStrSize];
 994       if (3+AsmStrSize+ConstStrSize > Record.size())
 995         return Error("Invalid INLINEASM record");
 996
 997       for (unsigned i = 0; i != AsmStrSize; ++i)
 998         AsmStr += (char)Record[2+i];
 999       for (unsigned i = 0; i != ConstStrSize; ++i)
1000         ConstrStr += (char)Record[3+AsmStrSize+i];
1001       const PointerType *PTy = cast<PointerType>(CurTy);
1002       V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()),
1003                          AsmStr, ConstrStr, HasSideEffects);
1004       break;
1005     }
1006     case bitc::CST_CODE_MDSTRING: {
1007       if (Record.size() < 2) return Error("Invalid MDSTRING record");
1008       unsigned MDStringLength = Record.size();
1009       SmallString<8> String;
1010       String.resize(MDStringLength);
1011       for (unsigned i = 0; i != MDStringLength; ++i)
1012         String[i] = Record[i];
1013       V = MDString::get(String.c_str(), String.c_str() + MDStringLength);
1014       break;
1015     }
1016     case bitc::CST_CODE_MDNODE: {
1017       if (Record.empty() || Record.size() % 2 == 1)
1018         return Error("Invalid CST_MDNODE record");
1019
1020       unsigned Size = Record.size();
1021       SmallVector<Value*, 8> Elts;
1022       for (unsigned i = 0; i != Size; i += 2) {
1023         const Type *Ty = getTypeByID(Record[i], false);
1024         if (Ty != Type::VoidTy)
1025           Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], Ty));
1026         else
1027           Elts.push_back(NULL);
1028       }
1029       V = MDNode::get(&Elts[0], Elts.size());
1030       break;
1031     }
1032     }
1033
1034     ValueList.AssignValue(V, NextCstNo);
1035     ++NextCstNo;
1036   }
1037
1038   if (NextCstNo != ValueList.size())
1039     return Error("Invalid constant reference!");
1040
1041   if (Stream.ReadBlockEnd())
1042     return Error("Error at end of constants block");
1043
1044   // Once all the constants have been read, go through and resolve forward
1045   // references.
1046   ValueList.ResolveConstantForwardRefs();
1047   return false;
1048 }
1049
1050 /// RememberAndSkipFunctionBody - When we see the block for a function body,
1051 /// remember where it is and then skip it.  This lets us lazily deserialize the
1052 /// functions.
1053 bool BitcodeReader::RememberAndSkipFunctionBody() {
1054   // Get the function we are talking about.
1055   if (FunctionsWithBodies.empty())
1056     return Error("Insufficient function protos");
1057
1058   Function *Fn = FunctionsWithBodies.back();
1059   FunctionsWithBodies.pop_back();
1060
1061   // Save the current stream state.
1062   uint64_t CurBit = Stream.GetCurrentBitNo();
1063   DeferredFunctionInfo[Fn] = std::make_pair(CurBit, Fn->getLinkage());
1064
1065   // Set the functions linkage to GhostLinkage so we know it is lazily
1066   // deserialized.
1067   Fn->setLinkage(GlobalValue::GhostLinkage);
1068
1069   // Skip over the function block for now.
1070   if (Stream.SkipBlock())
1071     return Error("Malformed block record");
1072   return false;
1073 }
1074
1075 bool BitcodeReader::ParseModule(const std::string &ModuleID) {
1076   // Reject multiple MODULE_BLOCK's in a single bitstream.
1077   if (TheModule)
1078     return Error("Multiple MODULE_BLOCKs in same stream");
1079
1080   if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
1081     return Error("Malformed block record");
1082
1083   // Otherwise, create the module.
1084   TheModule = new Module(ModuleID);
1085
1086   SmallVector<uint64_t, 64> Record;
1087   std::vector<std::string> SectionTable;
1088   std::vector<std::string> GCTable;
1089
1090   // Read all the records for this module.
1091   while (!Stream.AtEndOfStream()) {
1092     unsigned Code = Stream.ReadCode();
1093     if (Code == bitc::END_BLOCK) {
1094       if (Stream.ReadBlockEnd())
1095         return Error("Error at end of module block");
1096
1097       // Patch the initializers for globals and aliases up.
1098       ResolveGlobalAndAliasInits();
1099       if (!GlobalInits.empty() || !AliasInits.empty())
1100         return Error("Malformed global initializer set");
1101       if (!FunctionsWithBodies.empty())
1102         return Error("Too few function bodies found");
1103
1104       // Look for intrinsic functions which need to be upgraded at some point
1105       for (Module::iterator FI = TheModule->begin(), FE = TheModule->end();
1106            FI != FE; ++FI) {
1107         Function* NewFn;
1108         if (UpgradeIntrinsicFunction(FI, NewFn))
1109           UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn));
1110       }
1111
1112       // Force deallocation of memory for these vectors to favor the client that
1113       // want lazy deserialization.
1114       std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits);
1115       std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits);
1116       std::vector<Function*>().swap(FunctionsWithBodies);
1117       return false;
1118     }
1119
1120     if (Code == bitc::ENTER_SUBBLOCK) {
1121       switch (Stream.ReadSubBlockID()) {
1122       default:  // Skip unknown content.
1123         if (Stream.SkipBlock())
1124           return Error("Malformed block record");
1125         break;
1126       case bitc::BLOCKINFO_BLOCK_ID:
1127         if (Stream.ReadBlockInfoBlock())
1128           return Error("Malformed BlockInfoBlock");
1129         break;
1130       case bitc::PARAMATTR_BLOCK_ID:
1131         if (ParseAttributeBlock())
1132           return true;
1133         break;
1134       case bitc::TYPE_BLOCK_ID:
1135         if (ParseTypeTable())
1136           return true;
1137         break;
1138       case bitc::TYPE_SYMTAB_BLOCK_ID:
1139         if (ParseTypeSymbolTable())
1140           return true;
1141         break;
1142       case bitc::VALUE_SYMTAB_BLOCK_ID:
1143         if (ParseValueSymbolTable())
1144           return true;
1145         break;
1146       case bitc::CONSTANTS_BLOCK_ID:
1147         if (ParseConstants() || ResolveGlobalAndAliasInits())
1148           return true;
1149         break;
1150       case bitc::FUNCTION_BLOCK_ID:
1151         // If this is the first function body we've seen, reverse the
1152         // FunctionsWithBodies list.
1153         if (!HasReversedFunctionsWithBodies) {
1154           std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end());
1155           HasReversedFunctionsWithBodies = true;
1156         }
1157
1158         if (RememberAndSkipFunctionBody())
1159           return true;
1160         break;
1161       }
1162       continue;
1163     }
1164
1165     if (Code == bitc::DEFINE_ABBREV) {
1166       Stream.ReadAbbrevRecord();
1167       continue;
1168     }
1169
1170     // Read a record.
1171     switch (Stream.ReadRecord(Code, Record)) {
1172     default: break;  // Default behavior, ignore unknown content.
1173     case bitc::MODULE_CODE_VERSION:  // VERSION: [version#]
1174       if (Record.size() < 1)
1175         return Error("Malformed MODULE_CODE_VERSION");
1176       // Only version #0 is supported so far.
1177       if (Record[0] != 0)
1178         return Error("Unknown bitstream version!");
1179       break;
1180     case bitc::MODULE_CODE_TRIPLE: {  // TRIPLE: [strchr x N]
1181       std::string S;
1182       if (ConvertToString(Record, 0, S))
1183         return Error("Invalid MODULE_CODE_TRIPLE record");
1184       TheModule->setTargetTriple(S);
1185       break;
1186     }
1187     case bitc::MODULE_CODE_DATALAYOUT: {  // DATALAYOUT: [strchr x N]
1188       std::string S;
1189       if (ConvertToString(Record, 0, S))
1190         return Error("Invalid MODULE_CODE_DATALAYOUT record");
1191       TheModule->setDataLayout(S);
1192       break;
1193     }
1194     case bitc::MODULE_CODE_ASM: {  // ASM: [strchr x N]
1195       std::string S;
1196       if (ConvertToString(Record, 0, S))
1197         return Error("Invalid MODULE_CODE_ASM record");
1198       TheModule->setModuleInlineAsm(S);
1199       break;
1200     }
1201     case bitc::MODULE_CODE_DEPLIB: {  // DEPLIB: [strchr x N]
1202       std::string S;
1203       if (ConvertToString(Record, 0, S))
1204         return Error("Invalid MODULE_CODE_DEPLIB record");
1205       TheModule->addLibrary(S);
1206       break;
1207     }
1208     case bitc::MODULE_CODE_SECTIONNAME: {  // SECTIONNAME: [strchr x N]
1209       std::string S;
1210       if (ConvertToString(Record, 0, S))
1211         return Error("Invalid MODULE_CODE_SECTIONNAME record");
1212       SectionTable.push_back(S);
1213       break;
1214     }
1215     case bitc::MODULE_CODE_GCNAME: {  // SECTIONNAME: [strchr x N]
1216       std::string S;
1217       if (ConvertToString(Record, 0, S))
1218         return Error("Invalid MODULE_CODE_GCNAME record");
1219       GCTable.push_back(S);
1220       break;
1221     }
1222     // GLOBALVAR: [pointer type, isconst, initid,
1223     //             linkage, alignment, section, visibility, threadlocal]
1224     case bitc::MODULE_CODE_GLOBALVAR: {
1225       if (Record.size() < 6)
1226         return Error("Invalid MODULE_CODE_GLOBALVAR record");
1227       const Type *Ty = getTypeByID(Record[0]);
1228       if (!isa<PointerType>(Ty))
1229         return Error("Global not a pointer type!");
1230       unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace();
1231       Ty = cast<PointerType>(Ty)->getElementType();
1232
1233       bool isConstant = Record[1];
1234       GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]);
1235       unsigned Alignment = (1 << Record[4]) >> 1;
1236       std::string Section;
1237       if (Record[5]) {
1238         if (Record[5]-1 >= SectionTable.size())
1239           return Error("Invalid section ID");
1240         Section = SectionTable[Record[5]-1];
1241       }
1242       GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility;
1243       if (Record.size() > 6)
1244         Visibility = GetDecodedVisibility(Record[6]);
1245       bool isThreadLocal = false;
1246       if (Record.size() > 7)
1247         isThreadLocal = Record[7];
1248
1249       GlobalVariable *NewGV =
1250         new GlobalVariable(Ty, isConstant, Linkage, 0, "", TheModule,
1251                            isThreadLocal, AddressSpace);
1252       NewGV->setAlignment(Alignment);
1253       if (!Section.empty())
1254         NewGV->setSection(Section);
1255       NewGV->setVisibility(Visibility);
1256       NewGV->setThreadLocal(isThreadLocal);
1257
1258       ValueList.push_back(NewGV);
1259
1260       // Remember which value to use for the global initializer.
1261       if (unsigned InitID = Record[2])
1262         GlobalInits.push_back(std::make_pair(NewGV, InitID-1));
1263       break;
1264     }
1265     // FUNCTION:  [type, callingconv, isproto, linkage, paramattr,
1266     //             alignment, section, visibility, gc]
1267     case bitc::MODULE_CODE_FUNCTION: {
1268       if (Record.size() < 8)
1269         return Error("Invalid MODULE_CODE_FUNCTION record");
1270       const Type *Ty = getTypeByID(Record[0]);
1271       if (!isa<PointerType>(Ty))
1272         return Error("Function not a pointer type!");
1273       const FunctionType *FTy =
1274         dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType());
1275       if (!FTy)
1276         return Error("Function not a pointer to function type!");
1277
1278       Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage,
1279                                         "", TheModule);
1280
1281       Func->setCallingConv(Record[1]);
1282       bool isProto = Record[2];
1283       Func->setLinkage(GetDecodedLinkage(Record[3]));
1284       Func->setAttributes(getAttributes(Record[4]));
1285
1286       Func->setAlignment((1 << Record[5]) >> 1);
1287       if (Record[6]) {
1288         if (Record[6]-1 >= SectionTable.size())
1289           return Error("Invalid section ID");
1290         Func->setSection(SectionTable[Record[6]-1]);
1291       }
1292       Func->setVisibility(GetDecodedVisibility(Record[7]));
1293       if (Record.size() > 8 && Record[8]) {
1294         if (Record[8]-1 > GCTable.size())
1295           return Error("Invalid GC ID");
1296         Func->setGC(GCTable[Record[8]-1].c_str());
1297       }
1298       ValueList.push_back(Func);
1299
1300       // If this is a function with a body, remember the prototype we are
1301       // creating now, so that we can match up the body with them later.
1302       if (!isProto)
1303         FunctionsWithBodies.push_back(Func);
1304       break;
1305     }
1306     // ALIAS: [alias type, aliasee val#, linkage]
1307     // ALIAS: [alias type, aliasee val#, linkage, visibility]
1308     case bitc::MODULE_CODE_ALIAS: {
1309       if (Record.size() < 3)
1310         return Error("Invalid MODULE_ALIAS record");
1311       const Type *Ty = getTypeByID(Record[0]);
1312       if (!isa<PointerType>(Ty))
1313         return Error("Function not a pointer type!");
1314
1315       GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]),
1316                                            "", 0, TheModule);
1317       // Old bitcode files didn't have visibility field.
1318       if (Record.size() > 3)
1319         NewGA->setVisibility(GetDecodedVisibility(Record[3]));
1320       ValueList.push_back(NewGA);
1321       AliasInits.push_back(std::make_pair(NewGA, Record[1]));
1322       break;
1323     }
1324     /// MODULE_CODE_PURGEVALS: [numvals]
1325     case bitc::MODULE_CODE_PURGEVALS:
1326       // Trim down the value list to the specified size.
1327       if (Record.size() < 1 || Record[0] > ValueList.size())
1328         return Error("Invalid MODULE_PURGEVALS record");
1329       ValueList.shrinkTo(Record[0]);
1330       break;
1331     }
1332     Record.clear();
1333   }
1334
1335   return Error("Premature end of bitstream");
1336 }
1337
1338 bool BitcodeReader::ParseBitcode() {
1339   TheModule = 0;
1340
1341   if (Buffer->getBufferSize() & 3)
1342     return Error("Bitcode stream should be a multiple of 4 bytes in length");
1343
1344   unsigned char *BufPtr = (unsigned char *)Buffer->getBufferStart();
1345   unsigned char *BufEnd = BufPtr+Buffer->getBufferSize();
1346
1347   // If we have a wrapper header, parse it and ignore the non-bc file contents.
1348   // The magic number is 0x0B17C0DE stored in little endian.
1349   if (isBitcodeWrapper(BufPtr, BufEnd))
1350     if (SkipBitcodeWrapperHeader(BufPtr, BufEnd))
1351       return Error("Invalid bitcode wrapper header");
1352
1353   StreamFile.init(BufPtr, BufEnd);
1354   Stream.init(StreamFile);
1355
1356   // Sniff for the signature.
1357   if (Stream.Read(8) != 'B' ||
1358       Stream.Read(8) != 'C' ||
1359       Stream.Read(4) != 0x0 ||
1360       Stream.Read(4) != 0xC ||
1361       Stream.Read(4) != 0xE ||
1362       Stream.Read(4) != 0xD)
1363     return Error("Invalid bitcode signature");
1364
1365   // We expect a number of well-defined blocks, though we don't necessarily
1366   // need to understand them all.
1367   while (!Stream.AtEndOfStream()) {
1368     unsigned Code = Stream.ReadCode();
1369
1370     if (Code != bitc::ENTER_SUBBLOCK)
1371       return Error("Invalid record at top-level");
1372
1373     unsigned BlockID = Stream.ReadSubBlockID();
1374
1375     // We only know the MODULE subblock ID.
1376     switch (BlockID) {
1377     case bitc::BLOCKINFO_BLOCK_ID:
1378       if (Stream.ReadBlockInfoBlock())
1379         return Error("Malformed BlockInfoBlock");
1380       break;
1381     case bitc::MODULE_BLOCK_ID:
1382       if (ParseModule(Buffer->getBufferIdentifier()))
1383         return true;
1384       break;
1385     default:
1386       if (Stream.SkipBlock())
1387         return Error("Malformed block record");
1388       break;
1389     }
1390   }
1391
1392   return false;
1393 }
1394
1395
1396 /// ParseFunctionBody - Lazily parse the specified function body block.
1397 bool BitcodeReader::ParseFunctionBody(Function *F) {
1398   if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))
1399     return Error("Malformed block record");
1400
1401   unsigned ModuleValueListSize = ValueList.size();
1402
1403   // Add all the function arguments to the value table.
1404   for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I)
1405     ValueList.push_back(I);
1406
1407   unsigned NextValueNo = ValueList.size();
1408   BasicBlock *CurBB = 0;
1409   unsigned CurBBNo = 0;
1410
1411   // Read all the records.
1412   SmallVector<uint64_t, 64> Record;
1413   while (1) {
1414     unsigned Code = Stream.ReadCode();
1415     if (Code == bitc::END_BLOCK) {
1416       if (Stream.ReadBlockEnd())
1417         return Error("Error at end of function block");
1418       break;
1419     }
1420
1421     if (Code == bitc::ENTER_SUBBLOCK) {
1422       switch (Stream.ReadSubBlockID()) {
1423       default:  // Skip unknown content.
1424         if (Stream.SkipBlock())
1425           return Error("Malformed block record");
1426         break;
1427       case bitc::CONSTANTS_BLOCK_ID:
1428         if (ParseConstants()) return true;
1429         NextValueNo = ValueList.size();
1430         break;
1431       case bitc::VALUE_SYMTAB_BLOCK_ID:
1432         if (ParseValueSymbolTable()) return true;
1433         break;
1434       }
1435       continue;
1436     }
1437
1438     if (Code == bitc::DEFINE_ABBREV) {
1439       Stream.ReadAbbrevRecord();
1440       continue;
1441     }
1442
1443     // Read a record.
1444     Record.clear();
1445     Instruction *I = 0;
1446     switch (Stream.ReadRecord(Code, Record)) {
1447     default: // Default behavior: reject
1448       return Error("Unknown instruction");
1449     case bitc::FUNC_CODE_DECLAREBLOCKS:     // DECLAREBLOCKS: [nblocks]
1450       if (Record.size() < 1 || Record[0] == 0)
1451         return Error("Invalid DECLAREBLOCKS record");
1452       // Create all the basic blocks for the function.
1453       FunctionBBs.resize(Record[0]);
1454       for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i)
1455         FunctionBBs[i] = BasicBlock::Create("", F);
1456       CurBB = FunctionBBs[0];
1457       continue;
1458
1459     case bitc::FUNC_CODE_INST_BINOP: {    // BINOP: [opval, ty, opval, opcode]
1460       unsigned OpNum = 0;
1461       Value *LHS, *RHS;
1462       if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
1463           getValue(Record, OpNum, LHS->getType(), RHS) ||
1464           OpNum+1 != Record.size())
1465         return Error("Invalid BINOP record");
1466
1467       int Opc = GetDecodedBinaryOpcode(Record[OpNum], LHS->getType());
1468       if (Opc == -1) return Error("Invalid BINOP record");
1469       I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
1470       break;
1471     }
1472     case bitc::FUNC_CODE_INST_CAST: {    // CAST: [opval, opty, destty, castopc]
1473       unsigned OpNum = 0;
1474       Value *Op;
1475       if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
1476           OpNum+2 != Record.size())
1477         return Error("Invalid CAST record");
1478
1479       const Type *ResTy = getTypeByID(Record[OpNum]);
1480       int Opc = GetDecodedCastOpcode(Record[OpNum+1]);
1481       if (Opc == -1 || ResTy == 0)
1482         return Error("Invalid CAST record");
1483       I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy);
1484       break;
1485     }
1486     case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands]
1487       unsigned OpNum = 0;
1488       Value *BasePtr;
1489       if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr))
1490         return Error("Invalid GEP record");
1491
1492       SmallVector<Value*, 16> GEPIdx;
1493       while (OpNum != Record.size()) {
1494         Value *Op;
1495         if (getValueTypePair(Record, OpNum, NextValueNo, Op))
1496           return Error("Invalid GEP record");
1497         GEPIdx.push_back(Op);
1498       }
1499
1500       I = GetElementPtrInst::Create(BasePtr, GEPIdx.begin(), GEPIdx.end());
1501       break;
1502     }
1503
1504     case bitc::FUNC_CODE_INST_EXTRACTVAL: {
1505                                        // EXTRACTVAL: [opty, opval, n x indices]
1506       unsigned OpNum = 0;
1507       Value *Agg;
1508       if (getValueTypePair(Record, OpNum, NextValueNo, Agg))
1509         return Error("Invalid EXTRACTVAL record");
1510
1511       SmallVector<unsigned, 4> EXTRACTVALIdx;
1512       for (unsigned RecSize = Record.size();
1513            OpNum != RecSize; ++OpNum) {
1514         uint64_t Index = Record[OpNum];
1515         if ((unsigned)Index != Index)
1516           return Error("Invalid EXTRACTVAL index");
1517         EXTRACTVALIdx.push_back((unsigned)Index);
1518       }
1519
1520       I = ExtractValueInst::Create(Agg,
1521                                    EXTRACTVALIdx.begin(), EXTRACTVALIdx.end());
1522       break;
1523     }
1524
1525     case bitc::FUNC_CODE_INST_INSERTVAL: {
1526                            // INSERTVAL: [opty, opval, opty, opval, n x indices]
1527       unsigned OpNum = 0;
1528       Value *Agg;
1529       if (getValueTypePair(Record, OpNum, NextValueNo, Agg))
1530         return Error("Invalid INSERTVAL record");
1531       Value *Val;
1532       if (getValueTypePair(Record, OpNum, NextValueNo, Val))
1533         return Error("Invalid INSERTVAL record");
1534
1535       SmallVector<unsigned, 4> INSERTVALIdx;
1536       for (unsigned RecSize = Record.size();
1537            OpNum != RecSize; ++OpNum) {
1538         uint64_t Index = Record[OpNum];
1539         if ((unsigned)Index != Index)
1540           return Error("Invalid INSERTVAL index");
1541         INSERTVALIdx.push_back((unsigned)Index);
1542       }
1543
1544       I = InsertValueInst::Create(Agg, Val,
1545                                   INSERTVALIdx.begin(), INSERTVALIdx.end());
1546       break;
1547     }
1548
1549     case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval]
1550       // obsolete form of select
1551       // handles select i1 ... in old bitcode
1552       unsigned OpNum = 0;
1553       Value *TrueVal, *FalseVal, *Cond;
1554       if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) ||
1555           getValue(Record, OpNum, TrueVal->getType(), FalseVal) ||
1556           getValue(Record, OpNum, Type::Int1Ty, Cond))
1557         return Error("Invalid SELECT record");
1558
1559       I = SelectInst::Create(Cond, TrueVal, FalseVal);
1560       break;
1561     }
1562
1563     case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred]
1564       // new form of select
1565       // handles select i1 or select [N x i1]
1566       unsigned OpNum = 0;
1567       Value *TrueVal, *FalseVal, *Cond;
1568       if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) ||
1569           getValue(Record, OpNum, TrueVal->getType(), FalseVal) ||
1570           getValueTypePair(Record, OpNum, NextValueNo, Cond))
1571         return Error("Invalid SELECT record");
1572
1573       // select condition can be either i1 or [N x i1]
1574       if (const VectorType* vector_type =
1575           dyn_cast<const VectorType>(Cond->getType())) {
1576         // expect <n x i1>
1577         if (vector_type->getElementType() != Type::Int1Ty)
1578           return Error("Invalid SELECT condition type");
1579       } else {
1580         // expect i1
1581         if (Cond->getType() != Type::Int1Ty)
1582           return Error("Invalid SELECT condition type");
1583       }
1584
1585       I = SelectInst::Create(Cond, TrueVal, FalseVal);
1586       break;
1587     }
1588
1589     case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval]
1590       unsigned OpNum = 0;
1591       Value *Vec, *Idx;
1592       if (getValueTypePair(Record, OpNum, NextValueNo, Vec) ||
1593           getValue(Record, OpNum, Type::Int32Ty, Idx))
1594         return Error("Invalid EXTRACTELT record");
1595       I = new ExtractElementInst(Vec, Idx);
1596       break;
1597     }
1598
1599     case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval]
1600       unsigned OpNum = 0;
1601       Value *Vec, *Elt, *Idx;
1602       if (getValueTypePair(Record, OpNum, NextValueNo, Vec) ||
1603           getValue(Record, OpNum,
1604                    cast<VectorType>(Vec->getType())->getElementType(), Elt) ||
1605           getValue(Record, OpNum, Type::Int32Ty, Idx))
1606         return Error("Invalid INSERTELT record");
1607       I = InsertElementInst::Create(Vec, Elt, Idx);
1608       break;
1609     }
1610
1611     case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval]
1612       unsigned OpNum = 0;
1613       Value *Vec1, *Vec2, *Mask;
1614       if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) ||
1615           getValue(Record, OpNum, Vec1->getType(), Vec2))
1616         return Error("Invalid SHUFFLEVEC record");
1617
1618       if (getValueTypePair(Record, OpNum, NextValueNo, Mask))
1619         return Error("Invalid SHUFFLEVEC record");
1620       I = new ShuffleVectorInst(Vec1, Vec2, Mask);
1621       break;
1622     }
1623
1624     case bitc::FUNC_CODE_INST_CMP: { // CMP: [opty, opval, opval, pred]
1625       // VFCmp/VICmp
1626       // or old form of ICmp/FCmp returning bool
1627       unsigned OpNum = 0;
1628       Value *LHS, *RHS;
1629       if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
1630           getValue(Record, OpNum, LHS->getType(), RHS) ||
1631           OpNum+1 != Record.size())
1632         return Error("Invalid CMP record");
1633
1634       if (LHS->getType()->isFloatingPoint())
1635         I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS);
1636       else if (!isa<VectorType>(LHS->getType()))
1637         I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS);
1638       else if (LHS->getType()->isFPOrFPVector())
1639         I = new VFCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS);
1640       else
1641         I = new VICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS);
1642       break;
1643     }
1644     case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred]
1645       // Fcmp/ICmp returning bool or vector of bool
1646       unsigned OpNum = 0;
1647       Value *LHS, *RHS;
1648       if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
1649           getValue(Record, OpNum, LHS->getType(), RHS) ||
1650           OpNum+1 != Record.size())
1651         return Error("Invalid CMP2 record");
1652
1653       if (LHS->getType()->isFPOrFPVector())
1654         I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS);
1655       else
1656         I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS);
1657       break;
1658     }
1659     case bitc::FUNC_CODE_INST_GETRESULT: { // GETRESULT: [ty, val, n]
1660       if (Record.size() != 2)
1661         return Error("Invalid GETRESULT record");
1662       unsigned OpNum = 0;
1663       Value *Op;
1664       getValueTypePair(Record, OpNum, NextValueNo, Op);
1665       unsigned Index = Record[1];
1666       I = ExtractValueInst::Create(Op, Index);
1667       break;
1668     }
1669
1670     case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>]
1671       {
1672         unsigned Size = Record.size();
1673         if (Size == 0) {
1674           I = ReturnInst::Create();
1675           break;
1676         }
1677
1678         unsigned OpNum = 0;
1679         SmallVector<Value *,4> Vs;
1680         do {
1681           Value *Op = NULL;
1682           if (getValueTypePair(Record, OpNum, NextValueNo, Op))
1683             return Error("Invalid RET record");
1684           Vs.push_back(Op);
1685         } while(OpNum != Record.size());
1686
1687         const Type *ReturnType = F->getReturnType();
1688         if (Vs.size() > 1 ||
1689             (isa<StructType>(ReturnType) &&
1690              (Vs.empty() || Vs[0]->getType() != ReturnType))) {
1691           Value *RV = UndefValue::get(ReturnType);
1692           for (unsigned i = 0, e = Vs.size(); i != e; ++i) {
1693             I = InsertValueInst::Create(RV, Vs[i], i, "mrv");
1694             CurBB->getInstList().push_back(I);
1695             ValueList.AssignValue(I, NextValueNo++);
1696             RV = I;
1697           }
1698           I = ReturnInst::Create(RV);
1699           break;
1700         }
1701
1702         I = ReturnInst::Create(Vs[0]);
1703         break;
1704       }
1705     case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#]
1706       if (Record.size() != 1 && Record.size() != 3)
1707         return Error("Invalid BR record");
1708       BasicBlock *TrueDest = getBasicBlock(Record[0]);
1709       if (TrueDest == 0)
1710         return Error("Invalid BR record");
1711
1712       if (Record.size() == 1)
1713         I = BranchInst::Create(TrueDest);
1714       else {
1715         BasicBlock *FalseDest = getBasicBlock(Record[1]);
1716         Value *Cond = getFnValueByID(Record[2], Type::Int1Ty);
1717         if (FalseDest == 0 || Cond == 0)
1718           return Error("Invalid BR record");
1719         I = BranchInst::Create(TrueDest, FalseDest, Cond);
1720       }
1721       break;
1722     }
1723     case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, opval, n, n x ops]
1724       if (Record.size() < 3 || (Record.size() & 1) == 0)
1725         return Error("Invalid SWITCH record");
1726       const Type *OpTy = getTypeByID(Record[0]);
1727       Value *Cond = getFnValueByID(Record[1], OpTy);
1728       BasicBlock *Default = getBasicBlock(Record[2]);
1729       if (OpTy == 0 || Cond == 0 || Default == 0)
1730         return Error("Invalid SWITCH record");
1731       unsigned NumCases = (Record.size()-3)/2;
1732       SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases);
1733       for (unsigned i = 0, e = NumCases; i != e; ++i) {
1734         ConstantInt *CaseVal =
1735           dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy));
1736         BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]);
1737         if (CaseVal == 0 || DestBB == 0) {
1738           delete SI;
1739           return Error("Invalid SWITCH record!");
1740         }
1741         SI->addCase(CaseVal, DestBB);
1742       }
1743       I = SI;
1744       break;
1745     }
1746
1747     case bitc::FUNC_CODE_INST_INVOKE: {
1748       // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...]
1749       if (Record.size() < 4) return Error("Invalid INVOKE record");
1750       AttrListPtr PAL = getAttributes(Record[0]);
1751       unsigned CCInfo = Record[1];
1752       BasicBlock *NormalBB = getBasicBlock(Record[2]);
1753       BasicBlock *UnwindBB = getBasicBlock(Record[3]);
1754
1755       unsigned OpNum = 4;
1756       Value *Callee;
1757       if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
1758         return Error("Invalid INVOKE record");
1759
1760       const PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType());
1761       const FunctionType *FTy = !CalleeTy ? 0 :
1762         dyn_cast<FunctionType>(CalleeTy->getElementType());
1763
1764       // Check that the right number of fixed parameters are here.
1765       if (FTy == 0 || NormalBB == 0 || UnwindBB == 0 ||
1766           Record.size() < OpNum+FTy->getNumParams())
1767         return Error("Invalid INVOKE record");
1768
1769       SmallVector<Value*, 16> Ops;
1770       for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
1771         Ops.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i)));
1772         if (Ops.back() == 0) return Error("Invalid INVOKE record");
1773       }
1774
1775       if (!FTy->isVarArg()) {
1776         if (Record.size() != OpNum)
1777           return Error("Invalid INVOKE record");
1778       } else {
1779         // Read type/value pairs for varargs params.
1780         while (OpNum != Record.size()) {
1781           Value *Op;
1782           if (getValueTypePair(Record, OpNum, NextValueNo, Op))
1783             return Error("Invalid INVOKE record");
1784           Ops.push_back(Op);
1785         }
1786       }
1787
1788       I = InvokeInst::Create(Callee, NormalBB, UnwindBB,
1789                              Ops.begin(), Ops.end());
1790       cast<InvokeInst>(I)->setCallingConv(CCInfo);
1791       cast<InvokeInst>(I)->setAttributes(PAL);
1792       break;
1793     }
1794     case bitc::FUNC_CODE_INST_UNWIND: // UNWIND
1795       I = new UnwindInst();
1796       break;
1797     case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE
1798       I = new UnreachableInst();
1799       break;
1800     case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...]
1801       if (Record.size() < 1 || ((Record.size()-1)&1))
1802         return Error("Invalid PHI record");
1803       const Type *Ty = getTypeByID(Record[0]);
1804       if (!Ty) return Error("Invalid PHI record");
1805
1806       PHINode *PN = PHINode::Create(Ty);
1807       PN->reserveOperandSpace((Record.size()-1)/2);
1808
1809       for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) {
1810         Value *V = getFnValueByID(Record[1+i], Ty);
1811         BasicBlock *BB = getBasicBlock(Record[2+i]);
1812         if (!V || !BB) return Error("Invalid PHI record");
1813         PN->addIncoming(V, BB);
1814       }
1815       I = PN;
1816       break;
1817     }
1818
1819     case bitc::FUNC_CODE_INST_MALLOC: { // MALLOC: [instty, op, align]
1820       if (Record.size() < 3)
1821         return Error("Invalid MALLOC record");
1822       const PointerType *Ty =
1823         dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
1824       Value *Size = getFnValueByID(Record[1], Type::Int32Ty);
1825       unsigned Align = Record[2];
1826       if (!Ty || !Size) return Error("Invalid MALLOC record");
1827       I = new MallocInst(Ty->getElementType(), Size, (1 << Align) >> 1);
1828       break;
1829     }
1830     case bitc::FUNC_CODE_INST_FREE: { // FREE: [op, opty]
1831       unsigned OpNum = 0;
1832       Value *Op;
1833       if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
1834           OpNum != Record.size())
1835         return Error("Invalid FREE record");
1836       I = new FreeInst(Op);
1837       break;
1838     }
1839     case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, op, align]
1840       if (Record.size() < 3)
1841         return Error("Invalid ALLOCA record");
1842       const PointerType *Ty =
1843         dyn_cast_or_null<PointerType>(getTypeByID(Record[0]));
1844       Value *Size = getFnValueByID(Record[1], Type::Int32Ty);
1845       unsigned Align = Record[2];
1846       if (!Ty || !Size) return Error("Invalid ALLOCA record");
1847       I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1);
1848       break;
1849     }
1850     case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol]
1851       unsigned OpNum = 0;
1852       Value *Op;
1853       if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
1854           OpNum+2 != Record.size())
1855         return Error("Invalid LOAD record");
1856
1857       I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1);
1858       break;
1859     }
1860     case bitc::FUNC_CODE_INST_STORE2: { // STORE2:[ptrty, ptr, val, align, vol]
1861       unsigned OpNum = 0;
1862       Value *Val, *Ptr;
1863       if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
1864           getValue(Record, OpNum,
1865                     cast<PointerType>(Ptr->getType())->getElementType(), Val) ||
1866           OpNum+2 != Record.size())
1867         return Error("Invalid STORE record");
1868
1869       I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1);
1870       break;
1871     }
1872     case bitc::FUNC_CODE_INST_STORE: { // STORE:[val, valty, ptr, align, vol]
1873       // FIXME: Legacy form of store instruction. Should be removed in LLVM 3.0.
1874       unsigned OpNum = 0;
1875       Value *Val, *Ptr;
1876       if (getValueTypePair(Record, OpNum, NextValueNo, Val) ||
1877           getValue(Record, OpNum, PointerType::getUnqual(Val->getType()), Ptr)||
1878           OpNum+2 != Record.size())
1879         return Error("Invalid STORE record");
1880
1881       I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1);
1882       break;
1883     }
1884     case bitc::FUNC_CODE_INST_CALL: {
1885       // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...]
1886       if (Record.size() < 3)
1887         return Error("Invalid CALL record");
1888
1889       AttrListPtr PAL = getAttributes(Record[0]);
1890       unsigned CCInfo = Record[1];
1891
1892       unsigned OpNum = 2;
1893       Value *Callee;
1894       if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
1895         return Error("Invalid CALL record");
1896
1897       const PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
1898       const FunctionType *FTy = 0;
1899       if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType());
1900       if (!FTy || Record.size() < FTy->getNumParams()+OpNum)
1901         return Error("Invalid CALL record");
1902
1903       SmallVector<Value*, 16> Args;
1904       // Read the fixed params.
1905       for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
1906         if (FTy->getParamType(i)->getTypeID()==Type::LabelTyID)
1907           Args.push_back(getBasicBlock(Record[OpNum]));
1908         else
1909           Args.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i)));
1910         if (Args.back() == 0) return Error("Invalid CALL record");
1911       }
1912
1913       // Read type/value pairs for varargs params.
1914       if (!FTy->isVarArg()) {
1915         if (OpNum != Record.size())
1916           return Error("Invalid CALL record");
1917       } else {
1918         while (OpNum != Record.size()) {
1919           Value *Op;
1920           if (getValueTypePair(Record, OpNum, NextValueNo, Op))
1921             return Error("Invalid CALL record");
1922           Args.push_back(Op);
1923         }
1924       }
1925
1926       I = CallInst::Create(Callee, Args.begin(), Args.end());
1927       cast<CallInst>(I)->setCallingConv(CCInfo>>1);
1928       cast<CallInst>(I)->setTailCall(CCInfo & 1);
1929       cast<CallInst>(I)->setAttributes(PAL);
1930       break;
1931     }
1932     case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty]
1933       if (Record.size() < 3)
1934         return Error("Invalid VAARG record");
1935       const Type *OpTy = getTypeByID(Record[0]);
1936       Value *Op = getFnValueByID(Record[1], OpTy);
1937       const Type *ResTy = getTypeByID(Record[2]);
1938       if (!OpTy || !Op || !ResTy)
1939         return Error("Invalid VAARG record");
1940       I = new VAArgInst(Op, ResTy);
1941       break;
1942     }
1943     }
1944
1945     // Add instruction to end of current BB.  If there is no current BB, reject
1946     // this file.
1947     if (CurBB == 0) {
1948       delete I;
1949       return Error("Invalid instruction with no BB");
1950     }
1951     CurBB->getInstList().push_back(I);
1952
1953     // If this was a terminator instruction, move to the next block.
1954     if (isa<TerminatorInst>(I)) {
1955       ++CurBBNo;
1956       CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0;
1957     }
1958
1959     // Non-void values get registered in the value table for future use.
1960     if (I && I->getType() != Type::VoidTy)
1961       ValueList.AssignValue(I, NextValueNo++);
1962   }
1963
1964   // Check the function list for unresolved values.
1965   if (Argument *A = dyn_cast<Argument>(ValueList.back())) {
1966     if (A->getParent() == 0) {
1967       // We found at least one unresolved value.  Nuke them all to avoid leaks.
1968       for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){
1969         if ((A = dyn_cast<Argument>(ValueList.back())) && A->getParent() == 0) {
1970           A->replaceAllUsesWith(UndefValue::get(A->getType()));
1971           delete A;
1972         }
1973       }
1974       return Error("Never resolved value found in function!");
1975     }
1976   }
1977
1978   // Trim the value list down to the size it was before we parsed this function.
1979   ValueList.shrinkTo(ModuleValueListSize);
1980   std::vector<BasicBlock*>().swap(FunctionBBs);
1981
1982   return false;
1983 }
1984
1985 //===----------------------------------------------------------------------===//
1986 // ModuleProvider implementation
1987 //===----------------------------------------------------------------------===//
1988
1989
1990 bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo) {
1991   // If it already is material, ignore the request.
1992   if (!F->hasNotBeenReadFromBitcode()) return false;
1993
1994   DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator DFII =
1995     DeferredFunctionInfo.find(F);
1996   assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!");
1997
1998   // Move the bit stream to the saved position of the deferred function body and
1999   // restore the real linkage type for the function.
2000   Stream.JumpToBit(DFII->second.first);
2001   F->setLinkage((GlobalValue::LinkageTypes)DFII->second.second);
2002
2003   if (ParseFunctionBody(F)) {
2004     if (ErrInfo) *ErrInfo = ErrorString;
2005     return true;
2006   }
2007
2008   // Upgrade any old intrinsic calls in the function.
2009   for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(),
2010        E = UpgradedIntrinsics.end(); I != E; ++I) {
2011     if (I->first != I->second) {
2012       for (Value::use_iterator UI = I->first->use_begin(),
2013            UE = I->first->use_end(); UI != UE; ) {
2014         if (CallInst* CI = dyn_cast<CallInst>(*UI++))
2015           UpgradeIntrinsicCall(CI, I->second);
2016       }
2017     }
2018   }
2019
2020   return false;
2021 }
2022
2023 void BitcodeReader::dematerializeFunction(Function *F) {
2024   // If this function isn't materialized, or if it is a proto, this is a noop.
2025   if (F->hasNotBeenReadFromBitcode() || F->isDeclaration())
2026     return;
2027
2028   assert(DeferredFunctionInfo.count(F) && "No info to read function later?");
2029
2030   // Just forget the function body, we can remat it later.
2031   F->deleteBody();
2032   F->setLinkage(GlobalValue::GhostLinkage);
2033 }
2034
2035
2036 Module *BitcodeReader::materializeModule(std::string *ErrInfo) {
2037   for (DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator I =
2038        DeferredFunctionInfo.begin(), E = DeferredFunctionInfo.end(); I != E;
2039        ++I) {
2040     Function *F = I->first;
2041     if (F->hasNotBeenReadFromBitcode() &&
2042         materializeFunction(F, ErrInfo))
2043       return 0;
2044   }
2045
2046   // Upgrade any intrinsic calls that slipped through (should not happen!) and
2047   // delete the old functions to clean up. We can't do this unless the entire
2048   // module is materialized because there could always be another function body
2049   // with calls to the old function.
2050   for (std::vector<std::pair<Function*, Function*> >::iterator I =
2051        UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) {
2052     if (I->first != I->second) {
2053       for (Value::use_iterator UI = I->first->use_begin(),
2054            UE = I->first->use_end(); UI != UE; ) {
2055         if (CallInst* CI = dyn_cast<CallInst>(*UI++))
2056           UpgradeIntrinsicCall(CI, I->second);
2057       }
2058       if (!I->first->use_empty())
2059         I->first->replaceAllUsesWith(I->second);
2060       I->first->eraseFromParent();
2061     }
2062   }
2063   std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics);
2064
2065   return TheModule;
2066 }
2067
2068
2069 /// This method is provided by the parent ModuleProvde class and overriden
2070 /// here. It simply releases the module from its provided and frees up our
2071 /// state.
2072 /// @brief Release our hold on the generated module
2073 Module *BitcodeReader::releaseModule(std::string *ErrInfo) {
2074   // Since we're losing control of this Module, we must hand it back complete
2075   Module *M = ModuleProvider::releaseModule(ErrInfo);
2076   FreeState();
2077   return M;
2078 }
2079
2080
2081 //===----------------------------------------------------------------------===//
2082 // External interface
2083 //===----------------------------------------------------------------------===//
2084
2085 /// getBitcodeModuleProvider - lazy function-at-a-time loading from a file.
2086 ///
2087 ModuleProvider *llvm::getBitcodeModuleProvider(MemoryBuffer *Buffer,
2088                                                std::string *ErrMsg) {
2089   BitcodeReader *R = new BitcodeReader(Buffer);
2090   if (R->ParseBitcode()) {
2091     if (ErrMsg)
2092       *ErrMsg = R->getErrorString();
2093
2094     // Don't let the BitcodeReader dtor delete 'Buffer'.
2095     R->releaseMemoryBuffer();
2096     delete R;
2097     return 0;
2098   }
2099   return R;
2100 }
2101
2102 /// ParseBitcodeFile - Read the specified bitcode file, returning the module.
2103 /// If an error occurs, return null and fill in *ErrMsg if non-null.
2104 Module *llvm::ParseBitcodeFile(MemoryBuffer *Buffer, std::string *ErrMsg){
2105   BitcodeReader *R;
2106   R = static_cast<BitcodeReader*>(getBitcodeModuleProvider(Buffer, ErrMsg));
2107   if (!R) return 0;
2108
2109   // Read in the entire module.
2110   Module *M = R->materializeModule(ErrMsg);
2111
2112   // Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether
2113   // there was an error.
2114   R->releaseMemoryBuffer();
2115
2116   // If there was no error, tell ModuleProvider not to delete it when its dtor
2117   // is run.
2118   if (M)
2119     M = R->releaseModule(ErrMsg);
2120
2121   delete R;
2122   return M;
2123 }