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