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