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