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