BitcodeReader.cpp revision 67c619ba3eae68dcdb3f9340d82b33173aa0c256
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/IntrinsicInst.h" 20#include "llvm/Module.h" 21#include "llvm/Operator.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 if (BufferOwned) 32 delete Buffer; 33 Buffer = 0; 34 std::vector<PATypeHolder>().swap(TypeList); 35 ValueList.clear(); 36 MDValueList.clear(); 37 38 std::vector<AttrListPtr>().swap(MAttributes); 39 std::vector<BasicBlock*>().swap(FunctionBBs); 40 std::vector<Function*>().swap(FunctionsWithBodies); 41 DeferredFunctionInfo.clear(); 42 MDKindMap.clear(); 43} 44 45//===----------------------------------------------------------------------===// 46// Helper functions to implement forward reference resolution, etc. 47//===----------------------------------------------------------------------===// 48 49/// ConvertToString - Convert a string from a record into an std::string, return 50/// true on failure. 51template<typename StrTy> 52static bool ConvertToString(SmallVector<uint64_t, 64> &Record, unsigned Idx, 53 StrTy &Result) { 54 if (Idx > Record.size()) 55 return true; 56 57 for (unsigned i = Idx, e = Record.size(); i != e; ++i) 58 Result += (char)Record[i]; 59 return false; 60} 61 62static GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) { 63 switch (Val) { 64 default: // Map unknown/new linkages to external 65 case 0: return GlobalValue::ExternalLinkage; 66 case 1: return GlobalValue::WeakAnyLinkage; 67 case 2: return GlobalValue::AppendingLinkage; 68 case 3: return GlobalValue::InternalLinkage; 69 case 4: return GlobalValue::LinkOnceAnyLinkage; 70 case 5: return GlobalValue::DLLImportLinkage; 71 case 6: return GlobalValue::DLLExportLinkage; 72 case 7: return GlobalValue::ExternalWeakLinkage; 73 case 8: return GlobalValue::CommonLinkage; 74 case 9: return GlobalValue::PrivateLinkage; 75 case 10: return GlobalValue::WeakODRLinkage; 76 case 11: return GlobalValue::LinkOnceODRLinkage; 77 case 12: return GlobalValue::AvailableExternallyLinkage; 78 case 13: return GlobalValue::LinkerPrivateLinkage; 79 case 14: return GlobalValue::LinkerPrivateWeakLinkage; 80 case 15: return GlobalValue::LinkerPrivateWeakDefAutoLinkage; 81 } 82} 83 84static GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) { 85 switch (Val) { 86 default: // Map unknown visibilities to default. 87 case 0: return GlobalValue::DefaultVisibility; 88 case 1: return GlobalValue::HiddenVisibility; 89 case 2: return GlobalValue::ProtectedVisibility; 90 } 91} 92 93static int GetDecodedCastOpcode(unsigned Val) { 94 switch (Val) { 95 default: return -1; 96 case bitc::CAST_TRUNC : return Instruction::Trunc; 97 case bitc::CAST_ZEXT : return Instruction::ZExt; 98 case bitc::CAST_SEXT : return Instruction::SExt; 99 case bitc::CAST_FPTOUI : return Instruction::FPToUI; 100 case bitc::CAST_FPTOSI : return Instruction::FPToSI; 101 case bitc::CAST_UITOFP : return Instruction::UIToFP; 102 case bitc::CAST_SITOFP : return Instruction::SIToFP; 103 case bitc::CAST_FPTRUNC : return Instruction::FPTrunc; 104 case bitc::CAST_FPEXT : return Instruction::FPExt; 105 case bitc::CAST_PTRTOINT: return Instruction::PtrToInt; 106 case bitc::CAST_INTTOPTR: return Instruction::IntToPtr; 107 case bitc::CAST_BITCAST : return Instruction::BitCast; 108 } 109} 110static int GetDecodedBinaryOpcode(unsigned Val, const Type *Ty) { 111 switch (Val) { 112 default: return -1; 113 case bitc::BINOP_ADD: 114 return Ty->isFPOrFPVectorTy() ? Instruction::FAdd : Instruction::Add; 115 case bitc::BINOP_SUB: 116 return Ty->isFPOrFPVectorTy() ? Instruction::FSub : Instruction::Sub; 117 case bitc::BINOP_MUL: 118 return Ty->isFPOrFPVectorTy() ? Instruction::FMul : Instruction::Mul; 119 case bitc::BINOP_UDIV: return Instruction::UDiv; 120 case bitc::BINOP_SDIV: 121 return Ty->isFPOrFPVectorTy() ? Instruction::FDiv : Instruction::SDiv; 122 case bitc::BINOP_UREM: return Instruction::URem; 123 case bitc::BINOP_SREM: 124 return Ty->isFPOrFPVectorTy() ? Instruction::FRem : Instruction::SRem; 125 case bitc::BINOP_SHL: return Instruction::Shl; 126 case bitc::BINOP_LSHR: return Instruction::LShr; 127 case bitc::BINOP_ASHR: return Instruction::AShr; 128 case bitc::BINOP_AND: return Instruction::And; 129 case bitc::BINOP_OR: return Instruction::Or; 130 case bitc::BINOP_XOR: return Instruction::Xor; 131 } 132} 133 134namespace llvm { 135namespace { 136 /// @brief A class for maintaining the slot number definition 137 /// as a placeholder for the actual definition for forward constants defs. 138 class ConstantPlaceHolder : public ConstantExpr { 139 void operator=(const ConstantPlaceHolder &); // DO NOT IMPLEMENT 140 public: 141 // allocate space for exactly one operand 142 void *operator new(size_t s) { 143 return User::operator new(s, 1); 144 } 145 explicit ConstantPlaceHolder(const Type *Ty, LLVMContext& Context) 146 : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) { 147 Op<0>() = UndefValue::get(Type::getInt32Ty(Context)); 148 } 149 150 /// @brief Methods to support type inquiry through isa, cast, and dyn_cast. 151 //static inline bool classof(const ConstantPlaceHolder *) { return true; } 152 static bool classof(const Value *V) { 153 return isa<ConstantExpr>(V) && 154 cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1; 155 } 156 157 158 /// Provide fast operand accessors 159 //DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 160 }; 161} 162 163// FIXME: can we inherit this from ConstantExpr? 164template <> 165struct OperandTraits<ConstantPlaceHolder> : 166 public FixedNumOperandTraits<ConstantPlaceHolder, 1> { 167}; 168} 169 170 171void BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) { 172 if (Idx == size()) { 173 push_back(V); 174 return; 175 } 176 177 if (Idx >= size()) 178 resize(Idx+1); 179 180 WeakVH &OldV = ValuePtrs[Idx]; 181 if (OldV == 0) { 182 OldV = V; 183 return; 184 } 185 186 // Handle constants and non-constants (e.g. instrs) differently for 187 // efficiency. 188 if (Constant *PHC = dyn_cast<Constant>(&*OldV)) { 189 ResolveConstants.push_back(std::make_pair(PHC, Idx)); 190 OldV = V; 191 } else { 192 // If there was a forward reference to this value, replace it. 193 Value *PrevVal = OldV; 194 OldV->replaceAllUsesWith(V); 195 delete PrevVal; 196 } 197} 198 199 200Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, 201 const Type *Ty) { 202 if (Idx >= size()) 203 resize(Idx + 1); 204 205 if (Value *V = ValuePtrs[Idx]) { 206 assert(Ty == V->getType() && "Type mismatch in constant table!"); 207 return cast<Constant>(V); 208 } 209 210 // Create and return a placeholder, which will later be RAUW'd. 211 Constant *C = new ConstantPlaceHolder(Ty, Context); 212 ValuePtrs[Idx] = C; 213 return C; 214} 215 216Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, const Type *Ty) { 217 if (Idx >= size()) 218 resize(Idx + 1); 219 220 if (Value *V = ValuePtrs[Idx]) { 221 assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!"); 222 return V; 223 } 224 225 // No type specified, must be invalid reference. 226 if (Ty == 0) return 0; 227 228 // Create and return a placeholder, which will later be RAUW'd. 229 Value *V = new Argument(Ty); 230 ValuePtrs[Idx] = V; 231 return V; 232} 233 234/// ResolveConstantForwardRefs - Once all constants are read, this method bulk 235/// resolves any forward references. The idea behind this is that we sometimes 236/// get constants (such as large arrays) which reference *many* forward ref 237/// constants. Replacing each of these causes a lot of thrashing when 238/// building/reuniquing the constant. Instead of doing this, we look at all the 239/// uses and rewrite all the place holders at once for any constant that uses 240/// a placeholder. 241void BitcodeReaderValueList::ResolveConstantForwardRefs() { 242 // Sort the values by-pointer so that they are efficient to look up with a 243 // binary search. 244 std::sort(ResolveConstants.begin(), ResolveConstants.end()); 245 246 SmallVector<Constant*, 64> NewOps; 247 248 while (!ResolveConstants.empty()) { 249 Value *RealVal = operator[](ResolveConstants.back().second); 250 Constant *Placeholder = ResolveConstants.back().first; 251 ResolveConstants.pop_back(); 252 253 // Loop over all users of the placeholder, updating them to reference the 254 // new value. If they reference more than one placeholder, update them all 255 // at once. 256 while (!Placeholder->use_empty()) { 257 Value::use_iterator UI = Placeholder->use_begin(); 258 User *U = *UI; 259 260 // If the using object isn't uniqued, just update the operands. This 261 // handles instructions and initializers for global variables. 262 if (!isa<Constant>(U) || isa<GlobalValue>(U)) { 263 UI.getUse().set(RealVal); 264 continue; 265 } 266 267 // Otherwise, we have a constant that uses the placeholder. Replace that 268 // constant with a new constant that has *all* placeholder uses updated. 269 Constant *UserC = cast<Constant>(U); 270 for (User::op_iterator I = UserC->op_begin(), E = UserC->op_end(); 271 I != E; ++I) { 272 Value *NewOp; 273 if (!isa<ConstantPlaceHolder>(*I)) { 274 // Not a placeholder reference. 275 NewOp = *I; 276 } else if (*I == Placeholder) { 277 // Common case is that it just references this one placeholder. 278 NewOp = RealVal; 279 } else { 280 // Otherwise, look up the placeholder in ResolveConstants. 281 ResolveConstantsTy::iterator It = 282 std::lower_bound(ResolveConstants.begin(), ResolveConstants.end(), 283 std::pair<Constant*, unsigned>(cast<Constant>(*I), 284 0)); 285 assert(It != ResolveConstants.end() && It->first == *I); 286 NewOp = operator[](It->second); 287 } 288 289 NewOps.push_back(cast<Constant>(NewOp)); 290 } 291 292 // Make the new constant. 293 Constant *NewC; 294 if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) { 295 NewC = ConstantArray::get(UserCA->getType(), &NewOps[0], 296 NewOps.size()); 297 } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) { 298 NewC = ConstantStruct::get(Context, &NewOps[0], NewOps.size(), 299 UserCS->getType()->isPacked()); 300 } else if (isa<ConstantVector>(UserC)) { 301 NewC = ConstantVector::get(&NewOps[0], NewOps.size()); 302 } else { 303 assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr."); 304 NewC = cast<ConstantExpr>(UserC)->getWithOperands(&NewOps[0], 305 NewOps.size()); 306 } 307 308 UserC->replaceAllUsesWith(NewC); 309 UserC->destroyConstant(); 310 NewOps.clear(); 311 } 312 313 // Update all ValueHandles, they should be the only users at this point. 314 Placeholder->replaceAllUsesWith(RealVal); 315 delete Placeholder; 316 } 317} 318 319void BitcodeReaderMDValueList::AssignValue(Value *V, unsigned Idx) { 320 if (Idx == size()) { 321 push_back(V); 322 return; 323 } 324 325 if (Idx >= size()) 326 resize(Idx+1); 327 328 WeakVH &OldV = MDValuePtrs[Idx]; 329 if (OldV == 0) { 330 OldV = V; 331 return; 332 } 333 334 // If there was a forward reference to this value, replace it. 335 MDNode *PrevVal = cast<MDNode>(OldV); 336 OldV->replaceAllUsesWith(V); 337 MDNode::deleteTemporary(PrevVal); 338 // Deleting PrevVal sets Idx value in MDValuePtrs to null. Set new 339 // value for Idx. 340 MDValuePtrs[Idx] = V; 341} 342 343Value *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { 344 if (Idx >= size()) 345 resize(Idx + 1); 346 347 if (Value *V = MDValuePtrs[Idx]) { 348 assert(V->getType()->isMetadataTy() && "Type mismatch in value table!"); 349 return V; 350 } 351 352 // Create and return a placeholder, which will later be RAUW'd. 353 Value *V = MDNode::getTemporary(Context, 0, 0); 354 MDValuePtrs[Idx] = V; 355 return V; 356} 357 358const Type *BitcodeReader::getTypeByID(unsigned ID, bool isTypeTable) { 359 // If the TypeID is in range, return it. 360 if (ID < TypeList.size()) 361 return TypeList[ID].get(); 362 if (!isTypeTable) return 0; 363 364 // The type table allows forward references. Push as many Opaque types as 365 // needed to get up to ID. 366 while (TypeList.size() <= ID) 367 TypeList.push_back(OpaqueType::get(Context)); 368 return TypeList.back().get(); 369} 370 371//===----------------------------------------------------------------------===// 372// Functions for parsing blocks from the bitcode file 373//===----------------------------------------------------------------------===// 374 375bool BitcodeReader::ParseAttributeBlock() { 376 if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) 377 return Error("Malformed block record"); 378 379 if (!MAttributes.empty()) 380 return Error("Multiple PARAMATTR blocks found!"); 381 382 SmallVector<uint64_t, 64> Record; 383 384 SmallVector<AttributeWithIndex, 8> Attrs; 385 386 // Read all the records. 387 while (1) { 388 unsigned Code = Stream.ReadCode(); 389 if (Code == bitc::END_BLOCK) { 390 if (Stream.ReadBlockEnd()) 391 return Error("Error at end of PARAMATTR block"); 392 return false; 393 } 394 395 if (Code == bitc::ENTER_SUBBLOCK) { 396 // No known subblocks, always skip them. 397 Stream.ReadSubBlockID(); 398 if (Stream.SkipBlock()) 399 return Error("Malformed block record"); 400 continue; 401 } 402 403 if (Code == bitc::DEFINE_ABBREV) { 404 Stream.ReadAbbrevRecord(); 405 continue; 406 } 407 408 // Read a record. 409 Record.clear(); 410 switch (Stream.ReadRecord(Code, Record)) { 411 default: // Default behavior: ignore. 412 break; 413 case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [paramidx0, attr0, ...] 414 if (Record.size() & 1) 415 return Error("Invalid ENTRY record"); 416 417 // FIXME : Remove this autoupgrade code in LLVM 3.0. 418 // If Function attributes are using index 0 then transfer them 419 // to index ~0. Index 0 is used for return value attributes but used to be 420 // used for function attributes. 421 Attributes RetAttribute = Attribute::None; 422 Attributes FnAttribute = Attribute::None; 423 for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 424 // FIXME: remove in LLVM 3.0 425 // The alignment is stored as a 16-bit raw value from bits 31--16. 426 // We shift the bits above 31 down by 11 bits. 427 428 unsigned Alignment = (Record[i+1] & (0xffffull << 16)) >> 16; 429 if (Alignment && !isPowerOf2_32(Alignment)) 430 return Error("Alignment is not a power of two."); 431 432 Attributes ReconstitutedAttr = Record[i+1] & 0xffff; 433 if (Alignment) 434 ReconstitutedAttr |= Attribute::constructAlignmentFromInt(Alignment); 435 ReconstitutedAttr |= (Record[i+1] & (0xffffull << 32)) >> 11; 436 Record[i+1] = ReconstitutedAttr; 437 438 if (Record[i] == 0) 439 RetAttribute = Record[i+1]; 440 else if (Record[i] == ~0U) 441 FnAttribute = Record[i+1]; 442 } 443 444 unsigned OldRetAttrs = (Attribute::NoUnwind|Attribute::NoReturn| 445 Attribute::ReadOnly|Attribute::ReadNone); 446 447 if (FnAttribute == Attribute::None && RetAttribute != Attribute::None && 448 (RetAttribute & OldRetAttrs) != 0) { 449 if (FnAttribute == Attribute::None) { // add a slot so they get added. 450 Record.push_back(~0U); 451 Record.push_back(0); 452 } 453 454 FnAttribute |= RetAttribute & OldRetAttrs; 455 RetAttribute &= ~OldRetAttrs; 456 } 457 458 for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 459 if (Record[i] == 0) { 460 if (RetAttribute != Attribute::None) 461 Attrs.push_back(AttributeWithIndex::get(0, RetAttribute)); 462 } else if (Record[i] == ~0U) { 463 if (FnAttribute != Attribute::None) 464 Attrs.push_back(AttributeWithIndex::get(~0U, FnAttribute)); 465 } else if (Record[i+1] != Attribute::None) 466 Attrs.push_back(AttributeWithIndex::get(Record[i], Record[i+1])); 467 } 468 469 MAttributes.push_back(AttrListPtr::get(Attrs.begin(), Attrs.end())); 470 Attrs.clear(); 471 break; 472 } 473 } 474 } 475} 476 477 478bool BitcodeReader::ParseTypeTable() { 479 if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID)) 480 return Error("Malformed block record"); 481 482 if (!TypeList.empty()) 483 return Error("Multiple TYPE_BLOCKs found!"); 484 485 SmallVector<uint64_t, 64> Record; 486 unsigned NumRecords = 0; 487 488 // Read all the records for this type table. 489 while (1) { 490 unsigned Code = Stream.ReadCode(); 491 if (Code == bitc::END_BLOCK) { 492 if (NumRecords != TypeList.size()) 493 return Error("Invalid type forward reference in TYPE_BLOCK"); 494 if (Stream.ReadBlockEnd()) 495 return Error("Error at end of type table block"); 496 return false; 497 } 498 499 if (Code == bitc::ENTER_SUBBLOCK) { 500 // No known subblocks, always skip them. 501 Stream.ReadSubBlockID(); 502 if (Stream.SkipBlock()) 503 return Error("Malformed block record"); 504 continue; 505 } 506 507 if (Code == bitc::DEFINE_ABBREV) { 508 Stream.ReadAbbrevRecord(); 509 continue; 510 } 511 512 // Read a record. 513 Record.clear(); 514 const Type *ResultTy = 0; 515 switch (Stream.ReadRecord(Code, Record)) { 516 default: // Default behavior: unknown type. 517 ResultTy = 0; 518 break; 519 case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 520 // TYPE_CODE_NUMENTRY contains a count of the number of types in the 521 // type list. This allows us to reserve space. 522 if (Record.size() < 1) 523 return Error("Invalid TYPE_CODE_NUMENTRY record"); 524 TypeList.reserve(Record[0]); 525 continue; 526 case bitc::TYPE_CODE_VOID: // VOID 527 ResultTy = Type::getVoidTy(Context); 528 break; 529 case bitc::TYPE_CODE_FLOAT: // FLOAT 530 ResultTy = Type::getFloatTy(Context); 531 break; 532 case bitc::TYPE_CODE_DOUBLE: // DOUBLE 533 ResultTy = Type::getDoubleTy(Context); 534 break; 535 case bitc::TYPE_CODE_X86_FP80: // X86_FP80 536 ResultTy = Type::getX86_FP80Ty(Context); 537 break; 538 case bitc::TYPE_CODE_FP128: // FP128 539 ResultTy = Type::getFP128Ty(Context); 540 break; 541 case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 542 ResultTy = Type::getPPC_FP128Ty(Context); 543 break; 544 case bitc::TYPE_CODE_LABEL: // LABEL 545 ResultTy = Type::getLabelTy(Context); 546 break; 547 case bitc::TYPE_CODE_OPAQUE: // OPAQUE 548 ResultTy = 0; 549 break; 550 case bitc::TYPE_CODE_METADATA: // METADATA 551 ResultTy = Type::getMetadataTy(Context); 552 break; 553 case bitc::TYPE_CODE_X86_MMX: // X86_MMX 554 ResultTy = Type::getX86_MMXTy(Context); 555 break; 556 case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 557 if (Record.size() < 1) 558 return Error("Invalid Integer type record"); 559 560 ResultTy = IntegerType::get(Context, Record[0]); 561 break; 562 case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 563 // [pointee type, address space] 564 if (Record.size() < 1) 565 return Error("Invalid POINTER type record"); 566 unsigned AddressSpace = 0; 567 if (Record.size() == 2) 568 AddressSpace = Record[1]; 569 ResultTy = PointerType::get(getTypeByID(Record[0], true), 570 AddressSpace); 571 break; 572 } 573 case bitc::TYPE_CODE_FUNCTION: { 574 // FIXME: attrid is dead, remove it in LLVM 3.0 575 // FUNCTION: [vararg, attrid, retty, paramty x N] 576 if (Record.size() < 3) 577 return Error("Invalid FUNCTION type record"); 578 std::vector<const Type*> ArgTys; 579 for (unsigned i = 3, e = Record.size(); i != e; ++i) 580 ArgTys.push_back(getTypeByID(Record[i], true)); 581 582 ResultTy = FunctionType::get(getTypeByID(Record[2], true), ArgTys, 583 Record[0]); 584 break; 585 } 586 case bitc::TYPE_CODE_STRUCT: { // STRUCT: [ispacked, eltty x N] 587 if (Record.size() < 1) 588 return Error("Invalid STRUCT type record"); 589 std::vector<const Type*> EltTys; 590 for (unsigned i = 1, e = Record.size(); i != e; ++i) 591 EltTys.push_back(getTypeByID(Record[i], true)); 592 ResultTy = StructType::get(Context, EltTys, Record[0]); 593 break; 594 } 595 case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 596 if (Record.size() < 2) 597 return Error("Invalid ARRAY type record"); 598 ResultTy = ArrayType::get(getTypeByID(Record[1], true), Record[0]); 599 break; 600 case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 601 if (Record.size() < 2) 602 return Error("Invalid VECTOR type record"); 603 ResultTy = VectorType::get(getTypeByID(Record[1], true), Record[0]); 604 break; 605 } 606 607 if (NumRecords == TypeList.size()) { 608 // If this is a new type slot, just append it. 609 TypeList.push_back(ResultTy ? ResultTy : OpaqueType::get(Context)); 610 ++NumRecords; 611 } else if (ResultTy == 0) { 612 // Otherwise, this was forward referenced, so an opaque type was created, 613 // but the result type is actually just an opaque. Leave the one we 614 // created previously. 615 ++NumRecords; 616 } else { 617 // Otherwise, this was forward referenced, so an opaque type was created. 618 // Resolve the opaque type to the real type now. 619 assert(NumRecords < TypeList.size() && "Typelist imbalance"); 620 const OpaqueType *OldTy = cast<OpaqueType>(TypeList[NumRecords++].get()); 621 622 // Don't directly push the new type on the Tab. Instead we want to replace 623 // the opaque type we previously inserted with the new concrete value. The 624 // refinement from the abstract (opaque) type to the new type causes all 625 // uses of the abstract type to use the concrete type (NewTy). This will 626 // also cause the opaque type to be deleted. 627 const_cast<OpaqueType*>(OldTy)->refineAbstractTypeTo(ResultTy); 628 629 // This should have replaced the old opaque type with the new type in the 630 // value table... or with a preexisting type that was already in the 631 // system. Let's just make sure it did. 632 assert(TypeList[NumRecords-1].get() != OldTy && 633 "refineAbstractType didn't work!"); 634 } 635 } 636} 637 638 639bool BitcodeReader::ParseTypeSymbolTable() { 640 if (Stream.EnterSubBlock(bitc::TYPE_SYMTAB_BLOCK_ID)) 641 return Error("Malformed block record"); 642 643 SmallVector<uint64_t, 64> Record; 644 645 // Read all the records for this type table. 646 std::string TypeName; 647 while (1) { 648 unsigned Code = Stream.ReadCode(); 649 if (Code == bitc::END_BLOCK) { 650 if (Stream.ReadBlockEnd()) 651 return Error("Error at end of type symbol table block"); 652 return false; 653 } 654 655 if (Code == bitc::ENTER_SUBBLOCK) { 656 // No known subblocks, always skip them. 657 Stream.ReadSubBlockID(); 658 if (Stream.SkipBlock()) 659 return Error("Malformed block record"); 660 continue; 661 } 662 663 if (Code == bitc::DEFINE_ABBREV) { 664 Stream.ReadAbbrevRecord(); 665 continue; 666 } 667 668 // Read a record. 669 Record.clear(); 670 switch (Stream.ReadRecord(Code, Record)) { 671 default: // Default behavior: unknown type. 672 break; 673 case bitc::TST_CODE_ENTRY: // TST_ENTRY: [typeid, namechar x N] 674 if (ConvertToString(Record, 1, TypeName)) 675 return Error("Invalid TST_ENTRY record"); 676 unsigned TypeID = Record[0]; 677 if (TypeID >= TypeList.size()) 678 return Error("Invalid Type ID in TST_ENTRY record"); 679 680 TheModule->addTypeName(TypeName, TypeList[TypeID].get()); 681 TypeName.clear(); 682 break; 683 } 684 } 685} 686 687bool BitcodeReader::ParseValueSymbolTable() { 688 if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) 689 return Error("Malformed block record"); 690 691 SmallVector<uint64_t, 64> Record; 692 693 // Read all the records for this value table. 694 SmallString<128> ValueName; 695 while (1) { 696 unsigned Code = Stream.ReadCode(); 697 if (Code == bitc::END_BLOCK) { 698 if (Stream.ReadBlockEnd()) 699 return Error("Error at end of value symbol table block"); 700 return false; 701 } 702 if (Code == bitc::ENTER_SUBBLOCK) { 703 // No known subblocks, always skip them. 704 Stream.ReadSubBlockID(); 705 if (Stream.SkipBlock()) 706 return Error("Malformed block record"); 707 continue; 708 } 709 710 if (Code == bitc::DEFINE_ABBREV) { 711 Stream.ReadAbbrevRecord(); 712 continue; 713 } 714 715 // Read a record. 716 Record.clear(); 717 switch (Stream.ReadRecord(Code, Record)) { 718 default: // Default behavior: unknown type. 719 break; 720 case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N] 721 if (ConvertToString(Record, 1, ValueName)) 722 return Error("Invalid VST_ENTRY record"); 723 unsigned ValueID = Record[0]; 724 if (ValueID >= ValueList.size()) 725 return Error("Invalid Value ID in VST_ENTRY record"); 726 Value *V = ValueList[ValueID]; 727 728 V->setName(StringRef(ValueName.data(), ValueName.size())); 729 ValueName.clear(); 730 break; 731 } 732 case bitc::VST_CODE_BBENTRY: { 733 if (ConvertToString(Record, 1, ValueName)) 734 return Error("Invalid VST_BBENTRY record"); 735 BasicBlock *BB = getBasicBlock(Record[0]); 736 if (BB == 0) 737 return Error("Invalid BB ID in VST_BBENTRY record"); 738 739 BB->setName(StringRef(ValueName.data(), ValueName.size())); 740 ValueName.clear(); 741 break; 742 } 743 } 744 } 745} 746 747bool BitcodeReader::ParseMetadata() { 748 unsigned NextMDValueNo = MDValueList.size(); 749 750 if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) 751 return Error("Malformed block record"); 752 753 SmallVector<uint64_t, 64> Record; 754 755 // Read all the records. 756 while (1) { 757 unsigned Code = Stream.ReadCode(); 758 if (Code == bitc::END_BLOCK) { 759 if (Stream.ReadBlockEnd()) 760 return Error("Error at end of PARAMATTR block"); 761 return false; 762 } 763 764 if (Code == bitc::ENTER_SUBBLOCK) { 765 // No known subblocks, always skip them. 766 Stream.ReadSubBlockID(); 767 if (Stream.SkipBlock()) 768 return Error("Malformed block record"); 769 continue; 770 } 771 772 if (Code == bitc::DEFINE_ABBREV) { 773 Stream.ReadAbbrevRecord(); 774 continue; 775 } 776 777 bool IsFunctionLocal = false; 778 // Read a record. 779 Record.clear(); 780 Code = Stream.ReadRecord(Code, Record); 781 switch (Code) { 782 default: // Default behavior: ignore. 783 break; 784 case bitc::METADATA_NAME: { 785 // Read named of the named metadata. 786 unsigned NameLength = Record.size(); 787 SmallString<8> Name; 788 Name.resize(NameLength); 789 for (unsigned i = 0; i != NameLength; ++i) 790 Name[i] = Record[i]; 791 Record.clear(); 792 Code = Stream.ReadCode(); 793 794 // METADATA_NAME is always followed by METADATA_NAMED_NODE2. 795 // Or METADATA_NAMED_NODE in LLVM 2.7. FIXME: Remove this in LLVM 3.0. 796 unsigned NextBitCode = Stream.ReadRecord(Code, Record); 797 if (NextBitCode == bitc::METADATA_NAMED_NODE) { 798 LLVM2_7MetadataDetected = true; 799 } else if (NextBitCode != bitc::METADATA_NAMED_NODE2) 800 assert ( 0 && "Invalid Named Metadata record"); 801 802 // Read named metadata elements. 803 unsigned Size = Record.size(); 804 NamedMDNode *NMD = TheModule->getOrInsertNamedMetadata(Name); 805 for (unsigned i = 0; i != Size; ++i) { 806 MDNode *MD = dyn_cast<MDNode>(MDValueList.getValueFwdRef(Record[i])); 807 if (MD == 0) 808 return Error("Malformed metadata record"); 809 NMD->addOperand(MD); 810 } 811 // Backwards compatibility hack: NamedMDValues used to be Values, 812 // and they got their own slots in the value numbering. They are no 813 // longer Values, however we still need to account for them in the 814 // numbering in order to be able to read old bitcode files. 815 // FIXME: Remove this in LLVM 3.0. 816 if (LLVM2_7MetadataDetected) 817 MDValueList.AssignValue(0, NextMDValueNo++); 818 break; 819 } 820 case bitc::METADATA_FN_NODE: // FIXME: Remove in LLVM 3.0. 821 case bitc::METADATA_FN_NODE2: 822 IsFunctionLocal = true; 823 // fall-through 824 case bitc::METADATA_NODE: // FIXME: Remove in LLVM 3.0. 825 case bitc::METADATA_NODE2: { 826 827 // Detect 2.7-era metadata. 828 // FIXME: Remove in LLVM 3.0. 829 if (Code == bitc::METADATA_FN_NODE || Code == bitc::METADATA_NODE) 830 LLVM2_7MetadataDetected = true; 831 832 if (Record.size() % 2 == 1) 833 return Error("Invalid METADATA_NODE2 record"); 834 835 unsigned Size = Record.size(); 836 SmallVector<Value*, 8> Elts; 837 for (unsigned i = 0; i != Size; i += 2) { 838 const Type *Ty = getTypeByID(Record[i]); 839 if (!Ty) return Error("Invalid METADATA_NODE2 record"); 840 if (Ty->isMetadataTy()) 841 Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); 842 else if (!Ty->isVoidTy()) 843 Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty)); 844 else 845 Elts.push_back(NULL); 846 } 847 Value *V = MDNode::getWhenValsUnresolved(Context, 848 Elts.data(), Elts.size(), 849 IsFunctionLocal); 850 IsFunctionLocal = false; 851 MDValueList.AssignValue(V, NextMDValueNo++); 852 break; 853 } 854 case bitc::METADATA_STRING: { 855 unsigned MDStringLength = Record.size(); 856 SmallString<8> String; 857 String.resize(MDStringLength); 858 for (unsigned i = 0; i != MDStringLength; ++i) 859 String[i] = Record[i]; 860 Value *V = MDString::get(Context, 861 StringRef(String.data(), String.size())); 862 MDValueList.AssignValue(V, NextMDValueNo++); 863 break; 864 } 865 case bitc::METADATA_KIND: { 866 unsigned RecordLength = Record.size(); 867 if (Record.empty() || RecordLength < 2) 868 return Error("Invalid METADATA_KIND record"); 869 SmallString<8> Name; 870 Name.resize(RecordLength-1); 871 unsigned Kind = Record[0]; 872 for (unsigned i = 1; i != RecordLength; ++i) 873 Name[i-1] = Record[i]; 874 875 unsigned NewKind = TheModule->getMDKindID(Name.str()); 876 if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) 877 return Error("Conflicting METADATA_KIND records"); 878 break; 879 } 880 } 881 } 882} 883 884/// DecodeSignRotatedValue - Decode a signed value stored with the sign bit in 885/// the LSB for dense VBR encoding. 886static uint64_t DecodeSignRotatedValue(uint64_t V) { 887 if ((V & 1) == 0) 888 return V >> 1; 889 if (V != 1) 890 return -(V >> 1); 891 // There is no such thing as -0 with integers. "-0" really means MININT. 892 return 1ULL << 63; 893} 894 895/// ResolveGlobalAndAliasInits - Resolve all of the initializers for global 896/// values and aliases that we can. 897bool BitcodeReader::ResolveGlobalAndAliasInits() { 898 std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist; 899 std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist; 900 901 GlobalInitWorklist.swap(GlobalInits); 902 AliasInitWorklist.swap(AliasInits); 903 904 while (!GlobalInitWorklist.empty()) { 905 unsigned ValID = GlobalInitWorklist.back().second; 906 if (ValID >= ValueList.size()) { 907 // Not ready to resolve this yet, it requires something later in the file. 908 GlobalInits.push_back(GlobalInitWorklist.back()); 909 } else { 910 if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 911 GlobalInitWorklist.back().first->setInitializer(C); 912 else 913 return Error("Global variable initializer is not a constant!"); 914 } 915 GlobalInitWorklist.pop_back(); 916 } 917 918 while (!AliasInitWorklist.empty()) { 919 unsigned ValID = AliasInitWorklist.back().second; 920 if (ValID >= ValueList.size()) { 921 AliasInits.push_back(AliasInitWorklist.back()); 922 } else { 923 if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) 924 AliasInitWorklist.back().first->setAliasee(C); 925 else 926 return Error("Alias initializer is not a constant!"); 927 } 928 AliasInitWorklist.pop_back(); 929 } 930 return false; 931} 932 933bool BitcodeReader::ParseConstants() { 934 if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) 935 return Error("Malformed block record"); 936 937 SmallVector<uint64_t, 64> Record; 938 939 // Read all the records for this value table. 940 const Type *CurTy = Type::getInt32Ty(Context); 941 unsigned NextCstNo = ValueList.size(); 942 while (1) { 943 unsigned Code = Stream.ReadCode(); 944 if (Code == bitc::END_BLOCK) 945 break; 946 947 if (Code == bitc::ENTER_SUBBLOCK) { 948 // No known subblocks, always skip them. 949 Stream.ReadSubBlockID(); 950 if (Stream.SkipBlock()) 951 return Error("Malformed block record"); 952 continue; 953 } 954 955 if (Code == bitc::DEFINE_ABBREV) { 956 Stream.ReadAbbrevRecord(); 957 continue; 958 } 959 960 // Read a record. 961 Record.clear(); 962 Value *V = 0; 963 unsigned BitCode = Stream.ReadRecord(Code, Record); 964 switch (BitCode) { 965 default: // Default behavior: unknown constant 966 case bitc::CST_CODE_UNDEF: // UNDEF 967 V = UndefValue::get(CurTy); 968 break; 969 case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] 970 if (Record.empty()) 971 return Error("Malformed CST_SETTYPE record"); 972 if (Record[0] >= TypeList.size()) 973 return Error("Invalid Type ID in CST_SETTYPE record"); 974 CurTy = TypeList[Record[0]]; 975 continue; // Skip the ValueList manipulation. 976 case bitc::CST_CODE_NULL: // NULL 977 V = Constant::getNullValue(CurTy); 978 break; 979 case bitc::CST_CODE_INTEGER: // INTEGER: [intval] 980 if (!CurTy->isIntegerTy() || Record.empty()) 981 return Error("Invalid CST_INTEGER record"); 982 V = ConstantInt::get(CurTy, DecodeSignRotatedValue(Record[0])); 983 break; 984 case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval] 985 if (!CurTy->isIntegerTy() || Record.empty()) 986 return Error("Invalid WIDE_INTEGER record"); 987 988 unsigned NumWords = Record.size(); 989 SmallVector<uint64_t, 8> Words; 990 Words.resize(NumWords); 991 for (unsigned i = 0; i != NumWords; ++i) 992 Words[i] = DecodeSignRotatedValue(Record[i]); 993 V = ConstantInt::get(Context, 994 APInt(cast<IntegerType>(CurTy)->getBitWidth(), 995 NumWords, &Words[0])); 996 break; 997 } 998 case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] 999 if (Record.empty()) 1000 return Error("Invalid FLOAT record"); 1001 if (CurTy->isFloatTy()) 1002 V = ConstantFP::get(Context, APFloat(APInt(32, (uint32_t)Record[0]))); 1003 else if (CurTy->isDoubleTy()) 1004 V = ConstantFP::get(Context, APFloat(APInt(64, Record[0]))); 1005 else if (CurTy->isX86_FP80Ty()) { 1006 // Bits are not stored the same way as a normal i80 APInt, compensate. 1007 uint64_t Rearrange[2]; 1008 Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16); 1009 Rearrange[1] = Record[0] >> 48; 1010 V = ConstantFP::get(Context, APFloat(APInt(80, 2, Rearrange))); 1011 } else if (CurTy->isFP128Ty()) 1012 V = ConstantFP::get(Context, APFloat(APInt(128, 2, &Record[0]), true)); 1013 else if (CurTy->isPPC_FP128Ty()) 1014 V = ConstantFP::get(Context, APFloat(APInt(128, 2, &Record[0]))); 1015 else 1016 V = UndefValue::get(CurTy); 1017 break; 1018 } 1019 1020 case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] 1021 if (Record.empty()) 1022 return Error("Invalid CST_AGGREGATE record"); 1023 1024 unsigned Size = Record.size(); 1025 std::vector<Constant*> Elts; 1026 1027 if (const StructType *STy = dyn_cast<StructType>(CurTy)) { 1028 for (unsigned i = 0; i != Size; ++i) 1029 Elts.push_back(ValueList.getConstantFwdRef(Record[i], 1030 STy->getElementType(i))); 1031 V = ConstantStruct::get(STy, Elts); 1032 } else if (const ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) { 1033 const Type *EltTy = ATy->getElementType(); 1034 for (unsigned i = 0; i != Size; ++i) 1035 Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 1036 V = ConstantArray::get(ATy, Elts); 1037 } else if (const VectorType *VTy = dyn_cast<VectorType>(CurTy)) { 1038 const Type *EltTy = VTy->getElementType(); 1039 for (unsigned i = 0; i != Size; ++i) 1040 Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 1041 V = ConstantVector::get(Elts); 1042 } else { 1043 V = UndefValue::get(CurTy); 1044 } 1045 break; 1046 } 1047 case bitc::CST_CODE_STRING: { // STRING: [values] 1048 if (Record.empty()) 1049 return Error("Invalid CST_AGGREGATE record"); 1050 1051 const ArrayType *ATy = cast<ArrayType>(CurTy); 1052 const Type *EltTy = ATy->getElementType(); 1053 1054 unsigned Size = Record.size(); 1055 std::vector<Constant*> Elts; 1056 for (unsigned i = 0; i != Size; ++i) 1057 Elts.push_back(ConstantInt::get(EltTy, Record[i])); 1058 V = ConstantArray::get(ATy, Elts); 1059 break; 1060 } 1061 case bitc::CST_CODE_CSTRING: { // CSTRING: [values] 1062 if (Record.empty()) 1063 return Error("Invalid CST_AGGREGATE record"); 1064 1065 const ArrayType *ATy = cast<ArrayType>(CurTy); 1066 const Type *EltTy = ATy->getElementType(); 1067 1068 unsigned Size = Record.size(); 1069 std::vector<Constant*> Elts; 1070 for (unsigned i = 0; i != Size; ++i) 1071 Elts.push_back(ConstantInt::get(EltTy, Record[i])); 1072 Elts.push_back(Constant::getNullValue(EltTy)); 1073 V = ConstantArray::get(ATy, Elts); 1074 break; 1075 } 1076 case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] 1077 if (Record.size() < 3) return Error("Invalid CE_BINOP record"); 1078 int Opc = GetDecodedBinaryOpcode(Record[0], CurTy); 1079 if (Opc < 0) { 1080 V = UndefValue::get(CurTy); // Unknown binop. 1081 } else { 1082 Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy); 1083 Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy); 1084 unsigned Flags = 0; 1085 if (Record.size() >= 4) { 1086 if (Opc == Instruction::Add || 1087 Opc == Instruction::Sub || 1088 Opc == Instruction::Mul) { 1089 if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 1090 Flags |= OverflowingBinaryOperator::NoSignedWrap; 1091 if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 1092 Flags |= OverflowingBinaryOperator::NoUnsignedWrap; 1093 } else if (Opc == Instruction::SDiv) { 1094 if (Record[3] & (1 << bitc::SDIV_EXACT)) 1095 Flags |= SDivOperator::IsExact; 1096 } 1097 } 1098 V = ConstantExpr::get(Opc, LHS, RHS, Flags); 1099 } 1100 break; 1101 } 1102 case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] 1103 if (Record.size() < 3) return Error("Invalid CE_CAST record"); 1104 int Opc = GetDecodedCastOpcode(Record[0]); 1105 if (Opc < 0) { 1106 V = UndefValue::get(CurTy); // Unknown cast. 1107 } else { 1108 const Type *OpTy = getTypeByID(Record[1]); 1109 if (!OpTy) return Error("Invalid CE_CAST record"); 1110 Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); 1111 V = ConstantExpr::getCast(Opc, Op, CurTy); 1112 } 1113 break; 1114 } 1115 case bitc::CST_CODE_CE_INBOUNDS_GEP: 1116 case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands] 1117 if (Record.size() & 1) return Error("Invalid CE_GEP record"); 1118 SmallVector<Constant*, 16> Elts; 1119 for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 1120 const Type *ElTy = getTypeByID(Record[i]); 1121 if (!ElTy) return Error("Invalid CE_GEP record"); 1122 Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); 1123 } 1124 if (BitCode == bitc::CST_CODE_CE_INBOUNDS_GEP) 1125 V = ConstantExpr::getInBoundsGetElementPtr(Elts[0], &Elts[1], 1126 Elts.size()-1); 1127 else 1128 V = ConstantExpr::getGetElementPtr(Elts[0], &Elts[1], 1129 Elts.size()-1); 1130 break; 1131 } 1132 case bitc::CST_CODE_CE_SELECT: // CE_SELECT: [opval#, opval#, opval#] 1133 if (Record.size() < 3) return Error("Invalid CE_SELECT record"); 1134 V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0], 1135 Type::getInt1Ty(Context)), 1136 ValueList.getConstantFwdRef(Record[1],CurTy), 1137 ValueList.getConstantFwdRef(Record[2],CurTy)); 1138 break; 1139 case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval] 1140 if (Record.size() < 3) return Error("Invalid CE_EXTRACTELT record"); 1141 const VectorType *OpTy = 1142 dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1143 if (OpTy == 0) return Error("Invalid CE_EXTRACTELT record"); 1144 Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1145 Constant *Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 1146 V = ConstantExpr::getExtractElement(Op0, Op1); 1147 break; 1148 } 1149 case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval] 1150 const VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1151 if (Record.size() < 3 || OpTy == 0) 1152 return Error("Invalid CE_INSERTELT record"); 1153 Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 1154 Constant *Op1 = ValueList.getConstantFwdRef(Record[1], 1155 OpTy->getElementType()); 1156 Constant *Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 1157 V = ConstantExpr::getInsertElement(Op0, Op1, Op2); 1158 break; 1159 } 1160 case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] 1161 const VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1162 if (Record.size() < 3 || OpTy == 0) 1163 return Error("Invalid CE_SHUFFLEVEC record"); 1164 Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 1165 Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); 1166 const Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 1167 OpTy->getNumElements()); 1168 Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy); 1169 V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 1170 break; 1171 } 1172 case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval] 1173 const VectorType *RTy = dyn_cast<VectorType>(CurTy); 1174 const VectorType *OpTy = 1175 dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1176 if (Record.size() < 4 || RTy == 0 || OpTy == 0) 1177 return Error("Invalid CE_SHUFVEC_EX record"); 1178 Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1179 Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 1180 const Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 1181 RTy->getNumElements()); 1182 Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy); 1183 V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 1184 break; 1185 } 1186 case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] 1187 if (Record.size() < 4) return Error("Invalid CE_CMP record"); 1188 const Type *OpTy = getTypeByID(Record[0]); 1189 if (OpTy == 0) return Error("Invalid CE_CMP record"); 1190 Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1191 Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 1192 1193 if (OpTy->isFPOrFPVectorTy()) 1194 V = ConstantExpr::getFCmp(Record[3], Op0, Op1); 1195 else 1196 V = ConstantExpr::getICmp(Record[3], Op0, Op1); 1197 break; 1198 } 1199 case bitc::CST_CODE_INLINEASM: { 1200 if (Record.size() < 2) return Error("Invalid INLINEASM record"); 1201 std::string AsmStr, ConstrStr; 1202 bool HasSideEffects = Record[0] & 1; 1203 bool IsAlignStack = Record[0] >> 1; 1204 unsigned AsmStrSize = Record[1]; 1205 if (2+AsmStrSize >= Record.size()) 1206 return Error("Invalid INLINEASM record"); 1207 unsigned ConstStrSize = Record[2+AsmStrSize]; 1208 if (3+AsmStrSize+ConstStrSize > Record.size()) 1209 return Error("Invalid INLINEASM record"); 1210 1211 for (unsigned i = 0; i != AsmStrSize; ++i) 1212 AsmStr += (char)Record[2+i]; 1213 for (unsigned i = 0; i != ConstStrSize; ++i) 1214 ConstrStr += (char)Record[3+AsmStrSize+i]; 1215 const PointerType *PTy = cast<PointerType>(CurTy); 1216 V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), 1217 AsmStr, ConstrStr, HasSideEffects, IsAlignStack); 1218 break; 1219 } 1220 case bitc::CST_CODE_BLOCKADDRESS:{ 1221 if (Record.size() < 3) return Error("Invalid CE_BLOCKADDRESS record"); 1222 const Type *FnTy = getTypeByID(Record[0]); 1223 if (FnTy == 0) return Error("Invalid CE_BLOCKADDRESS record"); 1224 Function *Fn = 1225 dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy)); 1226 if (Fn == 0) return Error("Invalid CE_BLOCKADDRESS record"); 1227 1228 GlobalVariable *FwdRef = new GlobalVariable(*Fn->getParent(), 1229 Type::getInt8Ty(Context), 1230 false, GlobalValue::InternalLinkage, 1231 0, ""); 1232 BlockAddrFwdRefs[Fn].push_back(std::make_pair(Record[2], FwdRef)); 1233 V = FwdRef; 1234 break; 1235 } 1236 } 1237 1238 ValueList.AssignValue(V, NextCstNo); 1239 ++NextCstNo; 1240 } 1241 1242 if (NextCstNo != ValueList.size()) 1243 return Error("Invalid constant reference!"); 1244 1245 if (Stream.ReadBlockEnd()) 1246 return Error("Error at end of constants block"); 1247 1248 // Once all the constants have been read, go through and resolve forward 1249 // references. 1250 ValueList.ResolveConstantForwardRefs(); 1251 return false; 1252} 1253 1254/// RememberAndSkipFunctionBody - When we see the block for a function body, 1255/// remember where it is and then skip it. This lets us lazily deserialize the 1256/// functions. 1257bool BitcodeReader::RememberAndSkipFunctionBody() { 1258 // Get the function we are talking about. 1259 if (FunctionsWithBodies.empty()) 1260 return Error("Insufficient function protos"); 1261 1262 Function *Fn = FunctionsWithBodies.back(); 1263 FunctionsWithBodies.pop_back(); 1264 1265 // Save the current stream state. 1266 uint64_t CurBit = Stream.GetCurrentBitNo(); 1267 DeferredFunctionInfo[Fn] = CurBit; 1268 1269 // Skip over the function block for now. 1270 if (Stream.SkipBlock()) 1271 return Error("Malformed block record"); 1272 return false; 1273} 1274 1275bool BitcodeReader::ParseModule() { 1276 if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 1277 return Error("Malformed block record"); 1278 1279 SmallVector<uint64_t, 64> Record; 1280 std::vector<std::string> SectionTable; 1281 std::vector<std::string> GCTable; 1282 1283 // Read all the records for this module. 1284 while (!Stream.AtEndOfStream()) { 1285 unsigned Code = Stream.ReadCode(); 1286 if (Code == bitc::END_BLOCK) { 1287 if (Stream.ReadBlockEnd()) 1288 return Error("Error at end of module block"); 1289 1290 // Patch the initializers for globals and aliases up. 1291 ResolveGlobalAndAliasInits(); 1292 if (!GlobalInits.empty() || !AliasInits.empty()) 1293 return Error("Malformed global initializer set"); 1294 if (!FunctionsWithBodies.empty()) 1295 return Error("Too few function bodies found"); 1296 1297 // Look for intrinsic functions which need to be upgraded at some point 1298 for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); 1299 FI != FE; ++FI) { 1300 Function* NewFn; 1301 if (UpgradeIntrinsicFunction(FI, NewFn)) 1302 UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn)); 1303 } 1304 1305 // Look for global variables which need to be renamed. 1306 for (Module::global_iterator 1307 GI = TheModule->global_begin(), GE = TheModule->global_end(); 1308 GI != GE; ++GI) 1309 UpgradeGlobalVariable(GI); 1310 1311 // Force deallocation of memory for these vectors to favor the client that 1312 // want lazy deserialization. 1313 std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); 1314 std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); 1315 std::vector<Function*>().swap(FunctionsWithBodies); 1316 return false; 1317 } 1318 1319 if (Code == bitc::ENTER_SUBBLOCK) { 1320 switch (Stream.ReadSubBlockID()) { 1321 default: // Skip unknown content. 1322 if (Stream.SkipBlock()) 1323 return Error("Malformed block record"); 1324 break; 1325 case bitc::BLOCKINFO_BLOCK_ID: 1326 if (Stream.ReadBlockInfoBlock()) 1327 return Error("Malformed BlockInfoBlock"); 1328 break; 1329 case bitc::PARAMATTR_BLOCK_ID: 1330 if (ParseAttributeBlock()) 1331 return true; 1332 break; 1333 case bitc::TYPE_BLOCK_ID: 1334 if (ParseTypeTable()) 1335 return true; 1336 break; 1337 case bitc::TYPE_SYMTAB_BLOCK_ID: 1338 if (ParseTypeSymbolTable()) 1339 return true; 1340 break; 1341 case bitc::VALUE_SYMTAB_BLOCK_ID: 1342 if (ParseValueSymbolTable()) 1343 return true; 1344 break; 1345 case bitc::CONSTANTS_BLOCK_ID: 1346 if (ParseConstants() || ResolveGlobalAndAliasInits()) 1347 return true; 1348 break; 1349 case bitc::METADATA_BLOCK_ID: 1350 if (ParseMetadata()) 1351 return true; 1352 break; 1353 case bitc::FUNCTION_BLOCK_ID: 1354 // If this is the first function body we've seen, reverse the 1355 // FunctionsWithBodies list. 1356 if (!HasReversedFunctionsWithBodies) { 1357 std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end()); 1358 HasReversedFunctionsWithBodies = true; 1359 } 1360 1361 if (RememberAndSkipFunctionBody()) 1362 return true; 1363 break; 1364 } 1365 continue; 1366 } 1367 1368 if (Code == bitc::DEFINE_ABBREV) { 1369 Stream.ReadAbbrevRecord(); 1370 continue; 1371 } 1372 1373 // Read a record. 1374 switch (Stream.ReadRecord(Code, Record)) { 1375 default: break; // Default behavior, ignore unknown content. 1376 case bitc::MODULE_CODE_VERSION: // VERSION: [version#] 1377 if (Record.size() < 1) 1378 return Error("Malformed MODULE_CODE_VERSION"); 1379 // Only version #0 is supported so far. 1380 if (Record[0] != 0) 1381 return Error("Unknown bitstream version!"); 1382 break; 1383 case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 1384 std::string S; 1385 if (ConvertToString(Record, 0, S)) 1386 return Error("Invalid MODULE_CODE_TRIPLE record"); 1387 TheModule->setTargetTriple(S); 1388 break; 1389 } 1390 case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] 1391 std::string S; 1392 if (ConvertToString(Record, 0, S)) 1393 return Error("Invalid MODULE_CODE_DATALAYOUT record"); 1394 TheModule->setDataLayout(S); 1395 break; 1396 } 1397 case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] 1398 std::string S; 1399 if (ConvertToString(Record, 0, S)) 1400 return Error("Invalid MODULE_CODE_ASM record"); 1401 TheModule->setModuleInlineAsm(S); 1402 break; 1403 } 1404 case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N] 1405 std::string S; 1406 if (ConvertToString(Record, 0, S)) 1407 return Error("Invalid MODULE_CODE_DEPLIB record"); 1408 TheModule->addLibrary(S); 1409 break; 1410 } 1411 case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] 1412 std::string S; 1413 if (ConvertToString(Record, 0, S)) 1414 return Error("Invalid MODULE_CODE_SECTIONNAME record"); 1415 SectionTable.push_back(S); 1416 break; 1417 } 1418 case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N] 1419 std::string S; 1420 if (ConvertToString(Record, 0, S)) 1421 return Error("Invalid MODULE_CODE_GCNAME record"); 1422 GCTable.push_back(S); 1423 break; 1424 } 1425 // GLOBALVAR: [pointer type, isconst, initid, 1426 // linkage, alignment, section, visibility, threadlocal, 1427 // unnamed_addr] 1428 case bitc::MODULE_CODE_GLOBALVAR: { 1429 if (Record.size() < 6) 1430 return Error("Invalid MODULE_CODE_GLOBALVAR record"); 1431 const Type *Ty = getTypeByID(Record[0]); 1432 if (!Ty) return Error("Invalid MODULE_CODE_GLOBALVAR record"); 1433 if (!Ty->isPointerTy()) 1434 return Error("Global not a pointer type!"); 1435 unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); 1436 Ty = cast<PointerType>(Ty)->getElementType(); 1437 1438 bool isConstant = Record[1]; 1439 GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]); 1440 unsigned Alignment = (1 << Record[4]) >> 1; 1441 std::string Section; 1442 if (Record[5]) { 1443 if (Record[5]-1 >= SectionTable.size()) 1444 return Error("Invalid section ID"); 1445 Section = SectionTable[Record[5]-1]; 1446 } 1447 GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; 1448 if (Record.size() > 6) 1449 Visibility = GetDecodedVisibility(Record[6]); 1450 bool isThreadLocal = false; 1451 if (Record.size() > 7) 1452 isThreadLocal = Record[7]; 1453 1454 bool UnnamedAddr = false; 1455 if (Record.size() > 8) 1456 UnnamedAddr = Record[8]; 1457 1458 GlobalVariable *NewGV = 1459 new GlobalVariable(*TheModule, Ty, isConstant, Linkage, 0, "", 0, 1460 isThreadLocal, AddressSpace); 1461 NewGV->setAlignment(Alignment); 1462 if (!Section.empty()) 1463 NewGV->setSection(Section); 1464 NewGV->setVisibility(Visibility); 1465 NewGV->setThreadLocal(isThreadLocal); 1466 NewGV->setUnnamedAddr(UnnamedAddr); 1467 1468 ValueList.push_back(NewGV); 1469 1470 // Remember which value to use for the global initializer. 1471 if (unsigned InitID = Record[2]) 1472 GlobalInits.push_back(std::make_pair(NewGV, InitID-1)); 1473 break; 1474 } 1475 // FUNCTION: [type, callingconv, isproto, linkage, paramattr, 1476 // alignment, section, visibility, gc, unnamed_addr] 1477 case bitc::MODULE_CODE_FUNCTION: { 1478 if (Record.size() < 8) 1479 return Error("Invalid MODULE_CODE_FUNCTION record"); 1480 const Type *Ty = getTypeByID(Record[0]); 1481 if (!Ty) return Error("Invalid MODULE_CODE_FUNCTION record"); 1482 if (!Ty->isPointerTy()) 1483 return Error("Function not a pointer type!"); 1484 const FunctionType *FTy = 1485 dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType()); 1486 if (!FTy) 1487 return Error("Function not a pointer to function type!"); 1488 1489 Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, 1490 "", TheModule); 1491 1492 Func->setCallingConv(static_cast<CallingConv::ID>(Record[1])); 1493 bool isProto = Record[2]; 1494 Func->setLinkage(GetDecodedLinkage(Record[3])); 1495 Func->setAttributes(getAttributes(Record[4])); 1496 1497 Func->setAlignment((1 << Record[5]) >> 1); 1498 if (Record[6]) { 1499 if (Record[6]-1 >= SectionTable.size()) 1500 return Error("Invalid section ID"); 1501 Func->setSection(SectionTable[Record[6]-1]); 1502 } 1503 Func->setVisibility(GetDecodedVisibility(Record[7])); 1504 if (Record.size() > 8 && Record[8]) { 1505 if (Record[8]-1 > GCTable.size()) 1506 return Error("Invalid GC ID"); 1507 Func->setGC(GCTable[Record[8]-1].c_str()); 1508 } 1509 bool UnnamedAddr = false; 1510 if (Record.size() > 9) 1511 UnnamedAddr = Record[9]; 1512 Func->setUnnamedAddr(UnnamedAddr); 1513 ValueList.push_back(Func); 1514 1515 // If this is a function with a body, remember the prototype we are 1516 // creating now, so that we can match up the body with them later. 1517 if (!isProto) 1518 FunctionsWithBodies.push_back(Func); 1519 break; 1520 } 1521 // ALIAS: [alias type, aliasee val#, linkage] 1522 // ALIAS: [alias type, aliasee val#, linkage, visibility] 1523 case bitc::MODULE_CODE_ALIAS: { 1524 if (Record.size() < 3) 1525 return Error("Invalid MODULE_ALIAS record"); 1526 const Type *Ty = getTypeByID(Record[0]); 1527 if (!Ty) return Error("Invalid MODULE_ALIAS record"); 1528 if (!Ty->isPointerTy()) 1529 return Error("Function not a pointer type!"); 1530 1531 GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]), 1532 "", 0, TheModule); 1533 // Old bitcode files didn't have visibility field. 1534 if (Record.size() > 3) 1535 NewGA->setVisibility(GetDecodedVisibility(Record[3])); 1536 ValueList.push_back(NewGA); 1537 AliasInits.push_back(std::make_pair(NewGA, Record[1])); 1538 break; 1539 } 1540 /// MODULE_CODE_PURGEVALS: [numvals] 1541 case bitc::MODULE_CODE_PURGEVALS: 1542 // Trim down the value list to the specified size. 1543 if (Record.size() < 1 || Record[0] > ValueList.size()) 1544 return Error("Invalid MODULE_PURGEVALS record"); 1545 ValueList.shrinkTo(Record[0]); 1546 break; 1547 } 1548 Record.clear(); 1549 } 1550 1551 return Error("Premature end of bitstream"); 1552} 1553 1554bool BitcodeReader::ParseBitcodeInto(Module *M) { 1555 TheModule = 0; 1556 1557 unsigned char *BufPtr = (unsigned char *)Buffer->getBufferStart(); 1558 unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); 1559 1560 if (Buffer->getBufferSize() & 3) { 1561 if (!isRawBitcode(BufPtr, BufEnd) && !isBitcodeWrapper(BufPtr, BufEnd)) 1562 return Error("Invalid bitcode signature"); 1563 else 1564 return Error("Bitcode stream should be a multiple of 4 bytes in length"); 1565 } 1566 1567 // If we have a wrapper header, parse it and ignore the non-bc file contents. 1568 // The magic number is 0x0B17C0DE stored in little endian. 1569 if (isBitcodeWrapper(BufPtr, BufEnd)) 1570 if (SkipBitcodeWrapperHeader(BufPtr, BufEnd)) 1571 return Error("Invalid bitcode wrapper header"); 1572 1573 StreamFile.init(BufPtr, BufEnd); 1574 Stream.init(StreamFile); 1575 1576 // Sniff for the signature. 1577 if (Stream.Read(8) != 'B' || 1578 Stream.Read(8) != 'C' || 1579 Stream.Read(4) != 0x0 || 1580 Stream.Read(4) != 0xC || 1581 Stream.Read(4) != 0xE || 1582 Stream.Read(4) != 0xD) 1583 return Error("Invalid bitcode signature"); 1584 1585 // We expect a number of well-defined blocks, though we don't necessarily 1586 // need to understand them all. 1587 while (!Stream.AtEndOfStream()) { 1588 unsigned Code = Stream.ReadCode(); 1589 1590 if (Code != bitc::ENTER_SUBBLOCK) 1591 return Error("Invalid record at top-level"); 1592 1593 unsigned BlockID = Stream.ReadSubBlockID(); 1594 1595 // We only know the MODULE subblock ID. 1596 switch (BlockID) { 1597 case bitc::BLOCKINFO_BLOCK_ID: 1598 if (Stream.ReadBlockInfoBlock()) 1599 return Error("Malformed BlockInfoBlock"); 1600 break; 1601 case bitc::MODULE_BLOCK_ID: 1602 // Reject multiple MODULE_BLOCK's in a single bitstream. 1603 if (TheModule) 1604 return Error("Multiple MODULE_BLOCKs in same stream"); 1605 TheModule = M; 1606 if (ParseModule()) 1607 return true; 1608 break; 1609 default: 1610 if (Stream.SkipBlock()) 1611 return Error("Malformed block record"); 1612 break; 1613 } 1614 } 1615 1616 return false; 1617} 1618 1619bool BitcodeReader::ParseModuleTriple(std::string &Triple) { 1620 if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 1621 return Error("Malformed block record"); 1622 1623 SmallVector<uint64_t, 64> Record; 1624 1625 // Read all the records for this module. 1626 while (!Stream.AtEndOfStream()) { 1627 unsigned Code = Stream.ReadCode(); 1628 if (Code == bitc::END_BLOCK) { 1629 if (Stream.ReadBlockEnd()) 1630 return Error("Error at end of module block"); 1631 1632 return false; 1633 } 1634 1635 if (Code == bitc::ENTER_SUBBLOCK) { 1636 switch (Stream.ReadSubBlockID()) { 1637 default: // Skip unknown content. 1638 if (Stream.SkipBlock()) 1639 return Error("Malformed block record"); 1640 break; 1641 } 1642 continue; 1643 } 1644 1645 if (Code == bitc::DEFINE_ABBREV) { 1646 Stream.ReadAbbrevRecord(); 1647 continue; 1648 } 1649 1650 // Read a record. 1651 switch (Stream.ReadRecord(Code, Record)) { 1652 default: break; // Default behavior, ignore unknown content. 1653 case bitc::MODULE_CODE_VERSION: // VERSION: [version#] 1654 if (Record.size() < 1) 1655 return Error("Malformed MODULE_CODE_VERSION"); 1656 // Only version #0 is supported so far. 1657 if (Record[0] != 0) 1658 return Error("Unknown bitstream version!"); 1659 break; 1660 case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 1661 std::string S; 1662 if (ConvertToString(Record, 0, S)) 1663 return Error("Invalid MODULE_CODE_TRIPLE record"); 1664 Triple = S; 1665 break; 1666 } 1667 } 1668 Record.clear(); 1669 } 1670 1671 return Error("Premature end of bitstream"); 1672} 1673 1674bool BitcodeReader::ParseTriple(std::string &Triple) { 1675 if (Buffer->getBufferSize() & 3) 1676 return Error("Bitcode stream should be a multiple of 4 bytes in length"); 1677 1678 unsigned char *BufPtr = (unsigned char *)Buffer->getBufferStart(); 1679 unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); 1680 1681 // If we have a wrapper header, parse it and ignore the non-bc file contents. 1682 // The magic number is 0x0B17C0DE stored in little endian. 1683 if (isBitcodeWrapper(BufPtr, BufEnd)) 1684 if (SkipBitcodeWrapperHeader(BufPtr, BufEnd)) 1685 return Error("Invalid bitcode wrapper header"); 1686 1687 StreamFile.init(BufPtr, BufEnd); 1688 Stream.init(StreamFile); 1689 1690 // Sniff for the signature. 1691 if (Stream.Read(8) != 'B' || 1692 Stream.Read(8) != 'C' || 1693 Stream.Read(4) != 0x0 || 1694 Stream.Read(4) != 0xC || 1695 Stream.Read(4) != 0xE || 1696 Stream.Read(4) != 0xD) 1697 return Error("Invalid bitcode signature"); 1698 1699 // We expect a number of well-defined blocks, though we don't necessarily 1700 // need to understand them all. 1701 while (!Stream.AtEndOfStream()) { 1702 unsigned Code = Stream.ReadCode(); 1703 1704 if (Code != bitc::ENTER_SUBBLOCK) 1705 return Error("Invalid record at top-level"); 1706 1707 unsigned BlockID = Stream.ReadSubBlockID(); 1708 1709 // We only know the MODULE subblock ID. 1710 switch (BlockID) { 1711 case bitc::MODULE_BLOCK_ID: 1712 if (ParseModuleTriple(Triple)) 1713 return true; 1714 break; 1715 default: 1716 if (Stream.SkipBlock()) 1717 return Error("Malformed block record"); 1718 break; 1719 } 1720 } 1721 1722 return false; 1723} 1724 1725/// ParseMetadataAttachment - Parse metadata attachments. 1726bool BitcodeReader::ParseMetadataAttachment() { 1727 if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) 1728 return Error("Malformed block record"); 1729 1730 SmallVector<uint64_t, 64> Record; 1731 while(1) { 1732 unsigned Code = Stream.ReadCode(); 1733 if (Code == bitc::END_BLOCK) { 1734 if (Stream.ReadBlockEnd()) 1735 return Error("Error at end of PARAMATTR block"); 1736 break; 1737 } 1738 if (Code == bitc::DEFINE_ABBREV) { 1739 Stream.ReadAbbrevRecord(); 1740 continue; 1741 } 1742 // Read a metadata attachment record. 1743 Record.clear(); 1744 switch (Stream.ReadRecord(Code, Record)) { 1745 default: // Default behavior: ignore. 1746 break; 1747 // FIXME: Remove in LLVM 3.0. 1748 case bitc::METADATA_ATTACHMENT: 1749 LLVM2_7MetadataDetected = true; 1750 case bitc::METADATA_ATTACHMENT2: { 1751 unsigned RecordLength = Record.size(); 1752 if (Record.empty() || (RecordLength - 1) % 2 == 1) 1753 return Error ("Invalid METADATA_ATTACHMENT reader!"); 1754 Instruction *Inst = InstructionList[Record[0]]; 1755 for (unsigned i = 1; i != RecordLength; i = i+2) { 1756 unsigned Kind = Record[i]; 1757 DenseMap<unsigned, unsigned>::iterator I = 1758 MDKindMap.find(Kind); 1759 if (I == MDKindMap.end()) 1760 return Error("Invalid metadata kind ID"); 1761 Value *Node = MDValueList.getValueFwdRef(Record[i+1]); 1762 Inst->setMetadata(I->second, cast<MDNode>(Node)); 1763 } 1764 break; 1765 } 1766 } 1767 } 1768 return false; 1769} 1770 1771/// ParseFunctionBody - Lazily parse the specified function body block. 1772bool BitcodeReader::ParseFunctionBody(Function *F) { 1773 if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) 1774 return Error("Malformed block record"); 1775 1776 InstructionList.clear(); 1777 unsigned ModuleValueListSize = ValueList.size(); 1778 unsigned ModuleMDValueListSize = MDValueList.size(); 1779 1780 // Add all the function arguments to the value table. 1781 for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) 1782 ValueList.push_back(I); 1783 1784 unsigned NextValueNo = ValueList.size(); 1785 BasicBlock *CurBB = 0; 1786 unsigned CurBBNo = 0; 1787 1788 DebugLoc LastLoc; 1789 1790 // Read all the records. 1791 SmallVector<uint64_t, 64> Record; 1792 while (1) { 1793 unsigned Code = Stream.ReadCode(); 1794 if (Code == bitc::END_BLOCK) { 1795 if (Stream.ReadBlockEnd()) 1796 return Error("Error at end of function block"); 1797 break; 1798 } 1799 1800 if (Code == bitc::ENTER_SUBBLOCK) { 1801 switch (Stream.ReadSubBlockID()) { 1802 default: // Skip unknown content. 1803 if (Stream.SkipBlock()) 1804 return Error("Malformed block record"); 1805 break; 1806 case bitc::CONSTANTS_BLOCK_ID: 1807 if (ParseConstants()) return true; 1808 NextValueNo = ValueList.size(); 1809 break; 1810 case bitc::VALUE_SYMTAB_BLOCK_ID: 1811 if (ParseValueSymbolTable()) return true; 1812 break; 1813 case bitc::METADATA_ATTACHMENT_ID: 1814 if (ParseMetadataAttachment()) return true; 1815 break; 1816 case bitc::METADATA_BLOCK_ID: 1817 if (ParseMetadata()) return true; 1818 break; 1819 } 1820 continue; 1821 } 1822 1823 if (Code == bitc::DEFINE_ABBREV) { 1824 Stream.ReadAbbrevRecord(); 1825 continue; 1826 } 1827 1828 // Read a record. 1829 Record.clear(); 1830 Instruction *I = 0; 1831 unsigned BitCode = Stream.ReadRecord(Code, Record); 1832 switch (BitCode) { 1833 default: // Default behavior: reject 1834 return Error("Unknown instruction"); 1835 case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks] 1836 if (Record.size() < 1 || Record[0] == 0) 1837 return Error("Invalid DECLAREBLOCKS record"); 1838 // Create all the basic blocks for the function. 1839 FunctionBBs.resize(Record[0]); 1840 for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) 1841 FunctionBBs[i] = BasicBlock::Create(Context, "", F); 1842 CurBB = FunctionBBs[0]; 1843 continue; 1844 1845 1846 case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN 1847 // This record indicates that the last instruction is at the same 1848 // location as the previous instruction with a location. 1849 I = 0; 1850 1851 // Get the last instruction emitted. 1852 if (CurBB && !CurBB->empty()) 1853 I = &CurBB->back(); 1854 else if (CurBBNo && FunctionBBs[CurBBNo-1] && 1855 !FunctionBBs[CurBBNo-1]->empty()) 1856 I = &FunctionBBs[CurBBNo-1]->back(); 1857 1858 if (I == 0) return Error("Invalid DEBUG_LOC_AGAIN record"); 1859 I->setDebugLoc(LastLoc); 1860 I = 0; 1861 continue; 1862 1863 // FIXME: Remove this in LLVM 3.0. 1864 case bitc::FUNC_CODE_DEBUG_LOC: 1865 LLVM2_7MetadataDetected = true; 1866 case bitc::FUNC_CODE_DEBUG_LOC2: { // DEBUG_LOC: [line, col, scope, ia] 1867 I = 0; // Get the last instruction emitted. 1868 if (CurBB && !CurBB->empty()) 1869 I = &CurBB->back(); 1870 else if (CurBBNo && FunctionBBs[CurBBNo-1] && 1871 !FunctionBBs[CurBBNo-1]->empty()) 1872 I = &FunctionBBs[CurBBNo-1]->back(); 1873 if (I == 0 || Record.size() < 4) 1874 return Error("Invalid FUNC_CODE_DEBUG_LOC record"); 1875 1876 unsigned Line = Record[0], Col = Record[1]; 1877 unsigned ScopeID = Record[2], IAID = Record[3]; 1878 1879 MDNode *Scope = 0, *IA = 0; 1880 if (ScopeID) Scope = cast<MDNode>(MDValueList.getValueFwdRef(ScopeID-1)); 1881 if (IAID) IA = cast<MDNode>(MDValueList.getValueFwdRef(IAID-1)); 1882 LastLoc = DebugLoc::get(Line, Col, Scope, IA); 1883 I->setDebugLoc(LastLoc); 1884 I = 0; 1885 continue; 1886 } 1887 1888 case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode] 1889 unsigned OpNum = 0; 1890 Value *LHS, *RHS; 1891 if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 1892 getValue(Record, OpNum, LHS->getType(), RHS) || 1893 OpNum+1 > Record.size()) 1894 return Error("Invalid BINOP record"); 1895 1896 int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); 1897 if (Opc == -1) return Error("Invalid BINOP record"); 1898 I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); 1899 InstructionList.push_back(I); 1900 if (OpNum < Record.size()) { 1901 if (Opc == Instruction::Add || 1902 Opc == Instruction::Sub || 1903 Opc == Instruction::Mul) { 1904 if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 1905 cast<BinaryOperator>(I)->setHasNoSignedWrap(true); 1906 if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 1907 cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true); 1908 } else if (Opc == Instruction::SDiv) { 1909 if (Record[OpNum] & (1 << bitc::SDIV_EXACT)) 1910 cast<BinaryOperator>(I)->setIsExact(true); 1911 } 1912 } 1913 break; 1914 } 1915 case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc] 1916 unsigned OpNum = 0; 1917 Value *Op; 1918 if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 1919 OpNum+2 != Record.size()) 1920 return Error("Invalid CAST record"); 1921 1922 const Type *ResTy = getTypeByID(Record[OpNum]); 1923 int Opc = GetDecodedCastOpcode(Record[OpNum+1]); 1924 if (Opc == -1 || ResTy == 0) 1925 return Error("Invalid CAST record"); 1926 I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy); 1927 InstructionList.push_back(I); 1928 break; 1929 } 1930 case bitc::FUNC_CODE_INST_INBOUNDS_GEP: 1931 case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands] 1932 unsigned OpNum = 0; 1933 Value *BasePtr; 1934 if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) 1935 return Error("Invalid GEP record"); 1936 1937 SmallVector<Value*, 16> GEPIdx; 1938 while (OpNum != Record.size()) { 1939 Value *Op; 1940 if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 1941 return Error("Invalid GEP record"); 1942 GEPIdx.push_back(Op); 1943 } 1944 1945 I = GetElementPtrInst::Create(BasePtr, GEPIdx.begin(), GEPIdx.end()); 1946 InstructionList.push_back(I); 1947 if (BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP) 1948 cast<GetElementPtrInst>(I)->setIsInBounds(true); 1949 break; 1950 } 1951 1952 case bitc::FUNC_CODE_INST_EXTRACTVAL: { 1953 // EXTRACTVAL: [opty, opval, n x indices] 1954 unsigned OpNum = 0; 1955 Value *Agg; 1956 if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 1957 return Error("Invalid EXTRACTVAL record"); 1958 1959 SmallVector<unsigned, 4> EXTRACTVALIdx; 1960 for (unsigned RecSize = Record.size(); 1961 OpNum != RecSize; ++OpNum) { 1962 uint64_t Index = Record[OpNum]; 1963 if ((unsigned)Index != Index) 1964 return Error("Invalid EXTRACTVAL index"); 1965 EXTRACTVALIdx.push_back((unsigned)Index); 1966 } 1967 1968 I = ExtractValueInst::Create(Agg, 1969 EXTRACTVALIdx.begin(), EXTRACTVALIdx.end()); 1970 InstructionList.push_back(I); 1971 break; 1972 } 1973 1974 case bitc::FUNC_CODE_INST_INSERTVAL: { 1975 // INSERTVAL: [opty, opval, opty, opval, n x indices] 1976 unsigned OpNum = 0; 1977 Value *Agg; 1978 if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 1979 return Error("Invalid INSERTVAL record"); 1980 Value *Val; 1981 if (getValueTypePair(Record, OpNum, NextValueNo, Val)) 1982 return Error("Invalid INSERTVAL record"); 1983 1984 SmallVector<unsigned, 4> INSERTVALIdx; 1985 for (unsigned RecSize = Record.size(); 1986 OpNum != RecSize; ++OpNum) { 1987 uint64_t Index = Record[OpNum]; 1988 if ((unsigned)Index != Index) 1989 return Error("Invalid INSERTVAL index"); 1990 INSERTVALIdx.push_back((unsigned)Index); 1991 } 1992 1993 I = InsertValueInst::Create(Agg, Val, 1994 INSERTVALIdx.begin(), INSERTVALIdx.end()); 1995 InstructionList.push_back(I); 1996 break; 1997 } 1998 1999 case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval] 2000 // obsolete form of select 2001 // handles select i1 ... in old bitcode 2002 unsigned OpNum = 0; 2003 Value *TrueVal, *FalseVal, *Cond; 2004 if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 2005 getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 2006 getValue(Record, OpNum, Type::getInt1Ty(Context), Cond)) 2007 return Error("Invalid SELECT record"); 2008 2009 I = SelectInst::Create(Cond, TrueVal, FalseVal); 2010 InstructionList.push_back(I); 2011 break; 2012 } 2013 2014 case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred] 2015 // new form of select 2016 // handles select i1 or select [N x i1] 2017 unsigned OpNum = 0; 2018 Value *TrueVal, *FalseVal, *Cond; 2019 if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 2020 getValue(Record, OpNum, TrueVal->getType(), FalseVal) || 2021 getValueTypePair(Record, OpNum, NextValueNo, Cond)) 2022 return Error("Invalid SELECT record"); 2023 2024 // select condition can be either i1 or [N x i1] 2025 if (const VectorType* vector_type = 2026 dyn_cast<const VectorType>(Cond->getType())) { 2027 // expect <n x i1> 2028 if (vector_type->getElementType() != Type::getInt1Ty(Context)) 2029 return Error("Invalid SELECT condition type"); 2030 } else { 2031 // expect i1 2032 if (Cond->getType() != Type::getInt1Ty(Context)) 2033 return Error("Invalid SELECT condition type"); 2034 } 2035 2036 I = SelectInst::Create(Cond, TrueVal, FalseVal); 2037 InstructionList.push_back(I); 2038 break; 2039 } 2040 2041 case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval] 2042 unsigned OpNum = 0; 2043 Value *Vec, *Idx; 2044 if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 2045 getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 2046 return Error("Invalid EXTRACTELT record"); 2047 I = ExtractElementInst::Create(Vec, Idx); 2048 InstructionList.push_back(I); 2049 break; 2050 } 2051 2052 case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval] 2053 unsigned OpNum = 0; 2054 Value *Vec, *Elt, *Idx; 2055 if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 2056 getValue(Record, OpNum, 2057 cast<VectorType>(Vec->getType())->getElementType(), Elt) || 2058 getValue(Record, OpNum, Type::getInt32Ty(Context), Idx)) 2059 return Error("Invalid INSERTELT record"); 2060 I = InsertElementInst::Create(Vec, Elt, Idx); 2061 InstructionList.push_back(I); 2062 break; 2063 } 2064 2065 case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval] 2066 unsigned OpNum = 0; 2067 Value *Vec1, *Vec2, *Mask; 2068 if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) || 2069 getValue(Record, OpNum, Vec1->getType(), Vec2)) 2070 return Error("Invalid SHUFFLEVEC record"); 2071 2072 if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) 2073 return Error("Invalid SHUFFLEVEC record"); 2074 I = new ShuffleVectorInst(Vec1, Vec2, Mask); 2075 InstructionList.push_back(I); 2076 break; 2077 } 2078 2079 case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred] 2080 // Old form of ICmp/FCmp returning bool 2081 // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were 2082 // both legal on vectors but had different behaviour. 2083 case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred] 2084 // FCmp/ICmp returning bool or vector of bool 2085 2086 unsigned OpNum = 0; 2087 Value *LHS, *RHS; 2088 if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 2089 getValue(Record, OpNum, LHS->getType(), RHS) || 2090 OpNum+1 != Record.size()) 2091 return Error("Invalid CMP record"); 2092 2093 if (LHS->getType()->isFPOrFPVectorTy()) 2094 I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); 2095 else 2096 I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS); 2097 InstructionList.push_back(I); 2098 break; 2099 } 2100 2101 case bitc::FUNC_CODE_INST_GETRESULT: { // GETRESULT: [ty, val, n] 2102 if (Record.size() != 2) 2103 return Error("Invalid GETRESULT record"); 2104 unsigned OpNum = 0; 2105 Value *Op; 2106 getValueTypePair(Record, OpNum, NextValueNo, Op); 2107 unsigned Index = Record[1]; 2108 I = ExtractValueInst::Create(Op, Index); 2109 InstructionList.push_back(I); 2110 break; 2111 } 2112 2113 case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>] 2114 { 2115 unsigned Size = Record.size(); 2116 if (Size == 0) { 2117 I = ReturnInst::Create(Context); 2118 InstructionList.push_back(I); 2119 break; 2120 } 2121 2122 unsigned OpNum = 0; 2123 SmallVector<Value *,4> Vs; 2124 do { 2125 Value *Op = NULL; 2126 if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2127 return Error("Invalid RET record"); 2128 Vs.push_back(Op); 2129 } while(OpNum != Record.size()); 2130 2131 const Type *ReturnType = F->getReturnType(); 2132 // Handle multiple return values. FIXME: Remove in LLVM 3.0. 2133 if (Vs.size() > 1 || 2134 (ReturnType->isStructTy() && 2135 (Vs.empty() || Vs[0]->getType() != ReturnType))) { 2136 Value *RV = UndefValue::get(ReturnType); 2137 for (unsigned i = 0, e = Vs.size(); i != e; ++i) { 2138 I = InsertValueInst::Create(RV, Vs[i], i, "mrv"); 2139 InstructionList.push_back(I); 2140 CurBB->getInstList().push_back(I); 2141 ValueList.AssignValue(I, NextValueNo++); 2142 RV = I; 2143 } 2144 I = ReturnInst::Create(Context, RV); 2145 InstructionList.push_back(I); 2146 break; 2147 } 2148 2149 I = ReturnInst::Create(Context, Vs[0]); 2150 InstructionList.push_back(I); 2151 break; 2152 } 2153 case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] 2154 if (Record.size() != 1 && Record.size() != 3) 2155 return Error("Invalid BR record"); 2156 BasicBlock *TrueDest = getBasicBlock(Record[0]); 2157 if (TrueDest == 0) 2158 return Error("Invalid BR record"); 2159 2160 if (Record.size() == 1) { 2161 I = BranchInst::Create(TrueDest); 2162 InstructionList.push_back(I); 2163 } 2164 else { 2165 BasicBlock *FalseDest = getBasicBlock(Record[1]); 2166 Value *Cond = getFnValueByID(Record[2], Type::getInt1Ty(Context)); 2167 if (FalseDest == 0 || Cond == 0) 2168 return Error("Invalid BR record"); 2169 I = BranchInst::Create(TrueDest, FalseDest, Cond); 2170 InstructionList.push_back(I); 2171 } 2172 break; 2173 } 2174 case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...] 2175 if (Record.size() < 3 || (Record.size() & 1) == 0) 2176 return Error("Invalid SWITCH record"); 2177 const Type *OpTy = getTypeByID(Record[0]); 2178 Value *Cond = getFnValueByID(Record[1], OpTy); 2179 BasicBlock *Default = getBasicBlock(Record[2]); 2180 if (OpTy == 0 || Cond == 0 || Default == 0) 2181 return Error("Invalid SWITCH record"); 2182 unsigned NumCases = (Record.size()-3)/2; 2183 SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); 2184 InstructionList.push_back(SI); 2185 for (unsigned i = 0, e = NumCases; i != e; ++i) { 2186 ConstantInt *CaseVal = 2187 dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy)); 2188 BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); 2189 if (CaseVal == 0 || DestBB == 0) { 2190 delete SI; 2191 return Error("Invalid SWITCH record!"); 2192 } 2193 SI->addCase(CaseVal, DestBB); 2194 } 2195 I = SI; 2196 break; 2197 } 2198 case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] 2199 if (Record.size() < 2) 2200 return Error("Invalid INDIRECTBR record"); 2201 const Type *OpTy = getTypeByID(Record[0]); 2202 Value *Address = getFnValueByID(Record[1], OpTy); 2203 if (OpTy == 0 || Address == 0) 2204 return Error("Invalid INDIRECTBR record"); 2205 unsigned NumDests = Record.size()-2; 2206 IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); 2207 InstructionList.push_back(IBI); 2208 for (unsigned i = 0, e = NumDests; i != e; ++i) { 2209 if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) { 2210 IBI->addDestination(DestBB); 2211 } else { 2212 delete IBI; 2213 return Error("Invalid INDIRECTBR record!"); 2214 } 2215 } 2216 I = IBI; 2217 break; 2218 } 2219 2220 case bitc::FUNC_CODE_INST_INVOKE: { 2221 // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] 2222 if (Record.size() < 4) return Error("Invalid INVOKE record"); 2223 AttrListPtr PAL = getAttributes(Record[0]); 2224 unsigned CCInfo = Record[1]; 2225 BasicBlock *NormalBB = getBasicBlock(Record[2]); 2226 BasicBlock *UnwindBB = getBasicBlock(Record[3]); 2227 2228 unsigned OpNum = 4; 2229 Value *Callee; 2230 if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 2231 return Error("Invalid INVOKE record"); 2232 2233 const PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); 2234 const FunctionType *FTy = !CalleeTy ? 0 : 2235 dyn_cast<FunctionType>(CalleeTy->getElementType()); 2236 2237 // Check that the right number of fixed parameters are here. 2238 if (FTy == 0 || NormalBB == 0 || UnwindBB == 0 || 2239 Record.size() < OpNum+FTy->getNumParams()) 2240 return Error("Invalid INVOKE record"); 2241 2242 SmallVector<Value*, 16> Ops; 2243 for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 2244 Ops.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 2245 if (Ops.back() == 0) return Error("Invalid INVOKE record"); 2246 } 2247 2248 if (!FTy->isVarArg()) { 2249 if (Record.size() != OpNum) 2250 return Error("Invalid INVOKE record"); 2251 } else { 2252 // Read type/value pairs for varargs params. 2253 while (OpNum != Record.size()) { 2254 Value *Op; 2255 if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2256 return Error("Invalid INVOKE record"); 2257 Ops.push_back(Op); 2258 } 2259 } 2260 2261 I = InvokeInst::Create(Callee, NormalBB, UnwindBB, 2262 Ops.begin(), Ops.end()); 2263 InstructionList.push_back(I); 2264 cast<InvokeInst>(I)->setCallingConv( 2265 static_cast<CallingConv::ID>(CCInfo)); 2266 cast<InvokeInst>(I)->setAttributes(PAL); 2267 break; 2268 } 2269 case bitc::FUNC_CODE_INST_UNWIND: // UNWIND 2270 I = new UnwindInst(Context); 2271 InstructionList.push_back(I); 2272 break; 2273 case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE 2274 I = new UnreachableInst(Context); 2275 InstructionList.push_back(I); 2276 break; 2277 case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...] 2278 if (Record.size() < 1 || ((Record.size()-1)&1)) 2279 return Error("Invalid PHI record"); 2280 const Type *Ty = getTypeByID(Record[0]); 2281 if (!Ty) return Error("Invalid PHI record"); 2282 2283 PHINode *PN = PHINode::Create(Ty); 2284 InstructionList.push_back(PN); 2285 PN->reserveOperandSpace((Record.size()-1)/2); 2286 2287 for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) { 2288 Value *V = getFnValueByID(Record[1+i], Ty); 2289 BasicBlock *BB = getBasicBlock(Record[2+i]); 2290 if (!V || !BB) return Error("Invalid PHI record"); 2291 PN->addIncoming(V, BB); 2292 } 2293 I = PN; 2294 break; 2295 } 2296 2297 case bitc::FUNC_CODE_INST_MALLOC: { // MALLOC: [instty, op, align] 2298 // Autoupgrade malloc instruction to malloc call. 2299 // FIXME: Remove in LLVM 3.0. 2300 if (Record.size() < 3) 2301 return Error("Invalid MALLOC record"); 2302 const PointerType *Ty = 2303 dyn_cast_or_null<PointerType>(getTypeByID(Record[0])); 2304 Value *Size = getFnValueByID(Record[1], Type::getInt32Ty(Context)); 2305 if (!Ty || !Size) return Error("Invalid MALLOC record"); 2306 if (!CurBB) return Error("Invalid malloc instruction with no BB"); 2307 const Type *Int32Ty = IntegerType::getInt32Ty(CurBB->getContext()); 2308 Constant *AllocSize = ConstantExpr::getSizeOf(Ty->getElementType()); 2309 AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, Int32Ty); 2310 I = CallInst::CreateMalloc(CurBB, Int32Ty, Ty->getElementType(), 2311 AllocSize, Size, NULL); 2312 InstructionList.push_back(I); 2313 break; 2314 } 2315 case bitc::FUNC_CODE_INST_FREE: { // FREE: [op, opty] 2316 unsigned OpNum = 0; 2317 Value *Op; 2318 if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2319 OpNum != Record.size()) 2320 return Error("Invalid FREE record"); 2321 if (!CurBB) return Error("Invalid free instruction with no BB"); 2322 I = CallInst::CreateFree(Op, CurBB); 2323 InstructionList.push_back(I); 2324 break; 2325 } 2326 case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align] 2327 // For backward compatibility, tolerate a lack of an opty, and use i32. 2328 // Remove this in LLVM 3.0. 2329 if (Record.size() < 3 || Record.size() > 4) 2330 return Error("Invalid ALLOCA record"); 2331 unsigned OpNum = 0; 2332 const PointerType *Ty = 2333 dyn_cast_or_null<PointerType>(getTypeByID(Record[OpNum++])); 2334 const Type *OpTy = Record.size() == 4 ? getTypeByID(Record[OpNum++]) : 2335 Type::getInt32Ty(Context); 2336 Value *Size = getFnValueByID(Record[OpNum++], OpTy); 2337 unsigned Align = Record[OpNum++]; 2338 if (!Ty || !Size) return Error("Invalid ALLOCA record"); 2339 I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); 2340 InstructionList.push_back(I); 2341 break; 2342 } 2343 case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol] 2344 unsigned OpNum = 0; 2345 Value *Op; 2346 if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2347 OpNum+2 != Record.size()) 2348 return Error("Invalid LOAD record"); 2349 2350 I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2351 InstructionList.push_back(I); 2352 break; 2353 } 2354 case bitc::FUNC_CODE_INST_STORE2: { // STORE2:[ptrty, ptr, val, align, vol] 2355 unsigned OpNum = 0; 2356 Value *Val, *Ptr; 2357 if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 2358 getValue(Record, OpNum, 2359 cast<PointerType>(Ptr->getType())->getElementType(), Val) || 2360 OpNum+2 != Record.size()) 2361 return Error("Invalid STORE record"); 2362 2363 I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2364 InstructionList.push_back(I); 2365 break; 2366 } 2367 case bitc::FUNC_CODE_INST_STORE: { // STORE:[val, valty, ptr, align, vol] 2368 // FIXME: Legacy form of store instruction. Should be removed in LLVM 3.0. 2369 unsigned OpNum = 0; 2370 Value *Val, *Ptr; 2371 if (getValueTypePair(Record, OpNum, NextValueNo, Val) || 2372 getValue(Record, OpNum, 2373 PointerType::getUnqual(Val->getType()), Ptr)|| 2374 OpNum+2 != Record.size()) 2375 return Error("Invalid STORE record"); 2376 2377 I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 2378 InstructionList.push_back(I); 2379 break; 2380 } 2381 // FIXME: Remove this in LLVM 3.0. 2382 case bitc::FUNC_CODE_INST_CALL: 2383 LLVM2_7MetadataDetected = true; 2384 case bitc::FUNC_CODE_INST_CALL2: { 2385 // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] 2386 if (Record.size() < 3) 2387 return Error("Invalid CALL record"); 2388 2389 AttrListPtr PAL = getAttributes(Record[0]); 2390 unsigned CCInfo = Record[1]; 2391 2392 unsigned OpNum = 2; 2393 Value *Callee; 2394 if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 2395 return Error("Invalid CALL record"); 2396 2397 const PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); 2398 const FunctionType *FTy = 0; 2399 if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType()); 2400 if (!FTy || Record.size() < FTy->getNumParams()+OpNum) 2401 return Error("Invalid CALL record"); 2402 2403 SmallVector<Value*, 16> Args; 2404 // Read the fixed params. 2405 for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 2406 if (FTy->getParamType(i)->getTypeID()==Type::LabelTyID) 2407 Args.push_back(getBasicBlock(Record[OpNum])); 2408 else 2409 Args.push_back(getFnValueByID(Record[OpNum], FTy->getParamType(i))); 2410 if (Args.back() == 0) return Error("Invalid CALL record"); 2411 } 2412 2413 // Read type/value pairs for varargs params. 2414 if (!FTy->isVarArg()) { 2415 if (OpNum != Record.size()) 2416 return Error("Invalid CALL record"); 2417 } else { 2418 while (OpNum != Record.size()) { 2419 Value *Op; 2420 if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2421 return Error("Invalid CALL record"); 2422 Args.push_back(Op); 2423 } 2424 } 2425 2426 I = CallInst::Create(Callee, Args.begin(), Args.end()); 2427 InstructionList.push_back(I); 2428 cast<CallInst>(I)->setCallingConv( 2429 static_cast<CallingConv::ID>(CCInfo>>1)); 2430 cast<CallInst>(I)->setTailCall(CCInfo & 1); 2431 cast<CallInst>(I)->setAttributes(PAL); 2432 break; 2433 } 2434 case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] 2435 if (Record.size() < 3) 2436 return Error("Invalid VAARG record"); 2437 const Type *OpTy = getTypeByID(Record[0]); 2438 Value *Op = getFnValueByID(Record[1], OpTy); 2439 const Type *ResTy = getTypeByID(Record[2]); 2440 if (!OpTy || !Op || !ResTy) 2441 return Error("Invalid VAARG record"); 2442 I = new VAArgInst(Op, ResTy); 2443 InstructionList.push_back(I); 2444 break; 2445 } 2446 } 2447 2448 // Add instruction to end of current BB. If there is no current BB, reject 2449 // this file. 2450 if (CurBB == 0) { 2451 delete I; 2452 return Error("Invalid instruction with no BB"); 2453 } 2454 CurBB->getInstList().push_back(I); 2455 2456 // If this was a terminator instruction, move to the next block. 2457 if (isa<TerminatorInst>(I)) { 2458 ++CurBBNo; 2459 CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0; 2460 } 2461 2462 // Non-void values get registered in the value table for future use. 2463 if (I && !I->getType()->isVoidTy()) 2464 ValueList.AssignValue(I, NextValueNo++); 2465 } 2466 2467 // Check the function list for unresolved values. 2468 if (Argument *A = dyn_cast<Argument>(ValueList.back())) { 2469 if (A->getParent() == 0) { 2470 // We found at least one unresolved value. Nuke them all to avoid leaks. 2471 for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){ 2472 if ((A = dyn_cast<Argument>(ValueList[i])) && A->getParent() == 0) { 2473 A->replaceAllUsesWith(UndefValue::get(A->getType())); 2474 delete A; 2475 } 2476 } 2477 return Error("Never resolved value found in function!"); 2478 } 2479 } 2480 2481 // FIXME: Check for unresolved forward-declared metadata references 2482 // and clean up leaks. 2483 2484 // See if anything took the address of blocks in this function. If so, 2485 // resolve them now. 2486 DenseMap<Function*, std::vector<BlockAddrRefTy> >::iterator BAFRI = 2487 BlockAddrFwdRefs.find(F); 2488 if (BAFRI != BlockAddrFwdRefs.end()) { 2489 std::vector<BlockAddrRefTy> &RefList = BAFRI->second; 2490 for (unsigned i = 0, e = RefList.size(); i != e; ++i) { 2491 unsigned BlockIdx = RefList[i].first; 2492 if (BlockIdx >= FunctionBBs.size()) 2493 return Error("Invalid blockaddress block #"); 2494 2495 GlobalVariable *FwdRef = RefList[i].second; 2496 FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx])); 2497 FwdRef->eraseFromParent(); 2498 } 2499 2500 BlockAddrFwdRefs.erase(BAFRI); 2501 } 2502 2503 // FIXME: Remove this in LLVM 3.0. 2504 unsigned NewMDValueListSize = MDValueList.size(); 2505 2506 // Trim the value list down to the size it was before we parsed this function. 2507 ValueList.shrinkTo(ModuleValueListSize); 2508 MDValueList.shrinkTo(ModuleMDValueListSize); 2509 2510 // Backwards compatibility hack: Function-local metadata numbers 2511 // were previously not reset between functions. This is now fixed, 2512 // however we still need to understand the old numbering in order 2513 // to be able to read old bitcode files. 2514 // FIXME: Remove this in LLVM 3.0. 2515 if (LLVM2_7MetadataDetected) 2516 MDValueList.resize(NewMDValueListSize); 2517 2518 std::vector<BasicBlock*>().swap(FunctionBBs); 2519 2520 return false; 2521} 2522 2523//===----------------------------------------------------------------------===// 2524// GVMaterializer implementation 2525//===----------------------------------------------------------------------===// 2526 2527 2528bool BitcodeReader::isMaterializable(const GlobalValue *GV) const { 2529 if (const Function *F = dyn_cast<Function>(GV)) { 2530 return F->isDeclaration() && 2531 DeferredFunctionInfo.count(const_cast<Function*>(F)); 2532 } 2533 return false; 2534} 2535 2536bool BitcodeReader::Materialize(GlobalValue *GV, std::string *ErrInfo) { 2537 Function *F = dyn_cast<Function>(GV); 2538 // If it's not a function or is already material, ignore the request. 2539 if (!F || !F->isMaterializable()) return false; 2540 2541 DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F); 2542 assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!"); 2543 2544 // Move the bit stream to the saved position of the deferred function body. 2545 Stream.JumpToBit(DFII->second); 2546 2547 if (ParseFunctionBody(F)) { 2548 if (ErrInfo) *ErrInfo = ErrorString; 2549 return true; 2550 } 2551 2552 // Upgrade any old intrinsic calls in the function. 2553 for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(), 2554 E = UpgradedIntrinsics.end(); I != E; ++I) { 2555 if (I->first != I->second) { 2556 for (Value::use_iterator UI = I->first->use_begin(), 2557 UE = I->first->use_end(); UI != UE; ) { 2558 if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 2559 UpgradeIntrinsicCall(CI, I->second); 2560 } 2561 } 2562 } 2563 2564 return false; 2565} 2566 2567bool BitcodeReader::isDematerializable(const GlobalValue *GV) const { 2568 const Function *F = dyn_cast<Function>(GV); 2569 if (!F || F->isDeclaration()) 2570 return false; 2571 return DeferredFunctionInfo.count(const_cast<Function*>(F)); 2572} 2573 2574void BitcodeReader::Dematerialize(GlobalValue *GV) { 2575 Function *F = dyn_cast<Function>(GV); 2576 // If this function isn't dematerializable, this is a noop. 2577 if (!F || !isDematerializable(F)) 2578 return; 2579 2580 assert(DeferredFunctionInfo.count(F) && "No info to read function later?"); 2581 2582 // Just forget the function body, we can remat it later. 2583 F->deleteBody(); 2584} 2585 2586 2587bool BitcodeReader::MaterializeModule(Module *M, std::string *ErrInfo) { 2588 assert(M == TheModule && 2589 "Can only Materialize the Module this BitcodeReader is attached to."); 2590 // Iterate over the module, deserializing any functions that are still on 2591 // disk. 2592 for (Module::iterator F = TheModule->begin(), E = TheModule->end(); 2593 F != E; ++F) 2594 if (F->isMaterializable() && 2595 Materialize(F, ErrInfo)) 2596 return true; 2597 2598 // Upgrade any intrinsic calls that slipped through (should not happen!) and 2599 // delete the old functions to clean up. We can't do this unless the entire 2600 // module is materialized because there could always be another function body 2601 // with calls to the old function. 2602 for (std::vector<std::pair<Function*, Function*> >::iterator I = 2603 UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) { 2604 if (I->first != I->second) { 2605 for (Value::use_iterator UI = I->first->use_begin(), 2606 UE = I->first->use_end(); UI != UE; ) { 2607 if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 2608 UpgradeIntrinsicCall(CI, I->second); 2609 } 2610 if (!I->first->use_empty()) 2611 I->first->replaceAllUsesWith(I->second); 2612 I->first->eraseFromParent(); 2613 } 2614 } 2615 std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics); 2616 2617 // Check debug info intrinsics. 2618 CheckDebugInfoIntrinsics(TheModule); 2619 2620 return false; 2621} 2622 2623 2624//===----------------------------------------------------------------------===// 2625// External interface 2626//===----------------------------------------------------------------------===// 2627 2628/// getLazyBitcodeModule - lazy function-at-a-time loading from a file. 2629/// 2630Module *llvm::getLazyBitcodeModule(MemoryBuffer *Buffer, 2631 LLVMContext& Context, 2632 std::string *ErrMsg) { 2633 Module *M = new Module(Buffer->getBufferIdentifier(), Context); 2634 BitcodeReader *R = new BitcodeReader(Buffer, Context); 2635 M->setMaterializer(R); 2636 if (R->ParseBitcodeInto(M)) { 2637 if (ErrMsg) 2638 *ErrMsg = R->getErrorString(); 2639 2640 delete M; // Also deletes R. 2641 return 0; 2642 } 2643 // Have the BitcodeReader dtor delete 'Buffer'. 2644 R->setBufferOwned(true); 2645 return M; 2646} 2647 2648/// ParseBitcodeFile - Read the specified bitcode file, returning the module. 2649/// If an error occurs, return null and fill in *ErrMsg if non-null. 2650Module *llvm::ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext& Context, 2651 std::string *ErrMsg){ 2652 Module *M = getLazyBitcodeModule(Buffer, Context, ErrMsg); 2653 if (!M) return 0; 2654 2655 // Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether 2656 // there was an error. 2657 static_cast<BitcodeReader*>(M->getMaterializer())->setBufferOwned(false); 2658 2659 // Read in the entire module, and destroy the BitcodeReader. 2660 if (M->MaterializeAllPermanently(ErrMsg)) { 2661 delete M; 2662 return 0; 2663 } 2664 2665 return M; 2666} 2667 2668std::string llvm::getBitcodeTargetTriple(MemoryBuffer *Buffer, 2669 LLVMContext& Context, 2670 std::string *ErrMsg) { 2671 BitcodeReader *R = new BitcodeReader(Buffer, Context); 2672 // Don't let the BitcodeReader dtor delete 'Buffer'. 2673 R->setBufferOwned(false); 2674 2675 std::string Triple(""); 2676 if (R->ParseTriple(Triple)) 2677 if (ErrMsg) 2678 *ErrMsg = R->getErrorString(); 2679 2680 delete R; 2681 return Triple; 2682} 2683