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