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 #include "llvm/Bitcode/ReaderWriter.h" 11 #include "BitcodeReader.h" 12 #include "llvm/ADT/SmallString.h" 13 #include "llvm/ADT/SmallVector.h" 14 #include "llvm/Bitcode/LLVMBitCodes.h" 15 #include "llvm/IR/AutoUpgrade.h" 16 #include "llvm/IR/Constants.h" 17 #include "llvm/IR/DerivedTypes.h" 18 #include "llvm/IR/InlineAsm.h" 19 #include "llvm/IR/IntrinsicInst.h" 20 #include "llvm/IR/LLVMContext.h" 21 #include "llvm/IR/Module.h" 22 #include "llvm/IR/OperandTraits.h" 23 #include "llvm/IR/Operator.h" 24 #include "llvm/Support/DataStream.h" 25 #include "llvm/Support/MathExtras.h" 26 #include "llvm/Support/MemoryBuffer.h" 27 #include "llvm/Support/raw_ostream.h" 28 #include "llvm/Support/ManagedStatic.h" 29 30 using namespace llvm; 31 32 enum { 33 SWITCH_INST_MAGIC = 0x4B5 // May 2012 => 1205 => Hex 34 }; 35 36 std::error_code BitcodeReader::materializeForwardReferencedFunctions() { 37 if (WillMaterializeAllForwardRefs) 38 return std::error_code(); 39 40 // Prevent recursion. 41 WillMaterializeAllForwardRefs = true; 42 43 while (!BasicBlockFwdRefQueue.empty()) { 44 Function *F = BasicBlockFwdRefQueue.front(); 45 BasicBlockFwdRefQueue.pop_front(); 46 assert(F && "Expected valid function"); 47 if (!BasicBlockFwdRefs.count(F)) 48 // Already materialized. 49 continue; 50 51 // Check for a function that isn't materializable to prevent an infinite 52 // loop. When parsing a blockaddress stored in a global variable, there 53 // isn't a trivial way to check if a function will have a body without a 54 // linear search through FunctionsWithBodies, so just check it here. 55 if (!F->isMaterializable()) 56 return Error(BitcodeError::NeverResolvedFunctionFromBlockAddress); 57 58 // Try to materialize F. 59 if (std::error_code EC = Materialize(F)) 60 return EC; 61 } 62 assert(BasicBlockFwdRefs.empty() && "Function missing from queue"); 63 64 // Reset state. 65 WillMaterializeAllForwardRefs = false; 66 return std::error_code(); 67 } 68 69 void BitcodeReader::FreeState() { 70 Buffer = nullptr; 71 std::vector<Type*>().swap(TypeList); 72 ValueList.clear(); 73 MDValueList.clear(); 74 std::vector<Comdat *>().swap(ComdatList); 75 76 std::vector<AttributeSet>().swap(MAttributes); 77 std::vector<BasicBlock*>().swap(FunctionBBs); 78 std::vector<Function*>().swap(FunctionsWithBodies); 79 DeferredFunctionInfo.clear(); 80 MDKindMap.clear(); 81 82 assert(BasicBlockFwdRefs.empty() && "Unresolved blockaddress fwd references"); 83 BasicBlockFwdRefQueue.clear(); 84 } 85 86 //===----------------------------------------------------------------------===// 87 // Helper functions to implement forward reference resolution, etc. 88 //===----------------------------------------------------------------------===// 89 90 /// ConvertToString - Convert a string from a record into an std::string, return 91 /// true on failure. 92 template<typename StrTy> 93 static bool ConvertToString(ArrayRef<uint64_t> Record, unsigned Idx, 94 StrTy &Result) { 95 if (Idx > Record.size()) 96 return true; 97 98 for (unsigned i = Idx, e = Record.size(); i != e; ++i) 99 Result += (char)Record[i]; 100 return false; 101 } 102 103 static GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) { 104 switch (Val) { 105 default: // Map unknown/new linkages to external 106 case 0: return GlobalValue::ExternalLinkage; 107 case 1: return GlobalValue::WeakAnyLinkage; 108 case 2: return GlobalValue::AppendingLinkage; 109 case 3: return GlobalValue::InternalLinkage; 110 case 4: return GlobalValue::LinkOnceAnyLinkage; 111 case 5: return GlobalValue::ExternalLinkage; // Obsolete DLLImportLinkage 112 case 6: return GlobalValue::ExternalLinkage; // Obsolete DLLExportLinkage 113 case 7: return GlobalValue::ExternalWeakLinkage; 114 case 8: return GlobalValue::CommonLinkage; 115 case 9: return GlobalValue::PrivateLinkage; 116 case 10: return GlobalValue::WeakODRLinkage; 117 case 11: return GlobalValue::LinkOnceODRLinkage; 118 case 12: return GlobalValue::AvailableExternallyLinkage; 119 case 13: 120 return GlobalValue::PrivateLinkage; // Obsolete LinkerPrivateLinkage 121 case 14: 122 return GlobalValue::PrivateLinkage; // Obsolete LinkerPrivateWeakLinkage 123 } 124 } 125 126 static GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) { 127 switch (Val) { 128 default: // Map unknown visibilities to default. 129 case 0: return GlobalValue::DefaultVisibility; 130 case 1: return GlobalValue::HiddenVisibility; 131 case 2: return GlobalValue::ProtectedVisibility; 132 } 133 } 134 135 static GlobalValue::DLLStorageClassTypes 136 GetDecodedDLLStorageClass(unsigned Val) { 137 switch (Val) { 138 default: // Map unknown values to default. 139 case 0: return GlobalValue::DefaultStorageClass; 140 case 1: return GlobalValue::DLLImportStorageClass; 141 case 2: return GlobalValue::DLLExportStorageClass; 142 } 143 } 144 145 static GlobalVariable::ThreadLocalMode GetDecodedThreadLocalMode(unsigned Val) { 146 switch (Val) { 147 case 0: return GlobalVariable::NotThreadLocal; 148 default: // Map unknown non-zero value to general dynamic. 149 case 1: return GlobalVariable::GeneralDynamicTLSModel; 150 case 2: return GlobalVariable::LocalDynamicTLSModel; 151 case 3: return GlobalVariable::InitialExecTLSModel; 152 case 4: return GlobalVariable::LocalExecTLSModel; 153 } 154 } 155 156 static int GetDecodedCastOpcode(unsigned Val) { 157 switch (Val) { 158 default: return -1; 159 case bitc::CAST_TRUNC : return Instruction::Trunc; 160 case bitc::CAST_ZEXT : return Instruction::ZExt; 161 case bitc::CAST_SEXT : return Instruction::SExt; 162 case bitc::CAST_FPTOUI : return Instruction::FPToUI; 163 case bitc::CAST_FPTOSI : return Instruction::FPToSI; 164 case bitc::CAST_UITOFP : return Instruction::UIToFP; 165 case bitc::CAST_SITOFP : return Instruction::SIToFP; 166 case bitc::CAST_FPTRUNC : return Instruction::FPTrunc; 167 case bitc::CAST_FPEXT : return Instruction::FPExt; 168 case bitc::CAST_PTRTOINT: return Instruction::PtrToInt; 169 case bitc::CAST_INTTOPTR: return Instruction::IntToPtr; 170 case bitc::CAST_BITCAST : return Instruction::BitCast; 171 case bitc::CAST_ADDRSPACECAST: return Instruction::AddrSpaceCast; 172 } 173 } 174 static int GetDecodedBinaryOpcode(unsigned Val, Type *Ty) { 175 switch (Val) { 176 default: return -1; 177 case bitc::BINOP_ADD: 178 return Ty->isFPOrFPVectorTy() ? Instruction::FAdd : Instruction::Add; 179 case bitc::BINOP_SUB: 180 return Ty->isFPOrFPVectorTy() ? Instruction::FSub : Instruction::Sub; 181 case bitc::BINOP_MUL: 182 return Ty->isFPOrFPVectorTy() ? Instruction::FMul : Instruction::Mul; 183 case bitc::BINOP_UDIV: return Instruction::UDiv; 184 case bitc::BINOP_SDIV: 185 return Ty->isFPOrFPVectorTy() ? Instruction::FDiv : Instruction::SDiv; 186 case bitc::BINOP_UREM: return Instruction::URem; 187 case bitc::BINOP_SREM: 188 return Ty->isFPOrFPVectorTy() ? Instruction::FRem : Instruction::SRem; 189 case bitc::BINOP_SHL: return Instruction::Shl; 190 case bitc::BINOP_LSHR: return Instruction::LShr; 191 case bitc::BINOP_ASHR: return Instruction::AShr; 192 case bitc::BINOP_AND: return Instruction::And; 193 case bitc::BINOP_OR: return Instruction::Or; 194 case bitc::BINOP_XOR: return Instruction::Xor; 195 } 196 } 197 198 static AtomicRMWInst::BinOp GetDecodedRMWOperation(unsigned Val) { 199 switch (Val) { 200 default: return AtomicRMWInst::BAD_BINOP; 201 case bitc::RMW_XCHG: return AtomicRMWInst::Xchg; 202 case bitc::RMW_ADD: return AtomicRMWInst::Add; 203 case bitc::RMW_SUB: return AtomicRMWInst::Sub; 204 case bitc::RMW_AND: return AtomicRMWInst::And; 205 case bitc::RMW_NAND: return AtomicRMWInst::Nand; 206 case bitc::RMW_OR: return AtomicRMWInst::Or; 207 case bitc::RMW_XOR: return AtomicRMWInst::Xor; 208 case bitc::RMW_MAX: return AtomicRMWInst::Max; 209 case bitc::RMW_MIN: return AtomicRMWInst::Min; 210 case bitc::RMW_UMAX: return AtomicRMWInst::UMax; 211 case bitc::RMW_UMIN: return AtomicRMWInst::UMin; 212 } 213 } 214 215 static AtomicOrdering GetDecodedOrdering(unsigned Val) { 216 switch (Val) { 217 case bitc::ORDERING_NOTATOMIC: return NotAtomic; 218 case bitc::ORDERING_UNORDERED: return Unordered; 219 case bitc::ORDERING_MONOTONIC: return Monotonic; 220 case bitc::ORDERING_ACQUIRE: return Acquire; 221 case bitc::ORDERING_RELEASE: return Release; 222 case bitc::ORDERING_ACQREL: return AcquireRelease; 223 default: // Map unknown orderings to sequentially-consistent. 224 case bitc::ORDERING_SEQCST: return SequentiallyConsistent; 225 } 226 } 227 228 static SynchronizationScope GetDecodedSynchScope(unsigned Val) { 229 switch (Val) { 230 case bitc::SYNCHSCOPE_SINGLETHREAD: return SingleThread; 231 default: // Map unknown scopes to cross-thread. 232 case bitc::SYNCHSCOPE_CROSSTHREAD: return CrossThread; 233 } 234 } 235 236 static Comdat::SelectionKind getDecodedComdatSelectionKind(unsigned Val) { 237 switch (Val) { 238 default: // Map unknown selection kinds to any. 239 case bitc::COMDAT_SELECTION_KIND_ANY: 240 return Comdat::Any; 241 case bitc::COMDAT_SELECTION_KIND_EXACT_MATCH: 242 return Comdat::ExactMatch; 243 case bitc::COMDAT_SELECTION_KIND_LARGEST: 244 return Comdat::Largest; 245 case bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES: 246 return Comdat::NoDuplicates; 247 case bitc::COMDAT_SELECTION_KIND_SAME_SIZE: 248 return Comdat::SameSize; 249 } 250 } 251 252 static void UpgradeDLLImportExportLinkage(llvm::GlobalValue *GV, unsigned Val) { 253 switch (Val) { 254 case 5: GV->setDLLStorageClass(GlobalValue::DLLImportStorageClass); break; 255 case 6: GV->setDLLStorageClass(GlobalValue::DLLExportStorageClass); break; 256 } 257 } 258 259 namespace llvm { 260 namespace { 261 /// @brief A class for maintaining the slot number definition 262 /// as a placeholder for the actual definition for forward constants defs. 263 class ConstantPlaceHolder : public ConstantExpr { 264 void operator=(const ConstantPlaceHolder &) LLVM_DELETED_FUNCTION; 265 public: 266 // allocate space for exactly one operand 267 void *operator new(size_t s) { 268 return User::operator new(s, 1); 269 } 270 explicit ConstantPlaceHolder(Type *Ty, LLVMContext& Context) 271 : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) { 272 Op<0>() = UndefValue::get(Type::getInt32Ty(Context)); 273 } 274 275 /// @brief Methods to support type inquiry through isa, cast, and dyn_cast. 276 static bool classof(const Value *V) { 277 return isa<ConstantExpr>(V) && 278 cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1; 279 } 280 281 282 /// Provide fast operand accessors 283 //DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 284 }; 285 } 286 287 // FIXME: can we inherit this from ConstantExpr? 288 template <> 289 struct OperandTraits<ConstantPlaceHolder> : 290 public FixedNumOperandTraits<ConstantPlaceHolder, 1> { 291 }; 292 } 293 294 295 void BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) { 296 if (Idx == size()) { 297 push_back(V); 298 return; 299 } 300 301 if (Idx >= size()) 302 resize(Idx+1); 303 304 WeakVH &OldV = ValuePtrs[Idx]; 305 if (!OldV) { 306 OldV = V; 307 return; 308 } 309 310 // Handle constants and non-constants (e.g. instrs) differently for 311 // efficiency. 312 if (Constant *PHC = dyn_cast<Constant>(&*OldV)) { 313 ResolveConstants.push_back(std::make_pair(PHC, Idx)); 314 OldV = V; 315 } else { 316 // If there was a forward reference to this value, replace it. 317 Value *PrevVal = OldV; 318 OldV->replaceAllUsesWith(V); 319 delete PrevVal; 320 } 321 } 322 323 324 Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, 325 Type *Ty) { 326 if (Idx >= size()) 327 resize(Idx + 1); 328 329 if (Value *V = ValuePtrs[Idx]) { 330 assert(Ty == V->getType() && "Type mismatch in constant table!"); 331 return cast<Constant>(V); 332 } 333 334 // Create and return a placeholder, which will later be RAUW'd. 335 Constant *C = new ConstantPlaceHolder(Ty, Context); 336 ValuePtrs[Idx] = C; 337 return C; 338 } 339 340 Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty) { 341 if (Idx >= size()) 342 resize(Idx + 1); 343 344 if (Value *V = ValuePtrs[Idx]) { 345 assert((!Ty || Ty == V->getType()) && "Type mismatch in value table!"); 346 return V; 347 } 348 349 // No type specified, must be invalid reference. 350 if (!Ty) return nullptr; 351 352 // Create and return a placeholder, which will later be RAUW'd. 353 Value *V = new Argument(Ty); 354 ValuePtrs[Idx] = V; 355 return V; 356 } 357 358 /// ResolveConstantForwardRefs - Once all constants are read, this method bulk 359 /// resolves any forward references. The idea behind this is that we sometimes 360 /// get constants (such as large arrays) which reference *many* forward ref 361 /// constants. Replacing each of these causes a lot of thrashing when 362 /// building/reuniquing the constant. Instead of doing this, we look at all the 363 /// uses and rewrite all the place holders at once for any constant that uses 364 /// a placeholder. 365 void BitcodeReaderValueList::ResolveConstantForwardRefs() { 366 // Sort the values by-pointer so that they are efficient to look up with a 367 // binary search. 368 std::sort(ResolveConstants.begin(), ResolveConstants.end()); 369 370 SmallVector<Constant*, 64> NewOps; 371 372 while (!ResolveConstants.empty()) { 373 Value *RealVal = operator[](ResolveConstants.back().second); 374 Constant *Placeholder = ResolveConstants.back().first; 375 ResolveConstants.pop_back(); 376 377 // Loop over all users of the placeholder, updating them to reference the 378 // new value. If they reference more than one placeholder, update them all 379 // at once. 380 while (!Placeholder->use_empty()) { 381 auto UI = Placeholder->user_begin(); 382 User *U = *UI; 383 384 // If the using object isn't uniqued, just update the operands. This 385 // handles instructions and initializers for global variables. 386 if (!isa<Constant>(U) || isa<GlobalValue>(U)) { 387 UI.getUse().set(RealVal); 388 continue; 389 } 390 391 // Otherwise, we have a constant that uses the placeholder. Replace that 392 // constant with a new constant that has *all* placeholder uses updated. 393 Constant *UserC = cast<Constant>(U); 394 for (User::op_iterator I = UserC->op_begin(), E = UserC->op_end(); 395 I != E; ++I) { 396 Value *NewOp; 397 if (!isa<ConstantPlaceHolder>(*I)) { 398 // Not a placeholder reference. 399 NewOp = *I; 400 } else if (*I == Placeholder) { 401 // Common case is that it just references this one placeholder. 402 NewOp = RealVal; 403 } else { 404 // Otherwise, look up the placeholder in ResolveConstants. 405 ResolveConstantsTy::iterator It = 406 std::lower_bound(ResolveConstants.begin(), ResolveConstants.end(), 407 std::pair<Constant*, unsigned>(cast<Constant>(*I), 408 0)); 409 assert(It != ResolveConstants.end() && It->first == *I); 410 NewOp = operator[](It->second); 411 } 412 413 NewOps.push_back(cast<Constant>(NewOp)); 414 } 415 416 // Make the new constant. 417 Constant *NewC; 418 if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) { 419 NewC = ConstantArray::get(UserCA->getType(), NewOps); 420 } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) { 421 NewC = ConstantStruct::get(UserCS->getType(), NewOps); 422 } else if (isa<ConstantVector>(UserC)) { 423 NewC = ConstantVector::get(NewOps); 424 } else { 425 assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr."); 426 NewC = cast<ConstantExpr>(UserC)->getWithOperands(NewOps); 427 } 428 429 UserC->replaceAllUsesWith(NewC); 430 UserC->destroyConstant(); 431 NewOps.clear(); 432 } 433 434 // Update all ValueHandles, they should be the only users at this point. 435 Placeholder->replaceAllUsesWith(RealVal); 436 delete Placeholder; 437 } 438 } 439 440 void BitcodeReaderMDValueList::AssignValue(Value *V, unsigned Idx) { 441 if (Idx == size()) { 442 push_back(V); 443 return; 444 } 445 446 if (Idx >= size()) 447 resize(Idx+1); 448 449 WeakVH &OldV = MDValuePtrs[Idx]; 450 if (!OldV) { 451 OldV = V; 452 return; 453 } 454 455 // If there was a forward reference to this value, replace it. 456 MDNode *PrevVal = cast<MDNode>(OldV); 457 OldV->replaceAllUsesWith(V); 458 MDNode::deleteTemporary(PrevVal); 459 // Deleting PrevVal sets Idx value in MDValuePtrs to null. Set new 460 // value for Idx. 461 MDValuePtrs[Idx] = V; 462 } 463 464 Value *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { 465 if (Idx >= size()) 466 resize(Idx + 1); 467 468 if (Value *V = MDValuePtrs[Idx]) { 469 assert(V->getType()->isMetadataTy() && "Type mismatch in value table!"); 470 return V; 471 } 472 473 // Create and return a placeholder, which will later be RAUW'd. 474 Value *V = MDNode::getTemporary(Context, None); 475 MDValuePtrs[Idx] = V; 476 return V; 477 } 478 479 Type *BitcodeReader::getTypeByID(unsigned ID) { 480 // The type table size is always specified correctly. 481 if (ID >= TypeList.size()) 482 return nullptr; 483 484 if (Type *Ty = TypeList[ID]) 485 return Ty; 486 487 // If we have a forward reference, the only possible case is when it is to a 488 // named struct. Just create a placeholder for now. 489 return TypeList[ID] = StructType::create(Context); 490 } 491 492 493 //===----------------------------------------------------------------------===// 494 // Functions for parsing blocks from the bitcode file 495 //===----------------------------------------------------------------------===// 496 497 498 /// \brief This fills an AttrBuilder object with the LLVM attributes that have 499 /// been decoded from the given integer. This function must stay in sync with 500 /// 'encodeLLVMAttributesForBitcode'. 501 static void decodeLLVMAttributesForBitcode(AttrBuilder &B, 502 uint64_t EncodedAttrs) { 503 // FIXME: Remove in 4.0. 504 505 // The alignment is stored as a 16-bit raw value from bits 31--16. We shift 506 // the bits above 31 down by 11 bits. 507 unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16; 508 assert((!Alignment || isPowerOf2_32(Alignment)) && 509 "Alignment must be a power of two."); 510 511 if (Alignment) 512 B.addAlignmentAttr(Alignment); 513 B.addRawValue(((EncodedAttrs & (0xfffffULL << 32)) >> 11) | 514 (EncodedAttrs & 0xffff)); 515 } 516 517 std::error_code BitcodeReader::ParseAttributeBlock() { 518 if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) 519 return Error(BitcodeError::InvalidRecord); 520 521 if (!MAttributes.empty()) 522 return Error(BitcodeError::InvalidMultipleBlocks); 523 524 SmallVector<uint64_t, 64> Record; 525 526 SmallVector<AttributeSet, 8> Attrs; 527 528 // Read all the records. 529 while (1) { 530 BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 531 532 switch (Entry.Kind) { 533 case BitstreamEntry::SubBlock: // Handled for us already. 534 case BitstreamEntry::Error: 535 return Error(BitcodeError::MalformedBlock); 536 case BitstreamEntry::EndBlock: 537 return std::error_code(); 538 case BitstreamEntry::Record: 539 // The interesting case. 540 break; 541 } 542 543 // Read a record. 544 Record.clear(); 545 switch (Stream.readRecord(Entry.ID, Record)) { 546 default: // Default behavior: ignore. 547 break; 548 case bitc::PARAMATTR_CODE_ENTRY_OLD: { // ENTRY: [paramidx0, attr0, ...] 549 // FIXME: Remove in 4.0. 550 if (Record.size() & 1) 551 return Error(BitcodeError::InvalidRecord); 552 553 for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 554 AttrBuilder B; 555 decodeLLVMAttributesForBitcode(B, Record[i+1]); 556 Attrs.push_back(AttributeSet::get(Context, Record[i], B)); 557 } 558 559 MAttributes.push_back(AttributeSet::get(Context, Attrs)); 560 Attrs.clear(); 561 break; 562 } 563 case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [attrgrp0, attrgrp1, ...] 564 for (unsigned i = 0, e = Record.size(); i != e; ++i) 565 Attrs.push_back(MAttributeGroups[Record[i]]); 566 567 MAttributes.push_back(AttributeSet::get(Context, Attrs)); 568 Attrs.clear(); 569 break; 570 } 571 } 572 } 573 } 574 575 // Returns Attribute::None on unrecognized codes. 576 static Attribute::AttrKind GetAttrFromCode(uint64_t Code) { 577 switch (Code) { 578 default: 579 return Attribute::None; 580 case bitc::ATTR_KIND_ALIGNMENT: 581 return Attribute::Alignment; 582 case bitc::ATTR_KIND_ALWAYS_INLINE: 583 return Attribute::AlwaysInline; 584 case bitc::ATTR_KIND_BUILTIN: 585 return Attribute::Builtin; 586 case bitc::ATTR_KIND_BY_VAL: 587 return Attribute::ByVal; 588 case bitc::ATTR_KIND_IN_ALLOCA: 589 return Attribute::InAlloca; 590 case bitc::ATTR_KIND_COLD: 591 return Attribute::Cold; 592 case bitc::ATTR_KIND_INLINE_HINT: 593 return Attribute::InlineHint; 594 case bitc::ATTR_KIND_IN_REG: 595 return Attribute::InReg; 596 case bitc::ATTR_KIND_JUMP_TABLE: 597 return Attribute::JumpTable; 598 case bitc::ATTR_KIND_MIN_SIZE: 599 return Attribute::MinSize; 600 case bitc::ATTR_KIND_NAKED: 601 return Attribute::Naked; 602 case bitc::ATTR_KIND_NEST: 603 return Attribute::Nest; 604 case bitc::ATTR_KIND_NO_ALIAS: 605 return Attribute::NoAlias; 606 case bitc::ATTR_KIND_NO_BUILTIN: 607 return Attribute::NoBuiltin; 608 case bitc::ATTR_KIND_NO_CAPTURE: 609 return Attribute::NoCapture; 610 case bitc::ATTR_KIND_NO_DUPLICATE: 611 return Attribute::NoDuplicate; 612 case bitc::ATTR_KIND_NO_IMPLICIT_FLOAT: 613 return Attribute::NoImplicitFloat; 614 case bitc::ATTR_KIND_NO_INLINE: 615 return Attribute::NoInline; 616 case bitc::ATTR_KIND_NON_LAZY_BIND: 617 return Attribute::NonLazyBind; 618 case bitc::ATTR_KIND_NON_NULL: 619 return Attribute::NonNull; 620 case bitc::ATTR_KIND_DEREFERENCEABLE: 621 return Attribute::Dereferenceable; 622 case bitc::ATTR_KIND_NO_RED_ZONE: 623 return Attribute::NoRedZone; 624 case bitc::ATTR_KIND_NO_RETURN: 625 return Attribute::NoReturn; 626 case bitc::ATTR_KIND_NO_UNWIND: 627 return Attribute::NoUnwind; 628 case bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE: 629 return Attribute::OptimizeForSize; 630 case bitc::ATTR_KIND_OPTIMIZE_NONE: 631 return Attribute::OptimizeNone; 632 case bitc::ATTR_KIND_READ_NONE: 633 return Attribute::ReadNone; 634 case bitc::ATTR_KIND_READ_ONLY: 635 return Attribute::ReadOnly; 636 case bitc::ATTR_KIND_RETURNED: 637 return Attribute::Returned; 638 case bitc::ATTR_KIND_RETURNS_TWICE: 639 return Attribute::ReturnsTwice; 640 case bitc::ATTR_KIND_S_EXT: 641 return Attribute::SExt; 642 case bitc::ATTR_KIND_STACK_ALIGNMENT: 643 return Attribute::StackAlignment; 644 case bitc::ATTR_KIND_STACK_PROTECT: 645 return Attribute::StackProtect; 646 case bitc::ATTR_KIND_STACK_PROTECT_REQ: 647 return Attribute::StackProtectReq; 648 case bitc::ATTR_KIND_STACK_PROTECT_STRONG: 649 return Attribute::StackProtectStrong; 650 case bitc::ATTR_KIND_STRUCT_RET: 651 return Attribute::StructRet; 652 case bitc::ATTR_KIND_SANITIZE_ADDRESS: 653 return Attribute::SanitizeAddress; 654 case bitc::ATTR_KIND_SANITIZE_THREAD: 655 return Attribute::SanitizeThread; 656 case bitc::ATTR_KIND_SANITIZE_MEMORY: 657 return Attribute::SanitizeMemory; 658 case bitc::ATTR_KIND_UW_TABLE: 659 return Attribute::UWTable; 660 case bitc::ATTR_KIND_Z_EXT: 661 return Attribute::ZExt; 662 } 663 } 664 665 std::error_code BitcodeReader::ParseAttrKind(uint64_t Code, 666 Attribute::AttrKind *Kind) { 667 *Kind = GetAttrFromCode(Code); 668 if (*Kind == Attribute::None) 669 return Error(BitcodeError::InvalidValue); 670 return std::error_code(); 671 } 672 673 std::error_code BitcodeReader::ParseAttributeGroupBlock() { 674 if (Stream.EnterSubBlock(bitc::PARAMATTR_GROUP_BLOCK_ID)) 675 return Error(BitcodeError::InvalidRecord); 676 677 if (!MAttributeGroups.empty()) 678 return Error(BitcodeError::InvalidMultipleBlocks); 679 680 SmallVector<uint64_t, 64> Record; 681 682 // Read all the records. 683 while (1) { 684 BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 685 686 switch (Entry.Kind) { 687 case BitstreamEntry::SubBlock: // Handled for us already. 688 case BitstreamEntry::Error: 689 return Error(BitcodeError::MalformedBlock); 690 case BitstreamEntry::EndBlock: 691 return std::error_code(); 692 case BitstreamEntry::Record: 693 // The interesting case. 694 break; 695 } 696 697 // Read a record. 698 Record.clear(); 699 switch (Stream.readRecord(Entry.ID, Record)) { 700 default: // Default behavior: ignore. 701 break; 702 case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...] 703 if (Record.size() < 3) 704 return Error(BitcodeError::InvalidRecord); 705 706 uint64_t GrpID = Record[0]; 707 uint64_t Idx = Record[1]; // Index of the object this attribute refers to. 708 709 AttrBuilder B; 710 for (unsigned i = 2, e = Record.size(); i != e; ++i) { 711 if (Record[i] == 0) { // Enum attribute 712 Attribute::AttrKind Kind; 713 if (std::error_code EC = ParseAttrKind(Record[++i], &Kind)) 714 return EC; 715 716 B.addAttribute(Kind); 717 } else if (Record[i] == 1) { // Integer attribute 718 Attribute::AttrKind Kind; 719 if (std::error_code EC = ParseAttrKind(Record[++i], &Kind)) 720 return EC; 721 if (Kind == Attribute::Alignment) 722 B.addAlignmentAttr(Record[++i]); 723 else if (Kind == Attribute::StackAlignment) 724 B.addStackAlignmentAttr(Record[++i]); 725 else if (Kind == Attribute::Dereferenceable) 726 B.addDereferenceableAttr(Record[++i]); 727 } else { // String attribute 728 assert((Record[i] == 3 || Record[i] == 4) && 729 "Invalid attribute group entry"); 730 bool HasValue = (Record[i++] == 4); 731 SmallString<64> KindStr; 732 SmallString<64> ValStr; 733 734 while (Record[i] != 0 && i != e) 735 KindStr += Record[i++]; 736 assert(Record[i] == 0 && "Kind string not null terminated"); 737 738 if (HasValue) { 739 // Has a value associated with it. 740 ++i; // Skip the '0' that terminates the "kind" string. 741 while (Record[i] != 0 && i != e) 742 ValStr += Record[i++]; 743 assert(Record[i] == 0 && "Value string not null terminated"); 744 } 745 746 B.addAttribute(KindStr.str(), ValStr.str()); 747 } 748 } 749 750 MAttributeGroups[GrpID] = AttributeSet::get(Context, Idx, B); 751 break; 752 } 753 } 754 } 755 } 756 757 std::error_code BitcodeReader::ParseTypeTable() { 758 if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW)) 759 return Error(BitcodeError::InvalidRecord); 760 761 return ParseTypeTableBody(); 762 } 763 764 std::error_code BitcodeReader::ParseTypeTableBody() { 765 if (!TypeList.empty()) 766 return Error(BitcodeError::InvalidMultipleBlocks); 767 768 SmallVector<uint64_t, 64> Record; 769 unsigned NumRecords = 0; 770 771 SmallString<64> TypeName; 772 773 // Read all the records for this type table. 774 while (1) { 775 BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 776 777 switch (Entry.Kind) { 778 case BitstreamEntry::SubBlock: // Handled for us already. 779 case BitstreamEntry::Error: 780 return Error(BitcodeError::MalformedBlock); 781 case BitstreamEntry::EndBlock: 782 if (NumRecords != TypeList.size()) 783 return Error(BitcodeError::MalformedBlock); 784 return std::error_code(); 785 case BitstreamEntry::Record: 786 // The interesting case. 787 break; 788 } 789 790 // Read a record. 791 Record.clear(); 792 Type *ResultTy = nullptr; 793 switch (Stream.readRecord(Entry.ID, Record)) { 794 default: 795 return Error(BitcodeError::InvalidValue); 796 case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] 797 // TYPE_CODE_NUMENTRY contains a count of the number of types in the 798 // type list. This allows us to reserve space. 799 if (Record.size() < 1) 800 return Error(BitcodeError::InvalidRecord); 801 TypeList.resize(Record[0]); 802 continue; 803 case bitc::TYPE_CODE_VOID: // VOID 804 ResultTy = Type::getVoidTy(Context); 805 break; 806 case bitc::TYPE_CODE_HALF: // HALF 807 ResultTy = Type::getHalfTy(Context); 808 break; 809 case bitc::TYPE_CODE_FLOAT: // FLOAT 810 ResultTy = Type::getFloatTy(Context); 811 break; 812 case bitc::TYPE_CODE_DOUBLE: // DOUBLE 813 ResultTy = Type::getDoubleTy(Context); 814 break; 815 case bitc::TYPE_CODE_X86_FP80: // X86_FP80 816 ResultTy = Type::getX86_FP80Ty(Context); 817 break; 818 case bitc::TYPE_CODE_FP128: // FP128 819 ResultTy = Type::getFP128Ty(Context); 820 break; 821 case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 822 ResultTy = Type::getPPC_FP128Ty(Context); 823 break; 824 case bitc::TYPE_CODE_LABEL: // LABEL 825 ResultTy = Type::getLabelTy(Context); 826 break; 827 case bitc::TYPE_CODE_METADATA: // METADATA 828 ResultTy = Type::getMetadataTy(Context); 829 break; 830 case bitc::TYPE_CODE_X86_MMX: // X86_MMX 831 ResultTy = Type::getX86_MMXTy(Context); 832 break; 833 case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] 834 if (Record.size() < 1) 835 return Error(BitcodeError::InvalidRecord); 836 837 ResultTy = IntegerType::get(Context, Record[0]); 838 break; 839 case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or 840 // [pointee type, address space] 841 if (Record.size() < 1) 842 return Error(BitcodeError::InvalidRecord); 843 unsigned AddressSpace = 0; 844 if (Record.size() == 2) 845 AddressSpace = Record[1]; 846 ResultTy = getTypeByID(Record[0]); 847 if (!ResultTy) 848 return Error(BitcodeError::InvalidType); 849 ResultTy = PointerType::get(ResultTy, AddressSpace); 850 break; 851 } 852 case bitc::TYPE_CODE_FUNCTION_OLD: { 853 // FIXME: attrid is dead, remove it in LLVM 4.0 854 // FUNCTION: [vararg, attrid, retty, paramty x N] 855 if (Record.size() < 3) 856 return Error(BitcodeError::InvalidRecord); 857 SmallVector<Type*, 8> ArgTys; 858 for (unsigned i = 3, e = Record.size(); i != e; ++i) { 859 if (Type *T = getTypeByID(Record[i])) 860 ArgTys.push_back(T); 861 else 862 break; 863 } 864 865 ResultTy = getTypeByID(Record[2]); 866 if (!ResultTy || ArgTys.size() < Record.size()-3) 867 return Error(BitcodeError::InvalidType); 868 869 ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 870 break; 871 } 872 case bitc::TYPE_CODE_FUNCTION: { 873 // FUNCTION: [vararg, retty, paramty x N] 874 if (Record.size() < 2) 875 return Error(BitcodeError::InvalidRecord); 876 SmallVector<Type*, 8> ArgTys; 877 for (unsigned i = 2, e = Record.size(); i != e; ++i) { 878 if (Type *T = getTypeByID(Record[i])) 879 ArgTys.push_back(T); 880 else 881 break; 882 } 883 884 ResultTy = getTypeByID(Record[1]); 885 if (!ResultTy || ArgTys.size() < Record.size()-2) 886 return Error(BitcodeError::InvalidType); 887 888 ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); 889 break; 890 } 891 case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N] 892 if (Record.size() < 1) 893 return Error(BitcodeError::InvalidRecord); 894 SmallVector<Type*, 8> EltTys; 895 for (unsigned i = 1, e = Record.size(); i != e; ++i) { 896 if (Type *T = getTypeByID(Record[i])) 897 EltTys.push_back(T); 898 else 899 break; 900 } 901 if (EltTys.size() != Record.size()-1) 902 return Error(BitcodeError::InvalidType); 903 ResultTy = StructType::get(Context, EltTys, Record[0]); 904 break; 905 } 906 case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N] 907 if (ConvertToString(Record, 0, TypeName)) 908 return Error(BitcodeError::InvalidRecord); 909 continue; 910 911 case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N] 912 if (Record.size() < 1) 913 return Error(BitcodeError::InvalidRecord); 914 915 if (NumRecords >= TypeList.size()) 916 return Error(BitcodeError::InvalidTYPETable); 917 918 // Check to see if this was forward referenced, if so fill in the temp. 919 StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 920 if (Res) { 921 Res->setName(TypeName); 922 TypeList[NumRecords] = nullptr; 923 } else // Otherwise, create a new struct. 924 Res = StructType::create(Context, TypeName); 925 TypeName.clear(); 926 927 SmallVector<Type*, 8> EltTys; 928 for (unsigned i = 1, e = Record.size(); i != e; ++i) { 929 if (Type *T = getTypeByID(Record[i])) 930 EltTys.push_back(T); 931 else 932 break; 933 } 934 if (EltTys.size() != Record.size()-1) 935 return Error(BitcodeError::InvalidRecord); 936 Res->setBody(EltTys, Record[0]); 937 ResultTy = Res; 938 break; 939 } 940 case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: [] 941 if (Record.size() != 1) 942 return Error(BitcodeError::InvalidRecord); 943 944 if (NumRecords >= TypeList.size()) 945 return Error(BitcodeError::InvalidTYPETable); 946 947 // Check to see if this was forward referenced, if so fill in the temp. 948 StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); 949 if (Res) { 950 Res->setName(TypeName); 951 TypeList[NumRecords] = nullptr; 952 } else // Otherwise, create a new struct with no body. 953 Res = StructType::create(Context, TypeName); 954 TypeName.clear(); 955 ResultTy = Res; 956 break; 957 } 958 case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] 959 if (Record.size() < 2) 960 return Error(BitcodeError::InvalidRecord); 961 if ((ResultTy = getTypeByID(Record[1]))) 962 ResultTy = ArrayType::get(ResultTy, Record[0]); 963 else 964 return Error(BitcodeError::InvalidType); 965 break; 966 case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] 967 if (Record.size() < 2) 968 return Error(BitcodeError::InvalidRecord); 969 if ((ResultTy = getTypeByID(Record[1]))) 970 ResultTy = VectorType::get(ResultTy, Record[0]); 971 else 972 return Error(BitcodeError::InvalidType); 973 break; 974 } 975 976 if (NumRecords >= TypeList.size()) 977 return Error(BitcodeError::InvalidTYPETable); 978 assert(ResultTy && "Didn't read a type?"); 979 assert(!TypeList[NumRecords] && "Already read type?"); 980 TypeList[NumRecords++] = ResultTy; 981 } 982 } 983 984 std::error_code BitcodeReader::ParseValueSymbolTable() { 985 if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) 986 return Error(BitcodeError::InvalidRecord); 987 988 SmallVector<uint64_t, 64> Record; 989 990 // Read all the records for this value table. 991 SmallString<128> ValueName; 992 while (1) { 993 BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 994 995 switch (Entry.Kind) { 996 case BitstreamEntry::SubBlock: // Handled for us already. 997 case BitstreamEntry::Error: 998 return Error(BitcodeError::MalformedBlock); 999 case BitstreamEntry::EndBlock: 1000 return std::error_code(); 1001 case BitstreamEntry::Record: 1002 // The interesting case. 1003 break; 1004 } 1005 1006 // Read a record. 1007 Record.clear(); 1008 switch (Stream.readRecord(Entry.ID, Record)) { 1009 default: // Default behavior: unknown type. 1010 break; 1011 case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N] 1012 if (ConvertToString(Record, 1, ValueName)) 1013 return Error(BitcodeError::InvalidRecord); 1014 unsigned ValueID = Record[0]; 1015 if (ValueID >= ValueList.size() || !ValueList[ValueID]) 1016 return Error(BitcodeError::InvalidRecord); 1017 Value *V = ValueList[ValueID]; 1018 1019 V->setName(StringRef(ValueName.data(), ValueName.size())); 1020 ValueName.clear(); 1021 break; 1022 } 1023 case bitc::VST_CODE_BBENTRY: { 1024 if (ConvertToString(Record, 1, ValueName)) 1025 return Error(BitcodeError::InvalidRecord); 1026 BasicBlock *BB = getBasicBlock(Record[0]); 1027 if (!BB) 1028 return Error(BitcodeError::InvalidRecord); 1029 1030 BB->setName(StringRef(ValueName.data(), ValueName.size())); 1031 ValueName.clear(); 1032 break; 1033 } 1034 } 1035 } 1036 } 1037 1038 std::error_code BitcodeReader::ParseMetadata() { 1039 unsigned NextMDValueNo = MDValueList.size(); 1040 1041 if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) 1042 return Error(BitcodeError::InvalidRecord); 1043 1044 SmallVector<uint64_t, 64> Record; 1045 1046 // Read all the records. 1047 while (1) { 1048 BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 1049 1050 switch (Entry.Kind) { 1051 case BitstreamEntry::SubBlock: // Handled for us already. 1052 case BitstreamEntry::Error: 1053 return Error(BitcodeError::MalformedBlock); 1054 case BitstreamEntry::EndBlock: 1055 return std::error_code(); 1056 case BitstreamEntry::Record: 1057 // The interesting case. 1058 break; 1059 } 1060 1061 bool IsFunctionLocal = false; 1062 // Read a record. 1063 Record.clear(); 1064 unsigned Code = Stream.readRecord(Entry.ID, Record); 1065 switch (Code) { 1066 default: // Default behavior: ignore. 1067 break; 1068 case bitc::METADATA_NAME: { 1069 // Read name of the named metadata. 1070 SmallString<8> Name(Record.begin(), Record.end()); 1071 Record.clear(); 1072 Code = Stream.ReadCode(); 1073 1074 // METADATA_NAME is always followed by METADATA_NAMED_NODE. 1075 unsigned NextBitCode = Stream.readRecord(Code, Record); 1076 assert(NextBitCode == bitc::METADATA_NAMED_NODE); (void)NextBitCode; 1077 1078 // Read named metadata elements. 1079 unsigned Size = Record.size(); 1080 NamedMDNode *NMD = TheModule->getOrInsertNamedMetadata(Name); 1081 for (unsigned i = 0; i != Size; ++i) { 1082 MDNode *MD = dyn_cast_or_null<MDNode>(MDValueList.getValueFwdRef(Record[i])); 1083 if (!MD) 1084 return Error(BitcodeError::InvalidRecord); 1085 NMD->addOperand(MD); 1086 } 1087 break; 1088 } 1089 case bitc::METADATA_FN_NODE: 1090 IsFunctionLocal = true; 1091 // fall-through 1092 case bitc::METADATA_NODE: { 1093 if (Record.size() % 2 == 1) 1094 return Error(BitcodeError::InvalidRecord); 1095 1096 unsigned Size = Record.size(); 1097 SmallVector<Value*, 8> Elts; 1098 for (unsigned i = 0; i != Size; i += 2) { 1099 Type *Ty = getTypeByID(Record[i]); 1100 if (!Ty) 1101 return Error(BitcodeError::InvalidRecord); 1102 if (Ty->isMetadataTy()) 1103 Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); 1104 else if (!Ty->isVoidTy()) 1105 Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty)); 1106 else 1107 Elts.push_back(nullptr); 1108 } 1109 Value *V = MDNode::getWhenValsUnresolved(Context, Elts, IsFunctionLocal); 1110 IsFunctionLocal = false; 1111 MDValueList.AssignValue(V, NextMDValueNo++); 1112 break; 1113 } 1114 case bitc::METADATA_STRING: { 1115 std::string String(Record.begin(), Record.end()); 1116 llvm::UpgradeMDStringConstant(String); 1117 Value *V = MDString::get(Context, String); 1118 MDValueList.AssignValue(V, NextMDValueNo++); 1119 break; 1120 } 1121 case bitc::METADATA_KIND: { 1122 if (Record.size() < 2) 1123 return Error(BitcodeError::InvalidRecord); 1124 1125 unsigned Kind = Record[0]; 1126 SmallString<8> Name(Record.begin()+1, Record.end()); 1127 1128 unsigned NewKind = TheModule->getMDKindID(Name.str()); 1129 if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) 1130 return Error(BitcodeError::ConflictingMETADATA_KINDRecords); 1131 break; 1132 } 1133 } 1134 } 1135 } 1136 1137 /// decodeSignRotatedValue - Decode a signed value stored with the sign bit in 1138 /// the LSB for dense VBR encoding. 1139 uint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) { 1140 if ((V & 1) == 0) 1141 return V >> 1; 1142 if (V != 1) 1143 return -(V >> 1); 1144 // There is no such thing as -0 with integers. "-0" really means MININT. 1145 return 1ULL << 63; 1146 } 1147 1148 /// ResolveGlobalAndAliasInits - Resolve all of the initializers for global 1149 /// values and aliases that we can. 1150 std::error_code BitcodeReader::ResolveGlobalAndAliasInits() { 1151 std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist; 1152 std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist; 1153 std::vector<std::pair<Function*, unsigned> > FunctionPrefixWorklist; 1154 1155 GlobalInitWorklist.swap(GlobalInits); 1156 AliasInitWorklist.swap(AliasInits); 1157 FunctionPrefixWorklist.swap(FunctionPrefixes); 1158 1159 while (!GlobalInitWorklist.empty()) { 1160 unsigned ValID = GlobalInitWorklist.back().second; 1161 if (ValID >= ValueList.size()) { 1162 // Not ready to resolve this yet, it requires something later in the file. 1163 GlobalInits.push_back(GlobalInitWorklist.back()); 1164 } else { 1165 if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) 1166 GlobalInitWorklist.back().first->setInitializer(C); 1167 else 1168 return Error(BitcodeError::ExpectedConstant); 1169 } 1170 GlobalInitWorklist.pop_back(); 1171 } 1172 1173 while (!AliasInitWorklist.empty()) { 1174 unsigned ValID = AliasInitWorklist.back().second; 1175 if (ValID >= ValueList.size()) { 1176 AliasInits.push_back(AliasInitWorklist.back()); 1177 } else { 1178 if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) 1179 AliasInitWorklist.back().first->setAliasee(C); 1180 else 1181 return Error(BitcodeError::ExpectedConstant); 1182 } 1183 AliasInitWorklist.pop_back(); 1184 } 1185 1186 while (!FunctionPrefixWorklist.empty()) { 1187 unsigned ValID = FunctionPrefixWorklist.back().second; 1188 if (ValID >= ValueList.size()) { 1189 FunctionPrefixes.push_back(FunctionPrefixWorklist.back()); 1190 } else { 1191 if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID])) 1192 FunctionPrefixWorklist.back().first->setPrefixData(C); 1193 else 1194 return Error(BitcodeError::ExpectedConstant); 1195 } 1196 FunctionPrefixWorklist.pop_back(); 1197 } 1198 1199 return std::error_code(); 1200 } 1201 1202 static APInt ReadWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) { 1203 SmallVector<uint64_t, 8> Words(Vals.size()); 1204 std::transform(Vals.begin(), Vals.end(), Words.begin(), 1205 BitcodeReader::decodeSignRotatedValue); 1206 1207 return APInt(TypeBits, Words); 1208 } 1209 1210 std::error_code BitcodeReader::ParseConstants() { 1211 if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) 1212 return Error(BitcodeError::InvalidRecord); 1213 1214 SmallVector<uint64_t, 64> Record; 1215 1216 // Read all the records for this value table. 1217 Type *CurTy = Type::getInt32Ty(Context); 1218 unsigned NextCstNo = ValueList.size(); 1219 while (1) { 1220 BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 1221 1222 switch (Entry.Kind) { 1223 case BitstreamEntry::SubBlock: // Handled for us already. 1224 case BitstreamEntry::Error: 1225 return Error(BitcodeError::MalformedBlock); 1226 case BitstreamEntry::EndBlock: 1227 if (NextCstNo != ValueList.size()) 1228 return Error(BitcodeError::InvalidConstantReference); 1229 1230 // Once all the constants have been read, go through and resolve forward 1231 // references. 1232 ValueList.ResolveConstantForwardRefs(); 1233 return std::error_code(); 1234 case BitstreamEntry::Record: 1235 // The interesting case. 1236 break; 1237 } 1238 1239 // Read a record. 1240 Record.clear(); 1241 Value *V = nullptr; 1242 unsigned BitCode = Stream.readRecord(Entry.ID, Record); 1243 switch (BitCode) { 1244 default: // Default behavior: unknown constant 1245 case bitc::CST_CODE_UNDEF: // UNDEF 1246 V = UndefValue::get(CurTy); 1247 break; 1248 case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] 1249 if (Record.empty()) 1250 return Error(BitcodeError::InvalidRecord); 1251 if (Record[0] >= TypeList.size() || !TypeList[Record[0]]) 1252 return Error(BitcodeError::InvalidRecord); 1253 CurTy = TypeList[Record[0]]; 1254 continue; // Skip the ValueList manipulation. 1255 case bitc::CST_CODE_NULL: // NULL 1256 V = Constant::getNullValue(CurTy); 1257 break; 1258 case bitc::CST_CODE_INTEGER: // INTEGER: [intval] 1259 if (!CurTy->isIntegerTy() || Record.empty()) 1260 return Error(BitcodeError::InvalidRecord); 1261 V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0])); 1262 break; 1263 case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval] 1264 if (!CurTy->isIntegerTy() || Record.empty()) 1265 return Error(BitcodeError::InvalidRecord); 1266 1267 APInt VInt = ReadWideAPInt(Record, 1268 cast<IntegerType>(CurTy)->getBitWidth()); 1269 V = ConstantInt::get(Context, VInt); 1270 1271 break; 1272 } 1273 case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] 1274 if (Record.empty()) 1275 return Error(BitcodeError::InvalidRecord); 1276 if (CurTy->isHalfTy()) 1277 V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf, 1278 APInt(16, (uint16_t)Record[0]))); 1279 else if (CurTy->isFloatTy()) 1280 V = ConstantFP::get(Context, APFloat(APFloat::IEEEsingle, 1281 APInt(32, (uint32_t)Record[0]))); 1282 else if (CurTy->isDoubleTy()) 1283 V = ConstantFP::get(Context, APFloat(APFloat::IEEEdouble, 1284 APInt(64, Record[0]))); 1285 else if (CurTy->isX86_FP80Ty()) { 1286 // Bits are not stored the same way as a normal i80 APInt, compensate. 1287 uint64_t Rearrange[2]; 1288 Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16); 1289 Rearrange[1] = Record[0] >> 48; 1290 V = ConstantFP::get(Context, APFloat(APFloat::x87DoubleExtended, 1291 APInt(80, Rearrange))); 1292 } else if (CurTy->isFP128Ty()) 1293 V = ConstantFP::get(Context, APFloat(APFloat::IEEEquad, 1294 APInt(128, Record))); 1295 else if (CurTy->isPPC_FP128Ty()) 1296 V = ConstantFP::get(Context, APFloat(APFloat::PPCDoubleDouble, 1297 APInt(128, Record))); 1298 else 1299 V = UndefValue::get(CurTy); 1300 break; 1301 } 1302 1303 case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] 1304 if (Record.empty()) 1305 return Error(BitcodeError::InvalidRecord); 1306 1307 unsigned Size = Record.size(); 1308 SmallVector<Constant*, 16> Elts; 1309 1310 if (StructType *STy = dyn_cast<StructType>(CurTy)) { 1311 for (unsigned i = 0; i != Size; ++i) 1312 Elts.push_back(ValueList.getConstantFwdRef(Record[i], 1313 STy->getElementType(i))); 1314 V = ConstantStruct::get(STy, Elts); 1315 } else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) { 1316 Type *EltTy = ATy->getElementType(); 1317 for (unsigned i = 0; i != Size; ++i) 1318 Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 1319 V = ConstantArray::get(ATy, Elts); 1320 } else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) { 1321 Type *EltTy = VTy->getElementType(); 1322 for (unsigned i = 0; i != Size; ++i) 1323 Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); 1324 V = ConstantVector::get(Elts); 1325 } else { 1326 V = UndefValue::get(CurTy); 1327 } 1328 break; 1329 } 1330 case bitc::CST_CODE_STRING: // STRING: [values] 1331 case bitc::CST_CODE_CSTRING: { // CSTRING: [values] 1332 if (Record.empty()) 1333 return Error(BitcodeError::InvalidRecord); 1334 1335 SmallString<16> Elts(Record.begin(), Record.end()); 1336 V = ConstantDataArray::getString(Context, Elts, 1337 BitCode == bitc::CST_CODE_CSTRING); 1338 break; 1339 } 1340 case bitc::CST_CODE_DATA: {// DATA: [n x value] 1341 if (Record.empty()) 1342 return Error(BitcodeError::InvalidRecord); 1343 1344 Type *EltTy = cast<SequentialType>(CurTy)->getElementType(); 1345 unsigned Size = Record.size(); 1346 1347 if (EltTy->isIntegerTy(8)) { 1348 SmallVector<uint8_t, 16> Elts(Record.begin(), Record.end()); 1349 if (isa<VectorType>(CurTy)) 1350 V = ConstantDataVector::get(Context, Elts); 1351 else 1352 V = ConstantDataArray::get(Context, Elts); 1353 } else if (EltTy->isIntegerTy(16)) { 1354 SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end()); 1355 if (isa<VectorType>(CurTy)) 1356 V = ConstantDataVector::get(Context, Elts); 1357 else 1358 V = ConstantDataArray::get(Context, Elts); 1359 } else if (EltTy->isIntegerTy(32)) { 1360 SmallVector<uint32_t, 16> Elts(Record.begin(), Record.end()); 1361 if (isa<VectorType>(CurTy)) 1362 V = ConstantDataVector::get(Context, Elts); 1363 else 1364 V = ConstantDataArray::get(Context, Elts); 1365 } else if (EltTy->isIntegerTy(64)) { 1366 SmallVector<uint64_t, 16> Elts(Record.begin(), Record.end()); 1367 if (isa<VectorType>(CurTy)) 1368 V = ConstantDataVector::get(Context, Elts); 1369 else 1370 V = ConstantDataArray::get(Context, Elts); 1371 } else if (EltTy->isFloatTy()) { 1372 SmallVector<float, 16> Elts(Size); 1373 std::transform(Record.begin(), Record.end(), Elts.begin(), BitsToFloat); 1374 if (isa<VectorType>(CurTy)) 1375 V = ConstantDataVector::get(Context, Elts); 1376 else 1377 V = ConstantDataArray::get(Context, Elts); 1378 } else if (EltTy->isDoubleTy()) { 1379 SmallVector<double, 16> Elts(Size); 1380 std::transform(Record.begin(), Record.end(), Elts.begin(), 1381 BitsToDouble); 1382 if (isa<VectorType>(CurTy)) 1383 V = ConstantDataVector::get(Context, Elts); 1384 else 1385 V = ConstantDataArray::get(Context, Elts); 1386 } else { 1387 return Error(BitcodeError::InvalidTypeForValue); 1388 } 1389 break; 1390 } 1391 1392 case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] 1393 if (Record.size() < 3) 1394 return Error(BitcodeError::InvalidRecord); 1395 int Opc = GetDecodedBinaryOpcode(Record[0], CurTy); 1396 if (Opc < 0) { 1397 V = UndefValue::get(CurTy); // Unknown binop. 1398 } else { 1399 Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy); 1400 Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy); 1401 unsigned Flags = 0; 1402 if (Record.size() >= 4) { 1403 if (Opc == Instruction::Add || 1404 Opc == Instruction::Sub || 1405 Opc == Instruction::Mul || 1406 Opc == Instruction::Shl) { 1407 if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 1408 Flags |= OverflowingBinaryOperator::NoSignedWrap; 1409 if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 1410 Flags |= OverflowingBinaryOperator::NoUnsignedWrap; 1411 } else if (Opc == Instruction::SDiv || 1412 Opc == Instruction::UDiv || 1413 Opc == Instruction::LShr || 1414 Opc == Instruction::AShr) { 1415 if (Record[3] & (1 << bitc::PEO_EXACT)) 1416 Flags |= SDivOperator::IsExact; 1417 } 1418 } 1419 V = ConstantExpr::get(Opc, LHS, RHS, Flags); 1420 } 1421 break; 1422 } 1423 case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] 1424 if (Record.size() < 3) 1425 return Error(BitcodeError::InvalidRecord); 1426 int Opc = GetDecodedCastOpcode(Record[0]); 1427 if (Opc < 0) { 1428 V = UndefValue::get(CurTy); // Unknown cast. 1429 } else { 1430 Type *OpTy = getTypeByID(Record[1]); 1431 if (!OpTy) 1432 return Error(BitcodeError::InvalidRecord); 1433 Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); 1434 V = UpgradeBitCastExpr(Opc, Op, CurTy); 1435 if (!V) V = ConstantExpr::getCast(Opc, Op, CurTy); 1436 } 1437 break; 1438 } 1439 case bitc::CST_CODE_CE_INBOUNDS_GEP: 1440 case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands] 1441 if (Record.size() & 1) 1442 return Error(BitcodeError::InvalidRecord); 1443 SmallVector<Constant*, 16> Elts; 1444 for (unsigned i = 0, e = Record.size(); i != e; i += 2) { 1445 Type *ElTy = getTypeByID(Record[i]); 1446 if (!ElTy) 1447 return Error(BitcodeError::InvalidRecord); 1448 Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); 1449 } 1450 ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end()); 1451 V = ConstantExpr::getGetElementPtr(Elts[0], Indices, 1452 BitCode == 1453 bitc::CST_CODE_CE_INBOUNDS_GEP); 1454 break; 1455 } 1456 case bitc::CST_CODE_CE_SELECT: { // CE_SELECT: [opval#, opval#, opval#] 1457 if (Record.size() < 3) 1458 return Error(BitcodeError::InvalidRecord); 1459 1460 Type *SelectorTy = Type::getInt1Ty(Context); 1461 1462 // If CurTy is a vector of length n, then Record[0] must be a <n x i1> 1463 // vector. Otherwise, it must be a single bit. 1464 if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) 1465 SelectorTy = VectorType::get(Type::getInt1Ty(Context), 1466 VTy->getNumElements()); 1467 1468 V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0], 1469 SelectorTy), 1470 ValueList.getConstantFwdRef(Record[1],CurTy), 1471 ValueList.getConstantFwdRef(Record[2],CurTy)); 1472 break; 1473 } 1474 case bitc::CST_CODE_CE_EXTRACTELT 1475 : { // CE_EXTRACTELT: [opty, opval, opty, opval] 1476 if (Record.size() < 3) 1477 return Error(BitcodeError::InvalidRecord); 1478 VectorType *OpTy = 1479 dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1480 if (!OpTy) 1481 return Error(BitcodeError::InvalidRecord); 1482 Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1483 Constant *Op1 = nullptr; 1484 if (Record.size() == 4) { 1485 Type *IdxTy = getTypeByID(Record[2]); 1486 if (!IdxTy) 1487 return Error(BitcodeError::InvalidRecord); 1488 Op1 = ValueList.getConstantFwdRef(Record[3], IdxTy); 1489 } else // TODO: Remove with llvm 4.0 1490 Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 1491 if (!Op1) 1492 return Error(BitcodeError::InvalidRecord); 1493 V = ConstantExpr::getExtractElement(Op0, Op1); 1494 break; 1495 } 1496 case bitc::CST_CODE_CE_INSERTELT 1497 : { // CE_INSERTELT: [opval, opval, opty, opval] 1498 VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1499 if (Record.size() < 3 || !OpTy) 1500 return Error(BitcodeError::InvalidRecord); 1501 Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 1502 Constant *Op1 = ValueList.getConstantFwdRef(Record[1], 1503 OpTy->getElementType()); 1504 Constant *Op2 = nullptr; 1505 if (Record.size() == 4) { 1506 Type *IdxTy = getTypeByID(Record[2]); 1507 if (!IdxTy) 1508 return Error(BitcodeError::InvalidRecord); 1509 Op2 = ValueList.getConstantFwdRef(Record[3], IdxTy); 1510 } else // TODO: Remove with llvm 4.0 1511 Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context)); 1512 if (!Op2) 1513 return Error(BitcodeError::InvalidRecord); 1514 V = ConstantExpr::getInsertElement(Op0, Op1, Op2); 1515 break; 1516 } 1517 case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] 1518 VectorType *OpTy = dyn_cast<VectorType>(CurTy); 1519 if (Record.size() < 3 || !OpTy) 1520 return Error(BitcodeError::InvalidRecord); 1521 Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); 1522 Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); 1523 Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 1524 OpTy->getNumElements()); 1525 Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy); 1526 V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 1527 break; 1528 } 1529 case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval] 1530 VectorType *RTy = dyn_cast<VectorType>(CurTy); 1531 VectorType *OpTy = 1532 dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); 1533 if (Record.size() < 4 || !RTy || !OpTy) 1534 return Error(BitcodeError::InvalidRecord); 1535 Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1536 Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 1537 Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), 1538 RTy->getNumElements()); 1539 Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy); 1540 V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); 1541 break; 1542 } 1543 case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] 1544 if (Record.size() < 4) 1545 return Error(BitcodeError::InvalidRecord); 1546 Type *OpTy = getTypeByID(Record[0]); 1547 if (!OpTy) 1548 return Error(BitcodeError::InvalidRecord); 1549 Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); 1550 Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); 1551 1552 if (OpTy->isFPOrFPVectorTy()) 1553 V = ConstantExpr::getFCmp(Record[3], Op0, Op1); 1554 else 1555 V = ConstantExpr::getICmp(Record[3], Op0, Op1); 1556 break; 1557 } 1558 // This maintains backward compatibility, pre-asm dialect keywords. 1559 // FIXME: Remove with the 4.0 release. 1560 case bitc::CST_CODE_INLINEASM_OLD: { 1561 if (Record.size() < 2) 1562 return Error(BitcodeError::InvalidRecord); 1563 std::string AsmStr, ConstrStr; 1564 bool HasSideEffects = Record[0] & 1; 1565 bool IsAlignStack = Record[0] >> 1; 1566 unsigned AsmStrSize = Record[1]; 1567 if (2+AsmStrSize >= Record.size()) 1568 return Error(BitcodeError::InvalidRecord); 1569 unsigned ConstStrSize = Record[2+AsmStrSize]; 1570 if (3+AsmStrSize+ConstStrSize > Record.size()) 1571 return Error(BitcodeError::InvalidRecord); 1572 1573 for (unsigned i = 0; i != AsmStrSize; ++i) 1574 AsmStr += (char)Record[2+i]; 1575 for (unsigned i = 0; i != ConstStrSize; ++i) 1576 ConstrStr += (char)Record[3+AsmStrSize+i]; 1577 PointerType *PTy = cast<PointerType>(CurTy); 1578 V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), 1579 AsmStr, ConstrStr, HasSideEffects, IsAlignStack); 1580 break; 1581 } 1582 // This version adds support for the asm dialect keywords (e.g., 1583 // inteldialect). 1584 case bitc::CST_CODE_INLINEASM: { 1585 if (Record.size() < 2) 1586 return Error(BitcodeError::InvalidRecord); 1587 std::string AsmStr, ConstrStr; 1588 bool HasSideEffects = Record[0] & 1; 1589 bool IsAlignStack = (Record[0] >> 1) & 1; 1590 unsigned AsmDialect = Record[0] >> 2; 1591 unsigned AsmStrSize = Record[1]; 1592 if (2+AsmStrSize >= Record.size()) 1593 return Error(BitcodeError::InvalidRecord); 1594 unsigned ConstStrSize = Record[2+AsmStrSize]; 1595 if (3+AsmStrSize+ConstStrSize > Record.size()) 1596 return Error(BitcodeError::InvalidRecord); 1597 1598 for (unsigned i = 0; i != AsmStrSize; ++i) 1599 AsmStr += (char)Record[2+i]; 1600 for (unsigned i = 0; i != ConstStrSize; ++i) 1601 ConstrStr += (char)Record[3+AsmStrSize+i]; 1602 PointerType *PTy = cast<PointerType>(CurTy); 1603 V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), 1604 AsmStr, ConstrStr, HasSideEffects, IsAlignStack, 1605 InlineAsm::AsmDialect(AsmDialect)); 1606 break; 1607 } 1608 case bitc::CST_CODE_BLOCKADDRESS:{ 1609 if (Record.size() < 3) 1610 return Error(BitcodeError::InvalidRecord); 1611 Type *FnTy = getTypeByID(Record[0]); 1612 if (!FnTy) 1613 return Error(BitcodeError::InvalidRecord); 1614 Function *Fn = 1615 dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy)); 1616 if (!Fn) 1617 return Error(BitcodeError::InvalidRecord); 1618 1619 // Don't let Fn get dematerialized. 1620 BlockAddressesTaken.insert(Fn); 1621 1622 // If the function is already parsed we can insert the block address right 1623 // away. 1624 BasicBlock *BB; 1625 unsigned BBID = Record[2]; 1626 if (!BBID) 1627 // Invalid reference to entry block. 1628 return Error(BitcodeError::InvalidID); 1629 if (!Fn->empty()) { 1630 Function::iterator BBI = Fn->begin(), BBE = Fn->end(); 1631 for (size_t I = 0, E = BBID; I != E; ++I) { 1632 if (BBI == BBE) 1633 return Error(BitcodeError::InvalidID); 1634 ++BBI; 1635 } 1636 BB = BBI; 1637 } else { 1638 // Otherwise insert a placeholder and remember it so it can be inserted 1639 // when the function is parsed. 1640 auto &FwdBBs = BasicBlockFwdRefs[Fn]; 1641 if (FwdBBs.empty()) 1642 BasicBlockFwdRefQueue.push_back(Fn); 1643 if (FwdBBs.size() < BBID + 1) 1644 FwdBBs.resize(BBID + 1); 1645 if (!FwdBBs[BBID]) 1646 FwdBBs[BBID] = BasicBlock::Create(Context); 1647 BB = FwdBBs[BBID]; 1648 } 1649 V = BlockAddress::get(Fn, BB); 1650 break; 1651 } 1652 } 1653 1654 ValueList.AssignValue(V, NextCstNo); 1655 ++NextCstNo; 1656 } 1657 } 1658 1659 std::error_code BitcodeReader::ParseUseLists() { 1660 if (Stream.EnterSubBlock(bitc::USELIST_BLOCK_ID)) 1661 return Error(BitcodeError::InvalidRecord); 1662 1663 // Read all the records. 1664 SmallVector<uint64_t, 64> Record; 1665 while (1) { 1666 BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 1667 1668 switch (Entry.Kind) { 1669 case BitstreamEntry::SubBlock: // Handled for us already. 1670 case BitstreamEntry::Error: 1671 return Error(BitcodeError::MalformedBlock); 1672 case BitstreamEntry::EndBlock: 1673 return std::error_code(); 1674 case BitstreamEntry::Record: 1675 // The interesting case. 1676 break; 1677 } 1678 1679 // Read a use list record. 1680 Record.clear(); 1681 bool IsBB = false; 1682 switch (Stream.readRecord(Entry.ID, Record)) { 1683 default: // Default behavior: unknown type. 1684 break; 1685 case bitc::USELIST_CODE_BB: 1686 IsBB = true; 1687 // fallthrough 1688 case bitc::USELIST_CODE_DEFAULT: { 1689 unsigned RecordLength = Record.size(); 1690 if (RecordLength < 3) 1691 // Records should have at least an ID and two indexes. 1692 return Error(BitcodeError::InvalidRecord); 1693 unsigned ID = Record.back(); 1694 Record.pop_back(); 1695 1696 Value *V; 1697 if (IsBB) { 1698 assert(ID < FunctionBBs.size() && "Basic block not found"); 1699 V = FunctionBBs[ID]; 1700 } else 1701 V = ValueList[ID]; 1702 unsigned NumUses = 0; 1703 SmallDenseMap<const Use *, unsigned, 16> Order; 1704 for (const Use &U : V->uses()) { 1705 if (++NumUses > Record.size()) 1706 break; 1707 Order[&U] = Record[NumUses - 1]; 1708 } 1709 if (Order.size() != Record.size() || NumUses > Record.size()) 1710 // Mismatches can happen if the functions are being materialized lazily 1711 // (out-of-order), or a value has been upgraded. 1712 break; 1713 1714 V->sortUseList([&](const Use &L, const Use &R) { 1715 return Order.lookup(&L) < Order.lookup(&R); 1716 }); 1717 break; 1718 } 1719 } 1720 } 1721 } 1722 1723 /// RememberAndSkipFunctionBody - When we see the block for a function body, 1724 /// remember where it is and then skip it. This lets us lazily deserialize the 1725 /// functions. 1726 std::error_code BitcodeReader::RememberAndSkipFunctionBody() { 1727 // Get the function we are talking about. 1728 if (FunctionsWithBodies.empty()) 1729 return Error(BitcodeError::InsufficientFunctionProtos); 1730 1731 Function *Fn = FunctionsWithBodies.back(); 1732 FunctionsWithBodies.pop_back(); 1733 1734 // Save the current stream state. 1735 uint64_t CurBit = Stream.GetCurrentBitNo(); 1736 DeferredFunctionInfo[Fn] = CurBit; 1737 1738 // Skip over the function block for now. 1739 if (Stream.SkipBlock()) 1740 return Error(BitcodeError::InvalidRecord); 1741 return std::error_code(); 1742 } 1743 1744 std::error_code BitcodeReader::GlobalCleanup() { 1745 // Patch the initializers for globals and aliases up. 1746 ResolveGlobalAndAliasInits(); 1747 if (!GlobalInits.empty() || !AliasInits.empty()) 1748 return Error(BitcodeError::MalformedGlobalInitializerSet); 1749 1750 // Look for intrinsic functions which need to be upgraded at some point 1751 for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); 1752 FI != FE; ++FI) { 1753 Function *NewFn; 1754 if (UpgradeIntrinsicFunction(FI, NewFn)) 1755 UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn)); 1756 } 1757 1758 // Look for global variables which need to be renamed. 1759 for (Module::global_iterator 1760 GI = TheModule->global_begin(), GE = TheModule->global_end(); 1761 GI != GE;) { 1762 GlobalVariable *GV = GI++; 1763 UpgradeGlobalVariable(GV); 1764 } 1765 1766 // Force deallocation of memory for these vectors to favor the client that 1767 // want lazy deserialization. 1768 std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); 1769 std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); 1770 return std::error_code(); 1771 } 1772 1773 std::error_code BitcodeReader::ParseModule(bool Resume) { 1774 if (Resume) 1775 Stream.JumpToBit(NextUnreadBit); 1776 else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 1777 return Error(BitcodeError::InvalidRecord); 1778 1779 SmallVector<uint64_t, 64> Record; 1780 std::vector<std::string> SectionTable; 1781 std::vector<std::string> GCTable; 1782 1783 // Read all the records for this module. 1784 while (1) { 1785 BitstreamEntry Entry = Stream.advance(); 1786 1787 switch (Entry.Kind) { 1788 case BitstreamEntry::Error: 1789 return Error(BitcodeError::MalformedBlock); 1790 case BitstreamEntry::EndBlock: 1791 return GlobalCleanup(); 1792 1793 case BitstreamEntry::SubBlock: 1794 switch (Entry.ID) { 1795 default: // Skip unknown content. 1796 if (Stream.SkipBlock()) 1797 return Error(BitcodeError::InvalidRecord); 1798 break; 1799 case bitc::BLOCKINFO_BLOCK_ID: 1800 if (Stream.ReadBlockInfoBlock()) 1801 return Error(BitcodeError::MalformedBlock); 1802 break; 1803 case bitc::PARAMATTR_BLOCK_ID: 1804 if (std::error_code EC = ParseAttributeBlock()) 1805 return EC; 1806 break; 1807 case bitc::PARAMATTR_GROUP_BLOCK_ID: 1808 if (std::error_code EC = ParseAttributeGroupBlock()) 1809 return EC; 1810 break; 1811 case bitc::TYPE_BLOCK_ID_NEW: 1812 if (std::error_code EC = ParseTypeTable()) 1813 return EC; 1814 break; 1815 case bitc::VALUE_SYMTAB_BLOCK_ID: 1816 if (std::error_code EC = ParseValueSymbolTable()) 1817 return EC; 1818 SeenValueSymbolTable = true; 1819 break; 1820 case bitc::CONSTANTS_BLOCK_ID: 1821 if (std::error_code EC = ParseConstants()) 1822 return EC; 1823 if (std::error_code EC = ResolveGlobalAndAliasInits()) 1824 return EC; 1825 break; 1826 case bitc::METADATA_BLOCK_ID: 1827 if (std::error_code EC = ParseMetadata()) 1828 return EC; 1829 break; 1830 case bitc::FUNCTION_BLOCK_ID: 1831 // If this is the first function body we've seen, reverse the 1832 // FunctionsWithBodies list. 1833 if (!SeenFirstFunctionBody) { 1834 std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end()); 1835 if (std::error_code EC = GlobalCleanup()) 1836 return EC; 1837 SeenFirstFunctionBody = true; 1838 } 1839 1840 if (std::error_code EC = RememberAndSkipFunctionBody()) 1841 return EC; 1842 // For streaming bitcode, suspend parsing when we reach the function 1843 // bodies. Subsequent materialization calls will resume it when 1844 // necessary. For streaming, the function bodies must be at the end of 1845 // the bitcode. If the bitcode file is old, the symbol table will be 1846 // at the end instead and will not have been seen yet. In this case, 1847 // just finish the parse now. 1848 if (LazyStreamer && SeenValueSymbolTable) { 1849 NextUnreadBit = Stream.GetCurrentBitNo(); 1850 return std::error_code(); 1851 } 1852 break; 1853 case bitc::USELIST_BLOCK_ID: 1854 if (std::error_code EC = ParseUseLists()) 1855 return EC; 1856 break; 1857 } 1858 continue; 1859 1860 case BitstreamEntry::Record: 1861 // The interesting case. 1862 break; 1863 } 1864 1865 1866 // Read a record. 1867 switch (Stream.readRecord(Entry.ID, Record)) { 1868 default: break; // Default behavior, ignore unknown content. 1869 case bitc::MODULE_CODE_VERSION: { // VERSION: [version#] 1870 if (Record.size() < 1) 1871 return Error(BitcodeError::InvalidRecord); 1872 // Only version #0 and #1 are supported so far. 1873 unsigned module_version = Record[0]; 1874 switch (module_version) { 1875 default: 1876 return Error(BitcodeError::InvalidValue); 1877 case 0: 1878 UseRelativeIDs = false; 1879 break; 1880 case 1: 1881 UseRelativeIDs = true; 1882 break; 1883 } 1884 break; 1885 } 1886 case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 1887 std::string S; 1888 if (ConvertToString(Record, 0, S)) 1889 return Error(BitcodeError::InvalidRecord); 1890 TheModule->setTargetTriple(S); 1891 break; 1892 } 1893 case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] 1894 std::string S; 1895 if (ConvertToString(Record, 0, S)) 1896 return Error(BitcodeError::InvalidRecord); 1897 TheModule->setDataLayout(S); 1898 break; 1899 } 1900 case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] 1901 std::string S; 1902 if (ConvertToString(Record, 0, S)) 1903 return Error(BitcodeError::InvalidRecord); 1904 TheModule->setModuleInlineAsm(S); 1905 break; 1906 } 1907 case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N] 1908 // FIXME: Remove in 4.0. 1909 std::string S; 1910 if (ConvertToString(Record, 0, S)) 1911 return Error(BitcodeError::InvalidRecord); 1912 // Ignore value. 1913 break; 1914 } 1915 case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] 1916 std::string S; 1917 if (ConvertToString(Record, 0, S)) 1918 return Error(BitcodeError::InvalidRecord); 1919 SectionTable.push_back(S); 1920 break; 1921 } 1922 case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N] 1923 std::string S; 1924 if (ConvertToString(Record, 0, S)) 1925 return Error(BitcodeError::InvalidRecord); 1926 GCTable.push_back(S); 1927 break; 1928 } 1929 case bitc::MODULE_CODE_COMDAT: { // COMDAT: [selection_kind, name] 1930 if (Record.size() < 2) 1931 return Error(BitcodeError::InvalidRecord); 1932 Comdat::SelectionKind SK = getDecodedComdatSelectionKind(Record[0]); 1933 unsigned ComdatNameSize = Record[1]; 1934 std::string ComdatName; 1935 ComdatName.reserve(ComdatNameSize); 1936 for (unsigned i = 0; i != ComdatNameSize; ++i) 1937 ComdatName += (char)Record[2 + i]; 1938 Comdat *C = TheModule->getOrInsertComdat(ComdatName); 1939 C->setSelectionKind(SK); 1940 ComdatList.push_back(C); 1941 break; 1942 } 1943 // GLOBALVAR: [pointer type, isconst, initid, 1944 // linkage, alignment, section, visibility, threadlocal, 1945 // unnamed_addr, dllstorageclass] 1946 case bitc::MODULE_CODE_GLOBALVAR: { 1947 if (Record.size() < 6) 1948 return Error(BitcodeError::InvalidRecord); 1949 Type *Ty = getTypeByID(Record[0]); 1950 if (!Ty) 1951 return Error(BitcodeError::InvalidRecord); 1952 if (!Ty->isPointerTy()) 1953 return Error(BitcodeError::InvalidTypeForValue); 1954 unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); 1955 Ty = cast<PointerType>(Ty)->getElementType(); 1956 1957 bool isConstant = Record[1]; 1958 GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]); 1959 unsigned Alignment = (1 << Record[4]) >> 1; 1960 std::string Section; 1961 if (Record[5]) { 1962 if (Record[5]-1 >= SectionTable.size()) 1963 return Error(BitcodeError::InvalidID); 1964 Section = SectionTable[Record[5]-1]; 1965 } 1966 GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; 1967 // Local linkage must have default visibility. 1968 if (Record.size() > 6 && !GlobalValue::isLocalLinkage(Linkage)) 1969 // FIXME: Change to an error if non-default in 4.0. 1970 Visibility = GetDecodedVisibility(Record[6]); 1971 1972 GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal; 1973 if (Record.size() > 7) 1974 TLM = GetDecodedThreadLocalMode(Record[7]); 1975 1976 bool UnnamedAddr = false; 1977 if (Record.size() > 8) 1978 UnnamedAddr = Record[8]; 1979 1980 bool ExternallyInitialized = false; 1981 if (Record.size() > 9) 1982 ExternallyInitialized = Record[9]; 1983 1984 GlobalVariable *NewGV = 1985 new GlobalVariable(*TheModule, Ty, isConstant, Linkage, nullptr, "", nullptr, 1986 TLM, AddressSpace, ExternallyInitialized); 1987 NewGV->setAlignment(Alignment); 1988 if (!Section.empty()) 1989 NewGV->setSection(Section); 1990 NewGV->setVisibility(Visibility); 1991 NewGV->setUnnamedAddr(UnnamedAddr); 1992 1993 if (Record.size() > 10) 1994 NewGV->setDLLStorageClass(GetDecodedDLLStorageClass(Record[10])); 1995 else 1996 UpgradeDLLImportExportLinkage(NewGV, Record[3]); 1997 1998 ValueList.push_back(NewGV); 1999 2000 // Remember which value to use for the global initializer. 2001 if (unsigned InitID = Record[2]) 2002 GlobalInits.push_back(std::make_pair(NewGV, InitID-1)); 2003 2004 if (Record.size() > 11) 2005 if (unsigned ComdatID = Record[11]) { 2006 assert(ComdatID <= ComdatList.size()); 2007 NewGV->setComdat(ComdatList[ComdatID - 1]); 2008 } 2009 break; 2010 } 2011 // FUNCTION: [type, callingconv, isproto, linkage, paramattr, 2012 // alignment, section, visibility, gc, unnamed_addr, 2013 // dllstorageclass] 2014 case bitc::MODULE_CODE_FUNCTION: { 2015 if (Record.size() < 8) 2016 return Error(BitcodeError::InvalidRecord); 2017 Type *Ty = getTypeByID(Record[0]); 2018 if (!Ty) 2019 return Error(BitcodeError::InvalidRecord); 2020 if (!Ty->isPointerTy()) 2021 return Error(BitcodeError::InvalidTypeForValue); 2022 FunctionType *FTy = 2023 dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType()); 2024 if (!FTy) 2025 return Error(BitcodeError::InvalidTypeForValue); 2026 2027 Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, 2028 "", TheModule); 2029 2030 Func->setCallingConv(static_cast<CallingConv::ID>(Record[1])); 2031 bool isProto = Record[2]; 2032 Func->setLinkage(GetDecodedLinkage(Record[3])); 2033 Func->setAttributes(getAttributes(Record[4])); 2034 2035 Func->setAlignment((1 << Record[5]) >> 1); 2036 if (Record[6]) { 2037 if (Record[6]-1 >= SectionTable.size()) 2038 return Error(BitcodeError::InvalidID); 2039 Func->setSection(SectionTable[Record[6]-1]); 2040 } 2041 // Local linkage must have default visibility. 2042 if (!Func->hasLocalLinkage()) 2043 // FIXME: Change to an error if non-default in 4.0. 2044 Func->setVisibility(GetDecodedVisibility(Record[7])); 2045 if (Record.size() > 8 && Record[8]) { 2046 if (Record[8]-1 > GCTable.size()) 2047 return Error(BitcodeError::InvalidID); 2048 Func->setGC(GCTable[Record[8]-1].c_str()); 2049 } 2050 bool UnnamedAddr = false; 2051 if (Record.size() > 9) 2052 UnnamedAddr = Record[9]; 2053 Func->setUnnamedAddr(UnnamedAddr); 2054 if (Record.size() > 10 && Record[10] != 0) 2055 FunctionPrefixes.push_back(std::make_pair(Func, Record[10]-1)); 2056 2057 if (Record.size() > 11) 2058 Func->setDLLStorageClass(GetDecodedDLLStorageClass(Record[11])); 2059 else 2060 UpgradeDLLImportExportLinkage(Func, Record[3]); 2061 2062 if (Record.size() > 12) 2063 if (unsigned ComdatID = Record[12]) { 2064 assert(ComdatID <= ComdatList.size()); 2065 Func->setComdat(ComdatList[ComdatID - 1]); 2066 } 2067 2068 ValueList.push_back(Func); 2069 2070 // If this is a function with a body, remember the prototype we are 2071 // creating now, so that we can match up the body with them later. 2072 if (!isProto) { 2073 FunctionsWithBodies.push_back(Func); 2074 if (LazyStreamer) DeferredFunctionInfo[Func] = 0; 2075 } 2076 break; 2077 } 2078 // ALIAS: [alias type, aliasee val#, linkage] 2079 // ALIAS: [alias type, aliasee val#, linkage, visibility, dllstorageclass] 2080 case bitc::MODULE_CODE_ALIAS: { 2081 if (Record.size() < 3) 2082 return Error(BitcodeError::InvalidRecord); 2083 Type *Ty = getTypeByID(Record[0]); 2084 if (!Ty) 2085 return Error(BitcodeError::InvalidRecord); 2086 auto *PTy = dyn_cast<PointerType>(Ty); 2087 if (!PTy) 2088 return Error(BitcodeError::InvalidTypeForValue); 2089 2090 auto *NewGA = 2091 GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(), 2092 GetDecodedLinkage(Record[2]), "", TheModule); 2093 // Old bitcode files didn't have visibility field. 2094 // Local linkage must have default visibility. 2095 if (Record.size() > 3 && !NewGA->hasLocalLinkage()) 2096 // FIXME: Change to an error if non-default in 4.0. 2097 NewGA->setVisibility(GetDecodedVisibility(Record[3])); 2098 if (Record.size() > 4) 2099 NewGA->setDLLStorageClass(GetDecodedDLLStorageClass(Record[4])); 2100 else 2101 UpgradeDLLImportExportLinkage(NewGA, Record[2]); 2102 if (Record.size() > 5) 2103 NewGA->setThreadLocalMode(GetDecodedThreadLocalMode(Record[5])); 2104 if (Record.size() > 6) 2105 NewGA->setUnnamedAddr(Record[6]); 2106 ValueList.push_back(NewGA); 2107 AliasInits.push_back(std::make_pair(NewGA, Record[1])); 2108 break; 2109 } 2110 /// MODULE_CODE_PURGEVALS: [numvals] 2111 case bitc::MODULE_CODE_PURGEVALS: 2112 // Trim down the value list to the specified size. 2113 if (Record.size() < 1 || Record[0] > ValueList.size()) 2114 return Error(BitcodeError::InvalidRecord); 2115 ValueList.shrinkTo(Record[0]); 2116 break; 2117 } 2118 Record.clear(); 2119 } 2120 } 2121 2122 std::error_code BitcodeReader::ParseBitcodeInto(Module *M) { 2123 TheModule = nullptr; 2124 2125 if (std::error_code EC = InitStream()) 2126 return EC; 2127 2128 // Sniff for the signature. 2129 if (Stream.Read(8) != 'B' || 2130 Stream.Read(8) != 'C' || 2131 Stream.Read(4) != 0x0 || 2132 Stream.Read(4) != 0xC || 2133 Stream.Read(4) != 0xE || 2134 Stream.Read(4) != 0xD) 2135 return Error(BitcodeError::InvalidBitcodeSignature); 2136 2137 // We expect a number of well-defined blocks, though we don't necessarily 2138 // need to understand them all. 2139 while (1) { 2140 if (Stream.AtEndOfStream()) 2141 return std::error_code(); 2142 2143 BitstreamEntry Entry = 2144 Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs); 2145 2146 switch (Entry.Kind) { 2147 case BitstreamEntry::Error: 2148 return Error(BitcodeError::MalformedBlock); 2149 case BitstreamEntry::EndBlock: 2150 return std::error_code(); 2151 2152 case BitstreamEntry::SubBlock: 2153 switch (Entry.ID) { 2154 case bitc::BLOCKINFO_BLOCK_ID: 2155 if (Stream.ReadBlockInfoBlock()) 2156 return Error(BitcodeError::MalformedBlock); 2157 break; 2158 case bitc::MODULE_BLOCK_ID: 2159 // Reject multiple MODULE_BLOCK's in a single bitstream. 2160 if (TheModule) 2161 return Error(BitcodeError::InvalidMultipleBlocks); 2162 TheModule = M; 2163 if (std::error_code EC = ParseModule(false)) 2164 return EC; 2165 if (LazyStreamer) 2166 return std::error_code(); 2167 break; 2168 default: 2169 if (Stream.SkipBlock()) 2170 return Error(BitcodeError::InvalidRecord); 2171 break; 2172 } 2173 continue; 2174 case BitstreamEntry::Record: 2175 // There should be no records in the top-level of blocks. 2176 2177 // The ranlib in Xcode 4 will align archive members by appending newlines 2178 // to the end of them. If this file size is a multiple of 4 but not 8, we 2179 // have to read and ignore these final 4 bytes :-( 2180 if (Stream.getAbbrevIDWidth() == 2 && Entry.ID == 2 && 2181 Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a && 2182 Stream.AtEndOfStream()) 2183 return std::error_code(); 2184 2185 return Error(BitcodeError::InvalidRecord); 2186 } 2187 } 2188 } 2189 2190 ErrorOr<std::string> BitcodeReader::parseModuleTriple() { 2191 if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) 2192 return Error(BitcodeError::InvalidRecord); 2193 2194 SmallVector<uint64_t, 64> Record; 2195 2196 std::string Triple; 2197 // Read all the records for this module. 2198 while (1) { 2199 BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 2200 2201 switch (Entry.Kind) { 2202 case BitstreamEntry::SubBlock: // Handled for us already. 2203 case BitstreamEntry::Error: 2204 return Error(BitcodeError::MalformedBlock); 2205 case BitstreamEntry::EndBlock: 2206 return Triple; 2207 case BitstreamEntry::Record: 2208 // The interesting case. 2209 break; 2210 } 2211 2212 // Read a record. 2213 switch (Stream.readRecord(Entry.ID, Record)) { 2214 default: break; // Default behavior, ignore unknown content. 2215 case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] 2216 std::string S; 2217 if (ConvertToString(Record, 0, S)) 2218 return Error(BitcodeError::InvalidRecord); 2219 Triple = S; 2220 break; 2221 } 2222 } 2223 Record.clear(); 2224 } 2225 llvm_unreachable("Exit infinite loop"); 2226 } 2227 2228 ErrorOr<std::string> BitcodeReader::parseTriple() { 2229 if (std::error_code EC = InitStream()) 2230 return EC; 2231 2232 // Sniff for the signature. 2233 if (Stream.Read(8) != 'B' || 2234 Stream.Read(8) != 'C' || 2235 Stream.Read(4) != 0x0 || 2236 Stream.Read(4) != 0xC || 2237 Stream.Read(4) != 0xE || 2238 Stream.Read(4) != 0xD) 2239 return Error(BitcodeError::InvalidBitcodeSignature); 2240 2241 // We expect a number of well-defined blocks, though we don't necessarily 2242 // need to understand them all. 2243 while (1) { 2244 BitstreamEntry Entry = Stream.advance(); 2245 2246 switch (Entry.Kind) { 2247 case BitstreamEntry::Error: 2248 return Error(BitcodeError::MalformedBlock); 2249 case BitstreamEntry::EndBlock: 2250 return std::error_code(); 2251 2252 case BitstreamEntry::SubBlock: 2253 if (Entry.ID == bitc::MODULE_BLOCK_ID) 2254 return parseModuleTriple(); 2255 2256 // Ignore other sub-blocks. 2257 if (Stream.SkipBlock()) 2258 return Error(BitcodeError::MalformedBlock); 2259 continue; 2260 2261 case BitstreamEntry::Record: 2262 Stream.skipRecord(Entry.ID); 2263 continue; 2264 } 2265 } 2266 } 2267 2268 /// ParseMetadataAttachment - Parse metadata attachments. 2269 std::error_code BitcodeReader::ParseMetadataAttachment() { 2270 if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) 2271 return Error(BitcodeError::InvalidRecord); 2272 2273 SmallVector<uint64_t, 64> Record; 2274 while (1) { 2275 BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 2276 2277 switch (Entry.Kind) { 2278 case BitstreamEntry::SubBlock: // Handled for us already. 2279 case BitstreamEntry::Error: 2280 return Error(BitcodeError::MalformedBlock); 2281 case BitstreamEntry::EndBlock: 2282 return std::error_code(); 2283 case BitstreamEntry::Record: 2284 // The interesting case. 2285 break; 2286 } 2287 2288 // Read a metadata attachment record. 2289 Record.clear(); 2290 switch (Stream.readRecord(Entry.ID, Record)) { 2291 default: // Default behavior: ignore. 2292 break; 2293 case bitc::METADATA_ATTACHMENT: { 2294 unsigned RecordLength = Record.size(); 2295 if (Record.empty() || (RecordLength - 1) % 2 == 1) 2296 return Error(BitcodeError::InvalidRecord); 2297 Instruction *Inst = InstructionList[Record[0]]; 2298 for (unsigned i = 1; i != RecordLength; i = i+2) { 2299 unsigned Kind = Record[i]; 2300 DenseMap<unsigned, unsigned>::iterator I = 2301 MDKindMap.find(Kind); 2302 if (I == MDKindMap.end()) 2303 return Error(BitcodeError::InvalidID); 2304 Value *Node = MDValueList.getValueFwdRef(Record[i+1]); 2305 Inst->setMetadata(I->second, cast<MDNode>(Node)); 2306 if (I->second == LLVMContext::MD_tbaa) 2307 InstsWithTBAATag.push_back(Inst); 2308 } 2309 break; 2310 } 2311 } 2312 } 2313 } 2314 2315 /// ParseFunctionBody - Lazily parse the specified function body block. 2316 std::error_code BitcodeReader::ParseFunctionBody(Function *F) { 2317 if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) 2318 return Error(BitcodeError::InvalidRecord); 2319 2320 InstructionList.clear(); 2321 unsigned ModuleValueListSize = ValueList.size(); 2322 unsigned ModuleMDValueListSize = MDValueList.size(); 2323 2324 // Add all the function arguments to the value table. 2325 for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) 2326 ValueList.push_back(I); 2327 2328 unsigned NextValueNo = ValueList.size(); 2329 BasicBlock *CurBB = nullptr; 2330 unsigned CurBBNo = 0; 2331 2332 DebugLoc LastLoc; 2333 2334 // Read all the records. 2335 SmallVector<uint64_t, 64> Record; 2336 while (1) { 2337 BitstreamEntry Entry = Stream.advance(); 2338 2339 switch (Entry.Kind) { 2340 case BitstreamEntry::Error: 2341 return Error(BitcodeError::MalformedBlock); 2342 case BitstreamEntry::EndBlock: 2343 goto OutOfRecordLoop; 2344 2345 case BitstreamEntry::SubBlock: 2346 switch (Entry.ID) { 2347 default: // Skip unknown content. 2348 if (Stream.SkipBlock()) 2349 return Error(BitcodeError::InvalidRecord); 2350 break; 2351 case bitc::CONSTANTS_BLOCK_ID: 2352 if (std::error_code EC = ParseConstants()) 2353 return EC; 2354 NextValueNo = ValueList.size(); 2355 break; 2356 case bitc::VALUE_SYMTAB_BLOCK_ID: 2357 if (std::error_code EC = ParseValueSymbolTable()) 2358 return EC; 2359 break; 2360 case bitc::METADATA_ATTACHMENT_ID: 2361 if (std::error_code EC = ParseMetadataAttachment()) 2362 return EC; 2363 break; 2364 case bitc::METADATA_BLOCK_ID: 2365 if (std::error_code EC = ParseMetadata()) 2366 return EC; 2367 break; 2368 case bitc::USELIST_BLOCK_ID: 2369 if (std::error_code EC = ParseUseLists()) 2370 return EC; 2371 break; 2372 } 2373 continue; 2374 2375 case BitstreamEntry::Record: 2376 // The interesting case. 2377 break; 2378 } 2379 2380 // Read a record. 2381 Record.clear(); 2382 Instruction *I = nullptr; 2383 unsigned BitCode = Stream.readRecord(Entry.ID, Record); 2384 switch (BitCode) { 2385 default: // Default behavior: reject 2386 return Error(BitcodeError::InvalidValue); 2387 case bitc::FUNC_CODE_DECLAREBLOCKS: { // DECLAREBLOCKS: [nblocks] 2388 if (Record.size() < 1 || Record[0] == 0) 2389 return Error(BitcodeError::InvalidRecord); 2390 // Create all the basic blocks for the function. 2391 FunctionBBs.resize(Record[0]); 2392 2393 // See if anything took the address of blocks in this function. 2394 auto BBFRI = BasicBlockFwdRefs.find(F); 2395 if (BBFRI == BasicBlockFwdRefs.end()) { 2396 for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) 2397 FunctionBBs[i] = BasicBlock::Create(Context, "", F); 2398 } else { 2399 auto &BBRefs = BBFRI->second; 2400 // Check for invalid basic block references. 2401 if (BBRefs.size() > FunctionBBs.size()) 2402 return Error(BitcodeError::InvalidID); 2403 assert(!BBRefs.empty() && "Unexpected empty array"); 2404 assert(!BBRefs.front() && "Invalid reference to entry block"); 2405 for (unsigned I = 0, E = FunctionBBs.size(), RE = BBRefs.size(); I != E; 2406 ++I) 2407 if (I < RE && BBRefs[I]) { 2408 BBRefs[I]->insertInto(F); 2409 FunctionBBs[I] = BBRefs[I]; 2410 } else { 2411 FunctionBBs[I] = BasicBlock::Create(Context, "", F); 2412 } 2413 2414 // Erase from the table. 2415 BasicBlockFwdRefs.erase(BBFRI); 2416 } 2417 2418 CurBB = FunctionBBs[0]; 2419 continue; 2420 } 2421 2422 case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN 2423 // This record indicates that the last instruction is at the same 2424 // location as the previous instruction with a location. 2425 I = nullptr; 2426 2427 // Get the last instruction emitted. 2428 if (CurBB && !CurBB->empty()) 2429 I = &CurBB->back(); 2430 else if (CurBBNo && FunctionBBs[CurBBNo-1] && 2431 !FunctionBBs[CurBBNo-1]->empty()) 2432 I = &FunctionBBs[CurBBNo-1]->back(); 2433 2434 if (!I) 2435 return Error(BitcodeError::InvalidRecord); 2436 I->setDebugLoc(LastLoc); 2437 I = nullptr; 2438 continue; 2439 2440 case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia] 2441 I = nullptr; // Get the last instruction emitted. 2442 if (CurBB && !CurBB->empty()) 2443 I = &CurBB->back(); 2444 else if (CurBBNo && FunctionBBs[CurBBNo-1] && 2445 !FunctionBBs[CurBBNo-1]->empty()) 2446 I = &FunctionBBs[CurBBNo-1]->back(); 2447 if (!I || Record.size() < 4) 2448 return Error(BitcodeError::InvalidRecord); 2449 2450 unsigned Line = Record[0], Col = Record[1]; 2451 unsigned ScopeID = Record[2], IAID = Record[3]; 2452 2453 MDNode *Scope = nullptr, *IA = nullptr; 2454 if (ScopeID) Scope = cast<MDNode>(MDValueList.getValueFwdRef(ScopeID-1)); 2455 if (IAID) IA = cast<MDNode>(MDValueList.getValueFwdRef(IAID-1)); 2456 LastLoc = DebugLoc::get(Line, Col, Scope, IA); 2457 I->setDebugLoc(LastLoc); 2458 I = nullptr; 2459 continue; 2460 } 2461 2462 case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode] 2463 unsigned OpNum = 0; 2464 Value *LHS, *RHS; 2465 if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 2466 popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) || 2467 OpNum+1 > Record.size()) 2468 return Error(BitcodeError::InvalidRecord); 2469 2470 int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); 2471 if (Opc == -1) 2472 return Error(BitcodeError::InvalidRecord); 2473 I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); 2474 InstructionList.push_back(I); 2475 if (OpNum < Record.size()) { 2476 if (Opc == Instruction::Add || 2477 Opc == Instruction::Sub || 2478 Opc == Instruction::Mul || 2479 Opc == Instruction::Shl) { 2480 if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP)) 2481 cast<BinaryOperator>(I)->setHasNoSignedWrap(true); 2482 if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) 2483 cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true); 2484 } else if (Opc == Instruction::SDiv || 2485 Opc == Instruction::UDiv || 2486 Opc == Instruction::LShr || 2487 Opc == Instruction::AShr) { 2488 if (Record[OpNum] & (1 << bitc::PEO_EXACT)) 2489 cast<BinaryOperator>(I)->setIsExact(true); 2490 } else if (isa<FPMathOperator>(I)) { 2491 FastMathFlags FMF; 2492 if (0 != (Record[OpNum] & FastMathFlags::UnsafeAlgebra)) 2493 FMF.setUnsafeAlgebra(); 2494 if (0 != (Record[OpNum] & FastMathFlags::NoNaNs)) 2495 FMF.setNoNaNs(); 2496 if (0 != (Record[OpNum] & FastMathFlags::NoInfs)) 2497 FMF.setNoInfs(); 2498 if (0 != (Record[OpNum] & FastMathFlags::NoSignedZeros)) 2499 FMF.setNoSignedZeros(); 2500 if (0 != (Record[OpNum] & FastMathFlags::AllowReciprocal)) 2501 FMF.setAllowReciprocal(); 2502 if (FMF.any()) 2503 I->setFastMathFlags(FMF); 2504 } 2505 2506 } 2507 break; 2508 } 2509 case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc] 2510 unsigned OpNum = 0; 2511 Value *Op; 2512 if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 2513 OpNum+2 != Record.size()) 2514 return Error(BitcodeError::InvalidRecord); 2515 2516 Type *ResTy = getTypeByID(Record[OpNum]); 2517 int Opc = GetDecodedCastOpcode(Record[OpNum+1]); 2518 if (Opc == -1 || !ResTy) 2519 return Error(BitcodeError::InvalidRecord); 2520 Instruction *Temp = nullptr; 2521 if ((I = UpgradeBitCastInst(Opc, Op, ResTy, Temp))) { 2522 if (Temp) { 2523 InstructionList.push_back(Temp); 2524 CurBB->getInstList().push_back(Temp); 2525 } 2526 } else { 2527 I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy); 2528 } 2529 InstructionList.push_back(I); 2530 break; 2531 } 2532 case bitc::FUNC_CODE_INST_INBOUNDS_GEP: 2533 case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands] 2534 unsigned OpNum = 0; 2535 Value *BasePtr; 2536 if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) 2537 return Error(BitcodeError::InvalidRecord); 2538 2539 SmallVector<Value*, 16> GEPIdx; 2540 while (OpNum != Record.size()) { 2541 Value *Op; 2542 if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2543 return Error(BitcodeError::InvalidRecord); 2544 GEPIdx.push_back(Op); 2545 } 2546 2547 I = GetElementPtrInst::Create(BasePtr, GEPIdx); 2548 InstructionList.push_back(I); 2549 if (BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP) 2550 cast<GetElementPtrInst>(I)->setIsInBounds(true); 2551 break; 2552 } 2553 2554 case bitc::FUNC_CODE_INST_EXTRACTVAL: { 2555 // EXTRACTVAL: [opty, opval, n x indices] 2556 unsigned OpNum = 0; 2557 Value *Agg; 2558 if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2559 return Error(BitcodeError::InvalidRecord); 2560 2561 SmallVector<unsigned, 4> EXTRACTVALIdx; 2562 for (unsigned RecSize = Record.size(); 2563 OpNum != RecSize; ++OpNum) { 2564 uint64_t Index = Record[OpNum]; 2565 if ((unsigned)Index != Index) 2566 return Error(BitcodeError::InvalidValue); 2567 EXTRACTVALIdx.push_back((unsigned)Index); 2568 } 2569 2570 I = ExtractValueInst::Create(Agg, EXTRACTVALIdx); 2571 InstructionList.push_back(I); 2572 break; 2573 } 2574 2575 case bitc::FUNC_CODE_INST_INSERTVAL: { 2576 // INSERTVAL: [opty, opval, opty, opval, n x indices] 2577 unsigned OpNum = 0; 2578 Value *Agg; 2579 if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) 2580 return Error(BitcodeError::InvalidRecord); 2581 Value *Val; 2582 if (getValueTypePair(Record, OpNum, NextValueNo, Val)) 2583 return Error(BitcodeError::InvalidRecord); 2584 2585 SmallVector<unsigned, 4> INSERTVALIdx; 2586 for (unsigned RecSize = Record.size(); 2587 OpNum != RecSize; ++OpNum) { 2588 uint64_t Index = Record[OpNum]; 2589 if ((unsigned)Index != Index) 2590 return Error(BitcodeError::InvalidValue); 2591 INSERTVALIdx.push_back((unsigned)Index); 2592 } 2593 2594 I = InsertValueInst::Create(Agg, Val, INSERTVALIdx); 2595 InstructionList.push_back(I); 2596 break; 2597 } 2598 2599 case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval] 2600 // obsolete form of select 2601 // handles select i1 ... in old bitcode 2602 unsigned OpNum = 0; 2603 Value *TrueVal, *FalseVal, *Cond; 2604 if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 2605 popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) || 2606 popValue(Record, OpNum, NextValueNo, Type::getInt1Ty(Context), Cond)) 2607 return Error(BitcodeError::InvalidRecord); 2608 2609 I = SelectInst::Create(Cond, TrueVal, FalseVal); 2610 InstructionList.push_back(I); 2611 break; 2612 } 2613 2614 case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred] 2615 // new form of select 2616 // handles select i1 or select [N x i1] 2617 unsigned OpNum = 0; 2618 Value *TrueVal, *FalseVal, *Cond; 2619 if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || 2620 popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) || 2621 getValueTypePair(Record, OpNum, NextValueNo, Cond)) 2622 return Error(BitcodeError::InvalidRecord); 2623 2624 // select condition can be either i1 or [N x i1] 2625 if (VectorType* vector_type = 2626 dyn_cast<VectorType>(Cond->getType())) { 2627 // expect <n x i1> 2628 if (vector_type->getElementType() != Type::getInt1Ty(Context)) 2629 return Error(BitcodeError::InvalidTypeForValue); 2630 } else { 2631 // expect i1 2632 if (Cond->getType() != Type::getInt1Ty(Context)) 2633 return Error(BitcodeError::InvalidTypeForValue); 2634 } 2635 2636 I = SelectInst::Create(Cond, TrueVal, FalseVal); 2637 InstructionList.push_back(I); 2638 break; 2639 } 2640 2641 case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval] 2642 unsigned OpNum = 0; 2643 Value *Vec, *Idx; 2644 if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 2645 getValueTypePair(Record, OpNum, NextValueNo, Idx)) 2646 return Error(BitcodeError::InvalidRecord); 2647 I = ExtractElementInst::Create(Vec, Idx); 2648 InstructionList.push_back(I); 2649 break; 2650 } 2651 2652 case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval] 2653 unsigned OpNum = 0; 2654 Value *Vec, *Elt, *Idx; 2655 if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || 2656 popValue(Record, OpNum, NextValueNo, 2657 cast<VectorType>(Vec->getType())->getElementType(), Elt) || 2658 getValueTypePair(Record, OpNum, NextValueNo, Idx)) 2659 return Error(BitcodeError::InvalidRecord); 2660 I = InsertElementInst::Create(Vec, Elt, Idx); 2661 InstructionList.push_back(I); 2662 break; 2663 } 2664 2665 case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval] 2666 unsigned OpNum = 0; 2667 Value *Vec1, *Vec2, *Mask; 2668 if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) || 2669 popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec2)) 2670 return Error(BitcodeError::InvalidRecord); 2671 2672 if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) 2673 return Error(BitcodeError::InvalidRecord); 2674 I = new ShuffleVectorInst(Vec1, Vec2, Mask); 2675 InstructionList.push_back(I); 2676 break; 2677 } 2678 2679 case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred] 2680 // Old form of ICmp/FCmp returning bool 2681 // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were 2682 // both legal on vectors but had different behaviour. 2683 case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred] 2684 // FCmp/ICmp returning bool or vector of bool 2685 2686 unsigned OpNum = 0; 2687 Value *LHS, *RHS; 2688 if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || 2689 popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) || 2690 OpNum+1 != Record.size()) 2691 return Error(BitcodeError::InvalidRecord); 2692 2693 if (LHS->getType()->isFPOrFPVectorTy()) 2694 I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); 2695 else 2696 I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS); 2697 InstructionList.push_back(I); 2698 break; 2699 } 2700 2701 case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>] 2702 { 2703 unsigned Size = Record.size(); 2704 if (Size == 0) { 2705 I = ReturnInst::Create(Context); 2706 InstructionList.push_back(I); 2707 break; 2708 } 2709 2710 unsigned OpNum = 0; 2711 Value *Op = nullptr; 2712 if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2713 return Error(BitcodeError::InvalidRecord); 2714 if (OpNum != Record.size()) 2715 return Error(BitcodeError::InvalidRecord); 2716 2717 I = ReturnInst::Create(Context, Op); 2718 InstructionList.push_back(I); 2719 break; 2720 } 2721 case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] 2722 if (Record.size() != 1 && Record.size() != 3) 2723 return Error(BitcodeError::InvalidRecord); 2724 BasicBlock *TrueDest = getBasicBlock(Record[0]); 2725 if (!TrueDest) 2726 return Error(BitcodeError::InvalidRecord); 2727 2728 if (Record.size() == 1) { 2729 I = BranchInst::Create(TrueDest); 2730 InstructionList.push_back(I); 2731 } 2732 else { 2733 BasicBlock *FalseDest = getBasicBlock(Record[1]); 2734 Value *Cond = getValue(Record, 2, NextValueNo, 2735 Type::getInt1Ty(Context)); 2736 if (!FalseDest || !Cond) 2737 return Error(BitcodeError::InvalidRecord); 2738 I = BranchInst::Create(TrueDest, FalseDest, Cond); 2739 InstructionList.push_back(I); 2740 } 2741 break; 2742 } 2743 case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...] 2744 // Check magic 2745 if ((Record[0] >> 16) == SWITCH_INST_MAGIC) { 2746 // "New" SwitchInst format with case ranges. The changes to write this 2747 // format were reverted but we still recognize bitcode that uses it. 2748 // Hopefully someday we will have support for case ranges and can use 2749 // this format again. 2750 2751 Type *OpTy = getTypeByID(Record[1]); 2752 unsigned ValueBitWidth = cast<IntegerType>(OpTy)->getBitWidth(); 2753 2754 Value *Cond = getValue(Record, 2, NextValueNo, OpTy); 2755 BasicBlock *Default = getBasicBlock(Record[3]); 2756 if (!OpTy || !Cond || !Default) 2757 return Error(BitcodeError::InvalidRecord); 2758 2759 unsigned NumCases = Record[4]; 2760 2761 SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); 2762 InstructionList.push_back(SI); 2763 2764 unsigned CurIdx = 5; 2765 for (unsigned i = 0; i != NumCases; ++i) { 2766 SmallVector<ConstantInt*, 1> CaseVals; 2767 unsigned NumItems = Record[CurIdx++]; 2768 for (unsigned ci = 0; ci != NumItems; ++ci) { 2769 bool isSingleNumber = Record[CurIdx++]; 2770 2771 APInt Low; 2772 unsigned ActiveWords = 1; 2773 if (ValueBitWidth > 64) 2774 ActiveWords = Record[CurIdx++]; 2775 Low = ReadWideAPInt(makeArrayRef(&Record[CurIdx], ActiveWords), 2776 ValueBitWidth); 2777 CurIdx += ActiveWords; 2778 2779 if (!isSingleNumber) { 2780 ActiveWords = 1; 2781 if (ValueBitWidth > 64) 2782 ActiveWords = Record[CurIdx++]; 2783 APInt High = 2784 ReadWideAPInt(makeArrayRef(&Record[CurIdx], ActiveWords), 2785 ValueBitWidth); 2786 CurIdx += ActiveWords; 2787 2788 // FIXME: It is not clear whether values in the range should be 2789 // compared as signed or unsigned values. The partially 2790 // implemented changes that used this format in the past used 2791 // unsigned comparisons. 2792 for ( ; Low.ule(High); ++Low) 2793 CaseVals.push_back(ConstantInt::get(Context, Low)); 2794 } else 2795 CaseVals.push_back(ConstantInt::get(Context, Low)); 2796 } 2797 BasicBlock *DestBB = getBasicBlock(Record[CurIdx++]); 2798 for (SmallVector<ConstantInt*, 1>::iterator cvi = CaseVals.begin(), 2799 cve = CaseVals.end(); cvi != cve; ++cvi) 2800 SI->addCase(*cvi, DestBB); 2801 } 2802 I = SI; 2803 break; 2804 } 2805 2806 // Old SwitchInst format without case ranges. 2807 2808 if (Record.size() < 3 || (Record.size() & 1) == 0) 2809 return Error(BitcodeError::InvalidRecord); 2810 Type *OpTy = getTypeByID(Record[0]); 2811 Value *Cond = getValue(Record, 1, NextValueNo, OpTy); 2812 BasicBlock *Default = getBasicBlock(Record[2]); 2813 if (!OpTy || !Cond || !Default) 2814 return Error(BitcodeError::InvalidRecord); 2815 unsigned NumCases = (Record.size()-3)/2; 2816 SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); 2817 InstructionList.push_back(SI); 2818 for (unsigned i = 0, e = NumCases; i != e; ++i) { 2819 ConstantInt *CaseVal = 2820 dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy)); 2821 BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); 2822 if (!CaseVal || !DestBB) { 2823 delete SI; 2824 return Error(BitcodeError::InvalidRecord); 2825 } 2826 SI->addCase(CaseVal, DestBB); 2827 } 2828 I = SI; 2829 break; 2830 } 2831 case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] 2832 if (Record.size() < 2) 2833 return Error(BitcodeError::InvalidRecord); 2834 Type *OpTy = getTypeByID(Record[0]); 2835 Value *Address = getValue(Record, 1, NextValueNo, OpTy); 2836 if (!OpTy || !Address) 2837 return Error(BitcodeError::InvalidRecord); 2838 unsigned NumDests = Record.size()-2; 2839 IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); 2840 InstructionList.push_back(IBI); 2841 for (unsigned i = 0, e = NumDests; i != e; ++i) { 2842 if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) { 2843 IBI->addDestination(DestBB); 2844 } else { 2845 delete IBI; 2846 return Error(BitcodeError::InvalidRecord); 2847 } 2848 } 2849 I = IBI; 2850 break; 2851 } 2852 2853 case bitc::FUNC_CODE_INST_INVOKE: { 2854 // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] 2855 if (Record.size() < 4) 2856 return Error(BitcodeError::InvalidRecord); 2857 AttributeSet PAL = getAttributes(Record[0]); 2858 unsigned CCInfo = Record[1]; 2859 BasicBlock *NormalBB = getBasicBlock(Record[2]); 2860 BasicBlock *UnwindBB = getBasicBlock(Record[3]); 2861 2862 unsigned OpNum = 4; 2863 Value *Callee; 2864 if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 2865 return Error(BitcodeError::InvalidRecord); 2866 2867 PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); 2868 FunctionType *FTy = !CalleeTy ? nullptr : 2869 dyn_cast<FunctionType>(CalleeTy->getElementType()); 2870 2871 // Check that the right number of fixed parameters are here. 2872 if (!FTy || !NormalBB || !UnwindBB || 2873 Record.size() < OpNum+FTy->getNumParams()) 2874 return Error(BitcodeError::InvalidRecord); 2875 2876 SmallVector<Value*, 16> Ops; 2877 for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 2878 Ops.push_back(getValue(Record, OpNum, NextValueNo, 2879 FTy->getParamType(i))); 2880 if (!Ops.back()) 2881 return Error(BitcodeError::InvalidRecord); 2882 } 2883 2884 if (!FTy->isVarArg()) { 2885 if (Record.size() != OpNum) 2886 return Error(BitcodeError::InvalidRecord); 2887 } else { 2888 // Read type/value pairs for varargs params. 2889 while (OpNum != Record.size()) { 2890 Value *Op; 2891 if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 2892 return Error(BitcodeError::InvalidRecord); 2893 Ops.push_back(Op); 2894 } 2895 } 2896 2897 I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops); 2898 InstructionList.push_back(I); 2899 cast<InvokeInst>(I)->setCallingConv( 2900 static_cast<CallingConv::ID>(CCInfo)); 2901 cast<InvokeInst>(I)->setAttributes(PAL); 2902 break; 2903 } 2904 case bitc::FUNC_CODE_INST_RESUME: { // RESUME: [opval] 2905 unsigned Idx = 0; 2906 Value *Val = nullptr; 2907 if (getValueTypePair(Record, Idx, NextValueNo, Val)) 2908 return Error(BitcodeError::InvalidRecord); 2909 I = ResumeInst::Create(Val); 2910 InstructionList.push_back(I); 2911 break; 2912 } 2913 case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE 2914 I = new UnreachableInst(Context); 2915 InstructionList.push_back(I); 2916 break; 2917 case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...] 2918 if (Record.size() < 1 || ((Record.size()-1)&1)) 2919 return Error(BitcodeError::InvalidRecord); 2920 Type *Ty = getTypeByID(Record[0]); 2921 if (!Ty) 2922 return Error(BitcodeError::InvalidRecord); 2923 2924 PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2); 2925 InstructionList.push_back(PN); 2926 2927 for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) { 2928 Value *V; 2929 // With the new function encoding, it is possible that operands have 2930 // negative IDs (for forward references). Use a signed VBR 2931 // representation to keep the encoding small. 2932 if (UseRelativeIDs) 2933 V = getValueSigned(Record, 1+i, NextValueNo, Ty); 2934 else 2935 V = getValue(Record, 1+i, NextValueNo, Ty); 2936 BasicBlock *BB = getBasicBlock(Record[2+i]); 2937 if (!V || !BB) 2938 return Error(BitcodeError::InvalidRecord); 2939 PN->addIncoming(V, BB); 2940 } 2941 I = PN; 2942 break; 2943 } 2944 2945 case bitc::FUNC_CODE_INST_LANDINGPAD: { 2946 // LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?] 2947 unsigned Idx = 0; 2948 if (Record.size() < 4) 2949 return Error(BitcodeError::InvalidRecord); 2950 Type *Ty = getTypeByID(Record[Idx++]); 2951 if (!Ty) 2952 return Error(BitcodeError::InvalidRecord); 2953 Value *PersFn = nullptr; 2954 if (getValueTypePair(Record, Idx, NextValueNo, PersFn)) 2955 return Error(BitcodeError::InvalidRecord); 2956 2957 bool IsCleanup = !!Record[Idx++]; 2958 unsigned NumClauses = Record[Idx++]; 2959 LandingPadInst *LP = LandingPadInst::Create(Ty, PersFn, NumClauses); 2960 LP->setCleanup(IsCleanup); 2961 for (unsigned J = 0; J != NumClauses; ++J) { 2962 LandingPadInst::ClauseType CT = 2963 LandingPadInst::ClauseType(Record[Idx++]); (void)CT; 2964 Value *Val; 2965 2966 if (getValueTypePair(Record, Idx, NextValueNo, Val)) { 2967 delete LP; 2968 return Error(BitcodeError::InvalidRecord); 2969 } 2970 2971 assert((CT != LandingPadInst::Catch || 2972 !isa<ArrayType>(Val->getType())) && 2973 "Catch clause has a invalid type!"); 2974 assert((CT != LandingPadInst::Filter || 2975 isa<ArrayType>(Val->getType())) && 2976 "Filter clause has invalid type!"); 2977 LP->addClause(cast<Constant>(Val)); 2978 } 2979 2980 I = LP; 2981 InstructionList.push_back(I); 2982 break; 2983 } 2984 2985 case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align] 2986 if (Record.size() != 4) 2987 return Error(BitcodeError::InvalidRecord); 2988 PointerType *Ty = 2989 dyn_cast_or_null<PointerType>(getTypeByID(Record[0])); 2990 Type *OpTy = getTypeByID(Record[1]); 2991 Value *Size = getFnValueByID(Record[2], OpTy); 2992 unsigned AlignRecord = Record[3]; 2993 bool InAlloca = AlignRecord & (1 << 5); 2994 unsigned Align = AlignRecord & ((1 << 5) - 1); 2995 if (!Ty || !Size) 2996 return Error(BitcodeError::InvalidRecord); 2997 AllocaInst *AI = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); 2998 AI->setUsedWithInAlloca(InAlloca); 2999 I = AI; 3000 InstructionList.push_back(I); 3001 break; 3002 } 3003 case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol] 3004 unsigned OpNum = 0; 3005 Value *Op; 3006 if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 3007 OpNum+2 != Record.size()) 3008 return Error(BitcodeError::InvalidRecord); 3009 3010 I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); 3011 InstructionList.push_back(I); 3012 break; 3013 } 3014 case bitc::FUNC_CODE_INST_LOADATOMIC: { 3015 // LOADATOMIC: [opty, op, align, vol, ordering, synchscope] 3016 unsigned OpNum = 0; 3017 Value *Op; 3018 if (getValueTypePair(Record, OpNum, NextValueNo, Op) || 3019 OpNum+4 != Record.size()) 3020 return Error(BitcodeError::InvalidRecord); 3021 3022 AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); 3023 if (Ordering == NotAtomic || Ordering == Release || 3024 Ordering == AcquireRelease) 3025 return Error(BitcodeError::InvalidRecord); 3026 if (Ordering != NotAtomic && Record[OpNum] == 0) 3027 return Error(BitcodeError::InvalidRecord); 3028 SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); 3029 3030 I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1, 3031 Ordering, SynchScope); 3032 InstructionList.push_back(I); 3033 break; 3034 } 3035 case bitc::FUNC_CODE_INST_STORE: { // STORE2:[ptrty, ptr, val, align, vol] 3036 unsigned OpNum = 0; 3037 Value *Val, *Ptr; 3038 if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 3039 popValue(Record, OpNum, NextValueNo, 3040 cast<PointerType>(Ptr->getType())->getElementType(), Val) || 3041 OpNum+2 != Record.size()) 3042 return Error(BitcodeError::InvalidRecord); 3043 3044 I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); 3045 InstructionList.push_back(I); 3046 break; 3047 } 3048 case bitc::FUNC_CODE_INST_STOREATOMIC: { 3049 // STOREATOMIC: [ptrty, ptr, val, align, vol, ordering, synchscope] 3050 unsigned OpNum = 0; 3051 Value *Val, *Ptr; 3052 if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 3053 popValue(Record, OpNum, NextValueNo, 3054 cast<PointerType>(Ptr->getType())->getElementType(), Val) || 3055 OpNum+4 != Record.size()) 3056 return Error(BitcodeError::InvalidRecord); 3057 3058 AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); 3059 if (Ordering == NotAtomic || Ordering == Acquire || 3060 Ordering == AcquireRelease) 3061 return Error(BitcodeError::InvalidRecord); 3062 SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); 3063 if (Ordering != NotAtomic && Record[OpNum] == 0) 3064 return Error(BitcodeError::InvalidRecord); 3065 3066 I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1, 3067 Ordering, SynchScope); 3068 InstructionList.push_back(I); 3069 break; 3070 } 3071 case bitc::FUNC_CODE_INST_CMPXCHG: { 3072 // CMPXCHG:[ptrty, ptr, cmp, new, vol, successordering, synchscope, 3073 // failureordering?, isweak?] 3074 unsigned OpNum = 0; 3075 Value *Ptr, *Cmp, *New; 3076 if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 3077 popValue(Record, OpNum, NextValueNo, 3078 cast<PointerType>(Ptr->getType())->getElementType(), Cmp) || 3079 popValue(Record, OpNum, NextValueNo, 3080 cast<PointerType>(Ptr->getType())->getElementType(), New) || 3081 (Record.size() < OpNum + 3 || Record.size() > OpNum + 5)) 3082 return Error(BitcodeError::InvalidRecord); 3083 AtomicOrdering SuccessOrdering = GetDecodedOrdering(Record[OpNum+1]); 3084 if (SuccessOrdering == NotAtomic || SuccessOrdering == Unordered) 3085 return Error(BitcodeError::InvalidRecord); 3086 SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+2]); 3087 3088 AtomicOrdering FailureOrdering; 3089 if (Record.size() < 7) 3090 FailureOrdering = 3091 AtomicCmpXchgInst::getStrongestFailureOrdering(SuccessOrdering); 3092 else 3093 FailureOrdering = GetDecodedOrdering(Record[OpNum+3]); 3094 3095 I = new AtomicCmpXchgInst(Ptr, Cmp, New, SuccessOrdering, FailureOrdering, 3096 SynchScope); 3097 cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]); 3098 3099 if (Record.size() < 8) { 3100 // Before weak cmpxchgs existed, the instruction simply returned the 3101 // value loaded from memory, so bitcode files from that era will be 3102 // expecting the first component of a modern cmpxchg. 3103 CurBB->getInstList().push_back(I); 3104 I = ExtractValueInst::Create(I, 0); 3105 } else { 3106 cast<AtomicCmpXchgInst>(I)->setWeak(Record[OpNum+4]); 3107 } 3108 3109 InstructionList.push_back(I); 3110 break; 3111 } 3112 case bitc::FUNC_CODE_INST_ATOMICRMW: { 3113 // ATOMICRMW:[ptrty, ptr, val, op, vol, ordering, synchscope] 3114 unsigned OpNum = 0; 3115 Value *Ptr, *Val; 3116 if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || 3117 popValue(Record, OpNum, NextValueNo, 3118 cast<PointerType>(Ptr->getType())->getElementType(), Val) || 3119 OpNum+4 != Record.size()) 3120 return Error(BitcodeError::InvalidRecord); 3121 AtomicRMWInst::BinOp Operation = GetDecodedRMWOperation(Record[OpNum]); 3122 if (Operation < AtomicRMWInst::FIRST_BINOP || 3123 Operation > AtomicRMWInst::LAST_BINOP) 3124 return Error(BitcodeError::InvalidRecord); 3125 AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); 3126 if (Ordering == NotAtomic || Ordering == Unordered) 3127 return Error(BitcodeError::InvalidRecord); 3128 SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); 3129 I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SynchScope); 3130 cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]); 3131 InstructionList.push_back(I); 3132 break; 3133 } 3134 case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, synchscope] 3135 if (2 != Record.size()) 3136 return Error(BitcodeError::InvalidRecord); 3137 AtomicOrdering Ordering = GetDecodedOrdering(Record[0]); 3138 if (Ordering == NotAtomic || Ordering == Unordered || 3139 Ordering == Monotonic) 3140 return Error(BitcodeError::InvalidRecord); 3141 SynchronizationScope SynchScope = GetDecodedSynchScope(Record[1]); 3142 I = new FenceInst(Context, Ordering, SynchScope); 3143 InstructionList.push_back(I); 3144 break; 3145 } 3146 case bitc::FUNC_CODE_INST_CALL: { 3147 // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] 3148 if (Record.size() < 3) 3149 return Error(BitcodeError::InvalidRecord); 3150 3151 AttributeSet PAL = getAttributes(Record[0]); 3152 unsigned CCInfo = Record[1]; 3153 3154 unsigned OpNum = 2; 3155 Value *Callee; 3156 if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) 3157 return Error(BitcodeError::InvalidRecord); 3158 3159 PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); 3160 FunctionType *FTy = nullptr; 3161 if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType()); 3162 if (!FTy || Record.size() < FTy->getNumParams()+OpNum) 3163 return Error(BitcodeError::InvalidRecord); 3164 3165 SmallVector<Value*, 16> Args; 3166 // Read the fixed params. 3167 for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { 3168 if (FTy->getParamType(i)->isLabelTy()) 3169 Args.push_back(getBasicBlock(Record[OpNum])); 3170 else 3171 Args.push_back(getValue(Record, OpNum, NextValueNo, 3172 FTy->getParamType(i))); 3173 if (!Args.back()) 3174 return Error(BitcodeError::InvalidRecord); 3175 } 3176 3177 // Read type/value pairs for varargs params. 3178 if (!FTy->isVarArg()) { 3179 if (OpNum != Record.size()) 3180 return Error(BitcodeError::InvalidRecord); 3181 } else { 3182 while (OpNum != Record.size()) { 3183 Value *Op; 3184 if (getValueTypePair(Record, OpNum, NextValueNo, Op)) 3185 return Error(BitcodeError::InvalidRecord); 3186 Args.push_back(Op); 3187 } 3188 } 3189 3190 I = CallInst::Create(Callee, Args); 3191 InstructionList.push_back(I); 3192 cast<CallInst>(I)->setCallingConv( 3193 static_cast<CallingConv::ID>((~(1U << 14) & CCInfo) >> 1)); 3194 CallInst::TailCallKind TCK = CallInst::TCK_None; 3195 if (CCInfo & 1) 3196 TCK = CallInst::TCK_Tail; 3197 if (CCInfo & (1 << 14)) 3198 TCK = CallInst::TCK_MustTail; 3199 cast<CallInst>(I)->setTailCallKind(TCK); 3200 cast<CallInst>(I)->setAttributes(PAL); 3201 break; 3202 } 3203 case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] 3204 if (Record.size() < 3) 3205 return Error(BitcodeError::InvalidRecord); 3206 Type *OpTy = getTypeByID(Record[0]); 3207 Value *Op = getValue(Record, 1, NextValueNo, OpTy); 3208 Type *ResTy = getTypeByID(Record[2]); 3209 if (!OpTy || !Op || !ResTy) 3210 return Error(BitcodeError::InvalidRecord); 3211 I = new VAArgInst(Op, ResTy); 3212 InstructionList.push_back(I); 3213 break; 3214 } 3215 } 3216 3217 // Add instruction to end of current BB. If there is no current BB, reject 3218 // this file. 3219 if (!CurBB) { 3220 delete I; 3221 return Error(BitcodeError::InvalidInstructionWithNoBB); 3222 } 3223 CurBB->getInstList().push_back(I); 3224 3225 // If this was a terminator instruction, move to the next block. 3226 if (isa<TerminatorInst>(I)) { 3227 ++CurBBNo; 3228 CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : nullptr; 3229 } 3230 3231 // Non-void values get registered in the value table for future use. 3232 if (I && !I->getType()->isVoidTy()) 3233 ValueList.AssignValue(I, NextValueNo++); 3234 } 3235 3236 OutOfRecordLoop: 3237 3238 // Check the function list for unresolved values. 3239 if (Argument *A = dyn_cast<Argument>(ValueList.back())) { 3240 if (!A->getParent()) { 3241 // We found at least one unresolved value. Nuke them all to avoid leaks. 3242 for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){ 3243 if ((A = dyn_cast_or_null<Argument>(ValueList[i])) && !A->getParent()) { 3244 A->replaceAllUsesWith(UndefValue::get(A->getType())); 3245 delete A; 3246 } 3247 } 3248 return Error(BitcodeError::NeverResolvedValueFoundInFunction); 3249 } 3250 } 3251 3252 // FIXME: Check for unresolved forward-declared metadata references 3253 // and clean up leaks. 3254 3255 // Trim the value list down to the size it was before we parsed this function. 3256 ValueList.shrinkTo(ModuleValueListSize); 3257 MDValueList.shrinkTo(ModuleMDValueListSize); 3258 std::vector<BasicBlock*>().swap(FunctionBBs); 3259 return std::error_code(); 3260 } 3261 3262 /// Find the function body in the bitcode stream 3263 std::error_code BitcodeReader::FindFunctionInStream( 3264 Function *F, 3265 DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator) { 3266 while (DeferredFunctionInfoIterator->second == 0) { 3267 if (Stream.AtEndOfStream()) 3268 return Error(BitcodeError::CouldNotFindFunctionInStream); 3269 // ParseModule will parse the next body in the stream and set its 3270 // position in the DeferredFunctionInfo map. 3271 if (std::error_code EC = ParseModule(true)) 3272 return EC; 3273 } 3274 return std::error_code(); 3275 } 3276 3277 //===----------------------------------------------------------------------===// 3278 // GVMaterializer implementation 3279 //===----------------------------------------------------------------------===// 3280 3281 void BitcodeReader::releaseBuffer() { Buffer.release(); } 3282 3283 bool BitcodeReader::isMaterializable(const GlobalValue *GV) const { 3284 if (const Function *F = dyn_cast<Function>(GV)) { 3285 return F->isDeclaration() && 3286 DeferredFunctionInfo.count(const_cast<Function*>(F)); 3287 } 3288 return false; 3289 } 3290 3291 std::error_code BitcodeReader::Materialize(GlobalValue *GV) { 3292 Function *F = dyn_cast<Function>(GV); 3293 // If it's not a function or is already material, ignore the request. 3294 if (!F || !F->isMaterializable()) 3295 return std::error_code(); 3296 3297 DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F); 3298 assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!"); 3299 // If its position is recorded as 0, its body is somewhere in the stream 3300 // but we haven't seen it yet. 3301 if (DFII->second == 0 && LazyStreamer) 3302 if (std::error_code EC = FindFunctionInStream(F, DFII)) 3303 return EC; 3304 3305 // Move the bit stream to the saved position of the deferred function body. 3306 Stream.JumpToBit(DFII->second); 3307 3308 if (std::error_code EC = ParseFunctionBody(F)) 3309 return EC; 3310 3311 // Upgrade any old intrinsic calls in the function. 3312 for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(), 3313 E = UpgradedIntrinsics.end(); I != E; ++I) { 3314 if (I->first != I->second) { 3315 for (auto UI = I->first->user_begin(), UE = I->first->user_end(); 3316 UI != UE;) { 3317 if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 3318 UpgradeIntrinsicCall(CI, I->second); 3319 } 3320 } 3321 } 3322 3323 // Bring in any functions that this function forward-referenced via 3324 // blockaddresses. 3325 return materializeForwardReferencedFunctions(); 3326 } 3327 3328 bool BitcodeReader::isDematerializable(const GlobalValue *GV) const { 3329 const Function *F = dyn_cast<Function>(GV); 3330 if (!F || F->isDeclaration()) 3331 return false; 3332 3333 // Dematerializing F would leave dangling references that wouldn't be 3334 // reconnected on re-materialization. 3335 if (BlockAddressesTaken.count(F)) 3336 return false; 3337 3338 return DeferredFunctionInfo.count(const_cast<Function*>(F)); 3339 } 3340 3341 void BitcodeReader::Dematerialize(GlobalValue *GV) { 3342 Function *F = dyn_cast<Function>(GV); 3343 // If this function isn't dematerializable, this is a noop. 3344 if (!F || !isDematerializable(F)) 3345 return; 3346 3347 assert(DeferredFunctionInfo.count(F) && "No info to read function later?"); 3348 3349 // Just forget the function body, we can remat it later. 3350 F->dropAllReferences(); 3351 } 3352 3353 std::error_code BitcodeReader::MaterializeModule(Module *M) { 3354 assert(M == TheModule && 3355 "Can only Materialize the Module this BitcodeReader is attached to."); 3356 3357 // Promise to materialize all forward references. 3358 WillMaterializeAllForwardRefs = true; 3359 3360 // Iterate over the module, deserializing any functions that are still on 3361 // disk. 3362 for (Module::iterator F = TheModule->begin(), E = TheModule->end(); 3363 F != E; ++F) { 3364 if (F->isMaterializable()) { 3365 if (std::error_code EC = Materialize(F)) 3366 return EC; 3367 } 3368 } 3369 // At this point, if there are any function bodies, the current bit is 3370 // pointing to the END_BLOCK record after them. Now make sure the rest 3371 // of the bits in the module have been read. 3372 if (NextUnreadBit) 3373 ParseModule(true); 3374 3375 // Check that all block address forward references got resolved (as we 3376 // promised above). 3377 if (!BasicBlockFwdRefs.empty()) 3378 return Error(BitcodeError::NeverResolvedFunctionFromBlockAddress); 3379 3380 // Upgrade any intrinsic calls that slipped through (should not happen!) and 3381 // delete the old functions to clean up. We can't do this unless the entire 3382 // module is materialized because there could always be another function body 3383 // with calls to the old function. 3384 for (std::vector<std::pair<Function*, Function*> >::iterator I = 3385 UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) { 3386 if (I->first != I->second) { 3387 for (auto UI = I->first->user_begin(), UE = I->first->user_end(); 3388 UI != UE;) { 3389 if (CallInst* CI = dyn_cast<CallInst>(*UI++)) 3390 UpgradeIntrinsicCall(CI, I->second); 3391 } 3392 if (!I->first->use_empty()) 3393 I->first->replaceAllUsesWith(I->second); 3394 I->first->eraseFromParent(); 3395 } 3396 } 3397 std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics); 3398 3399 for (unsigned I = 0, E = InstsWithTBAATag.size(); I < E; I++) 3400 UpgradeInstWithTBAATag(InstsWithTBAATag[I]); 3401 3402 UpgradeDebugInfo(*M); 3403 return std::error_code(); 3404 } 3405 3406 std::error_code BitcodeReader::InitStream() { 3407 if (LazyStreamer) 3408 return InitLazyStream(); 3409 return InitStreamFromBuffer(); 3410 } 3411 3412 std::error_code BitcodeReader::InitStreamFromBuffer() { 3413 const unsigned char *BufPtr = (const unsigned char*)Buffer->getBufferStart(); 3414 const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); 3415 3416 if (Buffer->getBufferSize() & 3) 3417 return Error(BitcodeError::InvalidBitcodeSignature); 3418 3419 // If we have a wrapper header, parse it and ignore the non-bc file contents. 3420 // The magic number is 0x0B17C0DE stored in little endian. 3421 if (isBitcodeWrapper(BufPtr, BufEnd)) 3422 if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true)) 3423 return Error(BitcodeError::InvalidBitcodeWrapperHeader); 3424 3425 StreamFile.reset(new BitstreamReader(BufPtr, BufEnd)); 3426 Stream.init(*StreamFile); 3427 3428 return std::error_code(); 3429 } 3430 3431 std::error_code BitcodeReader::InitLazyStream() { 3432 // Check and strip off the bitcode wrapper; BitstreamReader expects never to 3433 // see it. 3434 StreamingMemoryObject *Bytes = new StreamingMemoryObject(LazyStreamer); 3435 StreamFile.reset(new BitstreamReader(Bytes)); 3436 Stream.init(*StreamFile); 3437 3438 unsigned char buf[16]; 3439 if (Bytes->readBytes(0, 16, buf) == -1) 3440 return Error(BitcodeError::InvalidBitcodeSignature); 3441 3442 if (!isBitcode(buf, buf + 16)) 3443 return Error(BitcodeError::InvalidBitcodeSignature); 3444 3445 if (isBitcodeWrapper(buf, buf + 4)) { 3446 const unsigned char *bitcodeStart = buf; 3447 const unsigned char *bitcodeEnd = buf + 16; 3448 SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false); 3449 Bytes->dropLeadingBytes(bitcodeStart - buf); 3450 Bytes->setKnownObjectSize(bitcodeEnd - bitcodeStart); 3451 } 3452 return std::error_code(); 3453 } 3454 3455 namespace { 3456 class BitcodeErrorCategoryType : public std::error_category { 3457 const char *name() const LLVM_NOEXCEPT override { 3458 return "llvm.bitcode"; 3459 } 3460 std::string message(int IE) const override { 3461 BitcodeError E = static_cast<BitcodeError>(IE); 3462 switch (E) { 3463 case BitcodeError::ConflictingMETADATA_KINDRecords: 3464 return "Conflicting METADATA_KIND records"; 3465 case BitcodeError::CouldNotFindFunctionInStream: 3466 return "Could not find function in stream"; 3467 case BitcodeError::ExpectedConstant: 3468 return "Expected a constant"; 3469 case BitcodeError::InsufficientFunctionProtos: 3470 return "Insufficient function protos"; 3471 case BitcodeError::InvalidBitcodeSignature: 3472 return "Invalid bitcode signature"; 3473 case BitcodeError::InvalidBitcodeWrapperHeader: 3474 return "Invalid bitcode wrapper header"; 3475 case BitcodeError::InvalidConstantReference: 3476 return "Invalid ronstant reference"; 3477 case BitcodeError::InvalidID: 3478 return "Invalid ID"; 3479 case BitcodeError::InvalidInstructionWithNoBB: 3480 return "Invalid instruction with no BB"; 3481 case BitcodeError::InvalidRecord: 3482 return "Invalid record"; 3483 case BitcodeError::InvalidTypeForValue: 3484 return "Invalid type for value"; 3485 case BitcodeError::InvalidTYPETable: 3486 return "Invalid TYPE table"; 3487 case BitcodeError::InvalidType: 3488 return "Invalid type"; 3489 case BitcodeError::MalformedBlock: 3490 return "Malformed block"; 3491 case BitcodeError::MalformedGlobalInitializerSet: 3492 return "Malformed global initializer set"; 3493 case BitcodeError::InvalidMultipleBlocks: 3494 return "Invalid multiple blocks"; 3495 case BitcodeError::NeverResolvedValueFoundInFunction: 3496 return "Never resolved value found in function"; 3497 case BitcodeError::NeverResolvedFunctionFromBlockAddress: 3498 return "Never resolved function from blockaddress"; 3499 case BitcodeError::InvalidValue: 3500 return "Invalid value"; 3501 } 3502 llvm_unreachable("Unknown error type!"); 3503 } 3504 }; 3505 } 3506 3507 static ManagedStatic<BitcodeErrorCategoryType> ErrorCategory; 3508 3509 const std::error_category &llvm::BitcodeErrorCategory() { 3510 return *ErrorCategory; 3511 } 3512 3513 //===----------------------------------------------------------------------===// 3514 // External interface 3515 //===----------------------------------------------------------------------===// 3516 3517 /// \brief Get a lazy one-at-time loading module from bitcode. 3518 /// 3519 /// This isn't always used in a lazy context. In particular, it's also used by 3520 /// \a parseBitcodeFile(). If this is truly lazy, then we need to eagerly pull 3521 /// in forward-referenced functions from block address references. 3522 /// 3523 /// \param[in] WillMaterializeAll Set to \c true if the caller promises to 3524 /// materialize everything -- in particular, if this isn't truly lazy. 3525 static ErrorOr<Module *> 3526 getLazyBitcodeModuleImpl(std::unique_ptr<MemoryBuffer> &&Buffer, 3527 LLVMContext &Context, bool WillMaterializeAll) { 3528 Module *M = new Module(Buffer->getBufferIdentifier(), Context); 3529 BitcodeReader *R = new BitcodeReader(Buffer.get(), Context); 3530 M->setMaterializer(R); 3531 3532 auto cleanupOnError = [&](std::error_code EC) { 3533 R->releaseBuffer(); // Never take ownership on error. 3534 delete M; // Also deletes R. 3535 return EC; 3536 }; 3537 3538 if (std::error_code EC = R->ParseBitcodeInto(M)) 3539 return cleanupOnError(EC); 3540 3541 if (!WillMaterializeAll) 3542 // Resolve forward references from blockaddresses. 3543 if (std::error_code EC = R->materializeForwardReferencedFunctions()) 3544 return cleanupOnError(EC); 3545 3546 Buffer.release(); // The BitcodeReader owns it now. 3547 return M; 3548 } 3549 3550 ErrorOr<Module *> 3551 llvm::getLazyBitcodeModule(std::unique_ptr<MemoryBuffer> &&Buffer, 3552 LLVMContext &Context) { 3553 return getLazyBitcodeModuleImpl(std::move(Buffer), Context, false); 3554 } 3555 3556 Module *llvm::getStreamedBitcodeModule(const std::string &name, 3557 DataStreamer *streamer, 3558 LLVMContext &Context, 3559 std::string *ErrMsg) { 3560 Module *M = new Module(name, Context); 3561 BitcodeReader *R = new BitcodeReader(streamer, Context); 3562 M->setMaterializer(R); 3563 if (std::error_code EC = R->ParseBitcodeInto(M)) { 3564 if (ErrMsg) 3565 *ErrMsg = EC.message(); 3566 delete M; // Also deletes R. 3567 return nullptr; 3568 } 3569 return M; 3570 } 3571 3572 ErrorOr<Module *> llvm::parseBitcodeFile(MemoryBufferRef Buffer, 3573 LLVMContext &Context) { 3574 std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); 3575 ErrorOr<Module *> ModuleOrErr = 3576 getLazyBitcodeModuleImpl(std::move(Buf), Context, true); 3577 if (!ModuleOrErr) 3578 return ModuleOrErr; 3579 Module *M = ModuleOrErr.get(); 3580 // Read in the entire module, and destroy the BitcodeReader. 3581 if (std::error_code EC = M->materializeAllPermanently()) { 3582 delete M; 3583 return EC; 3584 } 3585 3586 // TODO: Restore the use-lists to the in-memory state when the bitcode was 3587 // written. We must defer until the Module has been fully materialized. 3588 3589 return M; 3590 } 3591 3592 std::string llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer, 3593 LLVMContext &Context) { 3594 std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false); 3595 auto R = llvm::make_unique<BitcodeReader>(Buf.release(), Context); 3596 ErrorOr<std::string> Triple = R->parseTriple(); 3597 if (Triple.getError()) 3598 return ""; 3599 return Triple.get(); 3600 } 3601