1 //===- MetadataLoader.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 "MetadataLoader.h" 11 #include "ValueList.h" 12 13 #include "llvm/ADT/APFloat.h" 14 #include "llvm/ADT/APInt.h" 15 #include "llvm/ADT/ArrayRef.h" 16 #include "llvm/ADT/DenseMap.h" 17 #include "llvm/ADT/DenseSet.h" 18 #include "llvm/ADT/None.h" 19 #include "llvm/ADT/STLExtras.h" 20 #include "llvm/ADT/SmallString.h" 21 #include "llvm/ADT/SmallVector.h" 22 #include "llvm/ADT/Statistic.h" 23 #include "llvm/ADT/StringRef.h" 24 #include "llvm/ADT/Twine.h" 25 #include "llvm/Bitcode/BitcodeReader.h" 26 #include "llvm/Bitcode/BitstreamReader.h" 27 #include "llvm/Bitcode/LLVMBitCodes.h" 28 #include "llvm/IR/Argument.h" 29 #include "llvm/IR/Attributes.h" 30 #include "llvm/IR/AutoUpgrade.h" 31 #include "llvm/IR/BasicBlock.h" 32 #include "llvm/IR/CallingConv.h" 33 #include "llvm/IR/Comdat.h" 34 #include "llvm/IR/Constant.h" 35 #include "llvm/IR/Constants.h" 36 #include "llvm/IR/DebugInfo.h" 37 #include "llvm/IR/DebugInfoMetadata.h" 38 #include "llvm/IR/DebugLoc.h" 39 #include "llvm/IR/DerivedTypes.h" 40 #include "llvm/IR/DiagnosticPrinter.h" 41 #include "llvm/IR/Function.h" 42 #include "llvm/IR/GVMaterializer.h" 43 #include "llvm/IR/GlobalAlias.h" 44 #include "llvm/IR/GlobalIFunc.h" 45 #include "llvm/IR/GlobalIndirectSymbol.h" 46 #include "llvm/IR/GlobalObject.h" 47 #include "llvm/IR/GlobalValue.h" 48 #include "llvm/IR/GlobalVariable.h" 49 #include "llvm/IR/InlineAsm.h" 50 #include "llvm/IR/InstrTypes.h" 51 #include "llvm/IR/Instruction.h" 52 #include "llvm/IR/Instructions.h" 53 #include "llvm/IR/IntrinsicInst.h" 54 #include "llvm/IR/Intrinsics.h" 55 #include "llvm/IR/LLVMContext.h" 56 #include "llvm/IR/Module.h" 57 #include "llvm/IR/ModuleSummaryIndex.h" 58 #include "llvm/IR/OperandTraits.h" 59 #include "llvm/IR/TrackingMDRef.h" 60 #include "llvm/IR/Type.h" 61 #include "llvm/IR/ValueHandle.h" 62 #include "llvm/Support/AtomicOrdering.h" 63 #include "llvm/Support/Casting.h" 64 #include "llvm/Support/CommandLine.h" 65 #include "llvm/Support/Compiler.h" 66 #include "llvm/Support/Debug.h" 67 #include "llvm/Support/Error.h" 68 #include "llvm/Support/ErrorHandling.h" 69 #include "llvm/Support/ManagedStatic.h" 70 #include "llvm/Support/MemoryBuffer.h" 71 #include "llvm/Support/raw_ostream.h" 72 #include <algorithm> 73 #include <cassert> 74 #include <cstddef> 75 #include <cstdint> 76 #include <deque> 77 #include <limits> 78 #include <map> 79 #include <memory> 80 #include <string> 81 #include <system_error> 82 #include <tuple> 83 #include <utility> 84 #include <vector> 85 86 using namespace llvm; 87 88 #define DEBUG_TYPE "bitcode-reader" 89 90 STATISTIC(NumMDStringLoaded, "Number of MDStrings loaded"); 91 STATISTIC(NumMDNodeTemporary, "Number of MDNode::Temporary created"); 92 STATISTIC(NumMDRecordLoaded, "Number of Metadata records loaded"); 93 94 /// Flag whether we need to import full type definitions for ThinLTO. 95 /// Currently needed for Darwin and LLDB. 96 static cl::opt<bool> ImportFullTypeDefinitions( 97 "import-full-type-definitions", cl::init(false), cl::Hidden, 98 cl::desc("Import full type definitions for ThinLTO.")); 99 100 static cl::opt<bool> DisableLazyLoading( 101 "disable-ondemand-mds-loading", cl::init(false), cl::Hidden, 102 cl::desc("Force disable the lazy-loading on-demand of metadata when " 103 "loading bitcode for importing.")); 104 105 namespace { 106 107 static int64_t unrotateSign(uint64_t U) { return U & 1 ? ~(U >> 1) : U >> 1; } 108 109 class BitcodeReaderMetadataList { 110 /// Array of metadata references. 111 /// 112 /// Don't use std::vector here. Some versions of libc++ copy (instead of 113 /// move) on resize, and TrackingMDRef is very expensive to copy. 114 SmallVector<TrackingMDRef, 1> MetadataPtrs; 115 116 /// The set of indices in MetadataPtrs above of forward references that were 117 /// generated. 118 SmallDenseSet<unsigned, 1> ForwardReference; 119 120 /// The set of indices in MetadataPtrs above of Metadata that need to be 121 /// resolved. 122 SmallDenseSet<unsigned, 1> UnresolvedNodes; 123 124 /// Structures for resolving old type refs. 125 struct { 126 SmallDenseMap<MDString *, TempMDTuple, 1> Unknown; 127 SmallDenseMap<MDString *, DICompositeType *, 1> Final; 128 SmallDenseMap<MDString *, DICompositeType *, 1> FwdDecls; 129 SmallVector<std::pair<TrackingMDRef, TempMDTuple>, 1> Arrays; 130 } OldTypeRefs; 131 132 LLVMContext &Context; 133 134 public: 135 BitcodeReaderMetadataList(LLVMContext &C) : Context(C) {} 136 137 // vector compatibility methods 138 unsigned size() const { return MetadataPtrs.size(); } 139 void resize(unsigned N) { MetadataPtrs.resize(N); } 140 void push_back(Metadata *MD) { MetadataPtrs.emplace_back(MD); } 141 void clear() { MetadataPtrs.clear(); } 142 Metadata *back() const { return MetadataPtrs.back(); } 143 void pop_back() { MetadataPtrs.pop_back(); } 144 bool empty() const { return MetadataPtrs.empty(); } 145 146 Metadata *operator[](unsigned i) const { 147 assert(i < MetadataPtrs.size()); 148 return MetadataPtrs[i]; 149 } 150 151 Metadata *lookup(unsigned I) const { 152 if (I < MetadataPtrs.size()) 153 return MetadataPtrs[I]; 154 return nullptr; 155 } 156 157 void shrinkTo(unsigned N) { 158 assert(N <= size() && "Invalid shrinkTo request!"); 159 assert(ForwardReference.empty() && "Unexpected forward refs"); 160 assert(UnresolvedNodes.empty() && "Unexpected unresolved node"); 161 MetadataPtrs.resize(N); 162 } 163 164 /// Return the given metadata, creating a replaceable forward reference if 165 /// necessary. 166 Metadata *getMetadataFwdRef(unsigned Idx); 167 168 /// Return the given metadata only if it is fully resolved. 169 /// 170 /// Gives the same result as \a lookup(), unless \a MDNode::isResolved() 171 /// would give \c false. 172 Metadata *getMetadataIfResolved(unsigned Idx); 173 174 MDNode *getMDNodeFwdRefOrNull(unsigned Idx); 175 void assignValue(Metadata *MD, unsigned Idx); 176 void tryToResolveCycles(); 177 bool hasFwdRefs() const { return !ForwardReference.empty(); } 178 int getNextFwdRef() { 179 assert(hasFwdRefs()); 180 return *ForwardReference.begin(); 181 } 182 183 /// Upgrade a type that had an MDString reference. 184 void addTypeRef(MDString &UUID, DICompositeType &CT); 185 186 /// Upgrade a type that had an MDString reference. 187 Metadata *upgradeTypeRef(Metadata *MaybeUUID); 188 189 /// Upgrade a type ref array that may have MDString references. 190 Metadata *upgradeTypeRefArray(Metadata *MaybeTuple); 191 192 private: 193 Metadata *resolveTypeRefArray(Metadata *MaybeTuple); 194 }; 195 196 void BitcodeReaderMetadataList::assignValue(Metadata *MD, unsigned Idx) { 197 if (auto *MDN = dyn_cast<MDNode>(MD)) 198 if (!MDN->isResolved()) 199 UnresolvedNodes.insert(Idx); 200 201 if (Idx == size()) { 202 push_back(MD); 203 return; 204 } 205 206 if (Idx >= size()) 207 resize(Idx + 1); 208 209 TrackingMDRef &OldMD = MetadataPtrs[Idx]; 210 if (!OldMD) { 211 OldMD.reset(MD); 212 return; 213 } 214 215 // If there was a forward reference to this value, replace it. 216 TempMDTuple PrevMD(cast<MDTuple>(OldMD.get())); 217 PrevMD->replaceAllUsesWith(MD); 218 ForwardReference.erase(Idx); 219 } 220 221 Metadata *BitcodeReaderMetadataList::getMetadataFwdRef(unsigned Idx) { 222 if (Idx >= size()) 223 resize(Idx + 1); 224 225 if (Metadata *MD = MetadataPtrs[Idx]) 226 return MD; 227 228 // Track forward refs to be resolved later. 229 ForwardReference.insert(Idx); 230 231 // Create and return a placeholder, which will later be RAUW'd. 232 ++NumMDNodeTemporary; 233 Metadata *MD = MDNode::getTemporary(Context, None).release(); 234 MetadataPtrs[Idx].reset(MD); 235 return MD; 236 } 237 238 Metadata *BitcodeReaderMetadataList::getMetadataIfResolved(unsigned Idx) { 239 Metadata *MD = lookup(Idx); 240 if (auto *N = dyn_cast_or_null<MDNode>(MD)) 241 if (!N->isResolved()) 242 return nullptr; 243 return MD; 244 } 245 246 MDNode *BitcodeReaderMetadataList::getMDNodeFwdRefOrNull(unsigned Idx) { 247 return dyn_cast_or_null<MDNode>(getMetadataFwdRef(Idx)); 248 } 249 250 void BitcodeReaderMetadataList::tryToResolveCycles() { 251 if (!ForwardReference.empty()) 252 // Still forward references... can't resolve cycles. 253 return; 254 255 // Give up on finding a full definition for any forward decls that remain. 256 for (const auto &Ref : OldTypeRefs.FwdDecls) 257 OldTypeRefs.Final.insert(Ref); 258 OldTypeRefs.FwdDecls.clear(); 259 260 // Upgrade from old type ref arrays. In strange cases, this could add to 261 // OldTypeRefs.Unknown. 262 for (const auto &Array : OldTypeRefs.Arrays) 263 Array.second->replaceAllUsesWith(resolveTypeRefArray(Array.first.get())); 264 OldTypeRefs.Arrays.clear(); 265 266 // Replace old string-based type refs with the resolved node, if possible. 267 // If we haven't seen the node, leave it to the verifier to complain about 268 // the invalid string reference. 269 for (const auto &Ref : OldTypeRefs.Unknown) { 270 if (DICompositeType *CT = OldTypeRefs.Final.lookup(Ref.first)) 271 Ref.second->replaceAllUsesWith(CT); 272 else 273 Ref.second->replaceAllUsesWith(Ref.first); 274 } 275 OldTypeRefs.Unknown.clear(); 276 277 if (UnresolvedNodes.empty()) 278 // Nothing to do. 279 return; 280 281 // Resolve any cycles. 282 for (unsigned I : UnresolvedNodes) { 283 auto &MD = MetadataPtrs[I]; 284 auto *N = dyn_cast_or_null<MDNode>(MD); 285 if (!N) 286 continue; 287 288 assert(!N->isTemporary() && "Unexpected forward reference"); 289 N->resolveCycles(); 290 } 291 292 // Make sure we return early again until there's another unresolved ref. 293 UnresolvedNodes.clear(); 294 } 295 296 void BitcodeReaderMetadataList::addTypeRef(MDString &UUID, 297 DICompositeType &CT) { 298 assert(CT.getRawIdentifier() == &UUID && "Mismatched UUID"); 299 if (CT.isForwardDecl()) 300 OldTypeRefs.FwdDecls.insert(std::make_pair(&UUID, &CT)); 301 else 302 OldTypeRefs.Final.insert(std::make_pair(&UUID, &CT)); 303 } 304 305 Metadata *BitcodeReaderMetadataList::upgradeTypeRef(Metadata *MaybeUUID) { 306 auto *UUID = dyn_cast_or_null<MDString>(MaybeUUID); 307 if (LLVM_LIKELY(!UUID)) 308 return MaybeUUID; 309 310 if (auto *CT = OldTypeRefs.Final.lookup(UUID)) 311 return CT; 312 313 auto &Ref = OldTypeRefs.Unknown[UUID]; 314 if (!Ref) 315 Ref = MDNode::getTemporary(Context, None); 316 return Ref.get(); 317 } 318 319 Metadata *BitcodeReaderMetadataList::upgradeTypeRefArray(Metadata *MaybeTuple) { 320 auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple); 321 if (!Tuple || Tuple->isDistinct()) 322 return MaybeTuple; 323 324 // Look through the array immediately if possible. 325 if (!Tuple->isTemporary()) 326 return resolveTypeRefArray(Tuple); 327 328 // Create and return a placeholder to use for now. Eventually 329 // resolveTypeRefArrays() will be resolve this forward reference. 330 OldTypeRefs.Arrays.emplace_back( 331 std::piecewise_construct, std::forward_as_tuple(Tuple), 332 std::forward_as_tuple(MDTuple::getTemporary(Context, None))); 333 return OldTypeRefs.Arrays.back().second.get(); 334 } 335 336 Metadata *BitcodeReaderMetadataList::resolveTypeRefArray(Metadata *MaybeTuple) { 337 auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple); 338 if (!Tuple || Tuple->isDistinct()) 339 return MaybeTuple; 340 341 // Look through the DITypeRefArray, upgrading each DITypeRef. 342 SmallVector<Metadata *, 32> Ops; 343 Ops.reserve(Tuple->getNumOperands()); 344 for (Metadata *MD : Tuple->operands()) 345 Ops.push_back(upgradeTypeRef(MD)); 346 347 return MDTuple::get(Context, Ops); 348 } 349 350 namespace { 351 352 class PlaceholderQueue { 353 // Placeholders would thrash around when moved, so store in a std::deque 354 // instead of some sort of vector. 355 std::deque<DistinctMDOperandPlaceholder> PHs; 356 357 public: 358 ~PlaceholderQueue() { 359 assert(empty() && "PlaceholderQueue hasn't been flushed before being destroyed"); 360 } 361 bool empty() { return PHs.empty(); } 362 DistinctMDOperandPlaceholder &getPlaceholderOp(unsigned ID); 363 void flush(BitcodeReaderMetadataList &MetadataList); 364 365 /// Return the list of temporaries nodes in the queue, these need to be 366 /// loaded before we can flush the queue. 367 void getTemporaries(BitcodeReaderMetadataList &MetadataList, 368 DenseSet<unsigned> &Temporaries) { 369 for (auto &PH : PHs) { 370 auto ID = PH.getID(); 371 auto *MD = MetadataList.lookup(ID); 372 if (!MD) { 373 Temporaries.insert(ID); 374 continue; 375 } 376 auto *N = dyn_cast_or_null<MDNode>(MD); 377 if (N && N->isTemporary()) 378 Temporaries.insert(ID); 379 } 380 } 381 }; 382 383 } // end anonymous namespace 384 385 DistinctMDOperandPlaceholder &PlaceholderQueue::getPlaceholderOp(unsigned ID) { 386 PHs.emplace_back(ID); 387 return PHs.back(); 388 } 389 390 void PlaceholderQueue::flush(BitcodeReaderMetadataList &MetadataList) { 391 while (!PHs.empty()) { 392 auto *MD = MetadataList.lookup(PHs.front().getID()); 393 assert(MD && "Flushing placeholder on unassigned MD"); 394 #ifndef NDEBUG 395 if (auto *MDN = dyn_cast<MDNode>(MD)) 396 assert(MDN->isResolved() && 397 "Flushing Placeholder while cycles aren't resolved"); 398 #endif 399 PHs.front().replaceUseWith(MD); 400 PHs.pop_front(); 401 } 402 } 403 404 } // anonynous namespace 405 406 static Error error(const Twine &Message) { 407 return make_error<StringError>( 408 Message, make_error_code(BitcodeError::CorruptedBitcode)); 409 } 410 411 class MetadataLoader::MetadataLoaderImpl { 412 BitcodeReaderMetadataList MetadataList; 413 BitcodeReaderValueList &ValueList; 414 BitstreamCursor &Stream; 415 LLVMContext &Context; 416 Module &TheModule; 417 std::function<Type *(unsigned)> getTypeByID; 418 419 /// Cursor associated with the lazy-loading of Metadata. This is the easy way 420 /// to keep around the right "context" (Abbrev list) to be able to jump in 421 /// the middle of the metadata block and load any record. 422 BitstreamCursor IndexCursor; 423 424 /// Index that keeps track of MDString values. 425 std::vector<StringRef> MDStringRef; 426 427 /// On-demand loading of a single MDString. Requires the index above to be 428 /// populated. 429 MDString *lazyLoadOneMDString(unsigned Idx); 430 431 /// Index that keeps track of where to find a metadata record in the stream. 432 std::vector<uint64_t> GlobalMetadataBitPosIndex; 433 434 /// Populate the index above to enable lazily loading of metadata, and load 435 /// the named metadata as well as the transitively referenced global 436 /// Metadata. 437 Expected<bool> lazyLoadModuleMetadataBlock(); 438 439 /// On-demand loading of a single metadata. Requires the index above to be 440 /// populated. 441 void lazyLoadOneMetadata(unsigned Idx, PlaceholderQueue &Placeholders); 442 443 // Keep mapping of seens pair of old-style CU <-> SP, and update pointers to 444 // point from SP to CU after a block is completly parsed. 445 std::vector<std::pair<DICompileUnit *, Metadata *>> CUSubprograms; 446 447 /// Functions that need to be matched with subprograms when upgrading old 448 /// metadata. 449 SmallDenseMap<Function *, DISubprogram *, 16> FunctionsWithSPs; 450 451 // Map the bitcode's custom MDKind ID to the Module's MDKind ID. 452 DenseMap<unsigned, unsigned> MDKindMap; 453 454 bool StripTBAA = false; 455 bool HasSeenOldLoopTags = false; 456 bool NeedUpgradeToDIGlobalVariableExpression = false; 457 bool NeedDeclareExpressionUpgrade = false; 458 459 /// True if metadata is being parsed for a module being ThinLTO imported. 460 bool IsImporting = false; 461 462 Error parseOneMetadata(SmallVectorImpl<uint64_t> &Record, unsigned Code, 463 PlaceholderQueue &Placeholders, StringRef Blob, 464 unsigned &NextMetadataNo); 465 Error parseMetadataStrings(ArrayRef<uint64_t> Record, StringRef Blob, 466 function_ref<void(StringRef)> CallBack); 467 Error parseGlobalObjectAttachment(GlobalObject &GO, 468 ArrayRef<uint64_t> Record); 469 Error parseMetadataKindRecord(SmallVectorImpl<uint64_t> &Record); 470 471 void resolveForwardRefsAndPlaceholders(PlaceholderQueue &Placeholders); 472 473 /// Upgrade old-style CU <-> SP pointers to point from SP to CU. 474 void upgradeCUSubprograms() { 475 for (auto CU_SP : CUSubprograms) 476 if (auto *SPs = dyn_cast_or_null<MDTuple>(CU_SP.second)) 477 for (auto &Op : SPs->operands()) 478 if (auto *SP = dyn_cast_or_null<DISubprogram>(Op)) 479 SP->replaceUnit(CU_SP.first); 480 CUSubprograms.clear(); 481 } 482 483 /// Upgrade old-style bare DIGlobalVariables to DIGlobalVariableExpressions. 484 void upgradeCUVariables() { 485 if (!NeedUpgradeToDIGlobalVariableExpression) 486 return; 487 488 // Upgrade list of variables attached to the CUs. 489 if (NamedMDNode *CUNodes = TheModule.getNamedMetadata("llvm.dbg.cu")) 490 for (unsigned I = 0, E = CUNodes->getNumOperands(); I != E; ++I) { 491 auto *CU = cast<DICompileUnit>(CUNodes->getOperand(I)); 492 if (auto *GVs = dyn_cast_or_null<MDTuple>(CU->getRawGlobalVariables())) 493 for (unsigned I = 0; I < GVs->getNumOperands(); I++) 494 if (auto *GV = 495 dyn_cast_or_null<DIGlobalVariable>(GVs->getOperand(I))) { 496 auto *DGVE = DIGlobalVariableExpression::getDistinct( 497 Context, GV, DIExpression::get(Context, {})); 498 GVs->replaceOperandWith(I, DGVE); 499 } 500 } 501 502 // Upgrade variables attached to globals. 503 for (auto &GV : TheModule.globals()) { 504 SmallVector<MDNode *, 1> MDs; 505 GV.getMetadata(LLVMContext::MD_dbg, MDs); 506 GV.eraseMetadata(LLVMContext::MD_dbg); 507 for (auto *MD : MDs) 508 if (auto *DGV = dyn_cast_or_null<DIGlobalVariable>(MD)) { 509 auto *DGVE = DIGlobalVariableExpression::getDistinct( 510 Context, DGV, DIExpression::get(Context, {})); 511 GV.addMetadata(LLVMContext::MD_dbg, *DGVE); 512 } else 513 GV.addMetadata(LLVMContext::MD_dbg, *MD); 514 } 515 } 516 517 /// Remove a leading DW_OP_deref from DIExpressions in a dbg.declare that 518 /// describes a function argument. 519 void upgradeDeclareExpressions(Function &F) { 520 if (!NeedDeclareExpressionUpgrade) 521 return; 522 523 for (auto &BB : F) 524 for (auto &I : BB) 525 if (auto *DDI = dyn_cast<DbgDeclareInst>(&I)) 526 if (auto *DIExpr = DDI->getExpression()) 527 if (DIExpr->startsWithDeref() && 528 dyn_cast_or_null<Argument>(DDI->getAddress())) { 529 SmallVector<uint64_t, 8> Ops; 530 Ops.append(std::next(DIExpr->elements_begin()), 531 DIExpr->elements_end()); 532 auto *E = DIExpression::get(Context, Ops); 533 DDI->setOperand(2, MetadataAsValue::get(Context, E)); 534 } 535 } 536 537 /// Upgrade the expression from previous versions. 538 Error upgradeDIExpression(uint64_t FromVersion, 539 MutableArrayRef<uint64_t> &Expr, 540 SmallVectorImpl<uint64_t> &Buffer) { 541 auto N = Expr.size(); 542 switch (FromVersion) { 543 default: 544 return error("Invalid record"); 545 case 0: 546 if (N >= 3 && Expr[N - 3] == dwarf::DW_OP_bit_piece) 547 Expr[N - 3] = dwarf::DW_OP_LLVM_fragment; 548 LLVM_FALLTHROUGH; 549 case 1: 550 // Move DW_OP_deref to the end. 551 if (N && Expr[0] == dwarf::DW_OP_deref) { 552 auto End = Expr.end(); 553 if (Expr.size() >= 3 && 554 *std::prev(End, 3) == dwarf::DW_OP_LLVM_fragment) 555 End = std::prev(End, 3); 556 std::move(std::next(Expr.begin()), End, Expr.begin()); 557 *std::prev(End) = dwarf::DW_OP_deref; 558 } 559 NeedDeclareExpressionUpgrade = true; 560 LLVM_FALLTHROUGH; 561 case 2: { 562 // Change DW_OP_plus to DW_OP_plus_uconst. 563 // Change DW_OP_minus to DW_OP_uconst, DW_OP_minus 564 auto SubExpr = ArrayRef<uint64_t>(Expr); 565 while (!SubExpr.empty()) { 566 // Skip past other operators with their operands 567 // for this version of the IR, obtained from 568 // from historic DIExpression::ExprOperand::getSize(). 569 size_t HistoricSize; 570 switch (SubExpr.front()) { 571 default: 572 HistoricSize = 1; 573 break; 574 case dwarf::DW_OP_constu: 575 case dwarf::DW_OP_minus: 576 case dwarf::DW_OP_plus: 577 HistoricSize = 2; 578 break; 579 case dwarf::DW_OP_LLVM_fragment: 580 HistoricSize = 3; 581 break; 582 } 583 584 // If the expression is malformed, make sure we don't 585 // copy more elements than we should. 586 HistoricSize = std::min(SubExpr.size(), HistoricSize); 587 ArrayRef<uint64_t> Args = SubExpr.slice(1, HistoricSize-1); 588 589 switch (SubExpr.front()) { 590 case dwarf::DW_OP_plus: 591 Buffer.push_back(dwarf::DW_OP_plus_uconst); 592 Buffer.append(Args.begin(), Args.end()); 593 break; 594 case dwarf::DW_OP_minus: 595 Buffer.push_back(dwarf::DW_OP_constu); 596 Buffer.append(Args.begin(), Args.end()); 597 Buffer.push_back(dwarf::DW_OP_minus); 598 break; 599 default: 600 Buffer.push_back(*SubExpr.begin()); 601 Buffer.append(Args.begin(), Args.end()); 602 break; 603 } 604 605 // Continue with remaining elements. 606 SubExpr = SubExpr.slice(HistoricSize); 607 } 608 Expr = MutableArrayRef<uint64_t>(Buffer); 609 LLVM_FALLTHROUGH; 610 } 611 case 3: 612 // Up-to-date! 613 break; 614 } 615 616 return Error::success(); 617 } 618 619 void upgradeDebugInfo() { 620 upgradeCUSubprograms(); 621 upgradeCUVariables(); 622 } 623 624 public: 625 MetadataLoaderImpl(BitstreamCursor &Stream, Module &TheModule, 626 BitcodeReaderValueList &ValueList, 627 std::function<Type *(unsigned)> getTypeByID, 628 bool IsImporting) 629 : MetadataList(TheModule.getContext()), ValueList(ValueList), 630 Stream(Stream), Context(TheModule.getContext()), TheModule(TheModule), 631 getTypeByID(std::move(getTypeByID)), IsImporting(IsImporting) {} 632 633 Error parseMetadata(bool ModuleLevel); 634 635 bool hasFwdRefs() const { return MetadataList.hasFwdRefs(); } 636 637 Metadata *getMetadataFwdRefOrLoad(unsigned ID) { 638 if (ID < MDStringRef.size()) 639 return lazyLoadOneMDString(ID); 640 if (auto *MD = MetadataList.lookup(ID)) 641 return MD; 642 // If lazy-loading is enabled, we try recursively to load the operand 643 // instead of creating a temporary. 644 if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) { 645 PlaceholderQueue Placeholders; 646 lazyLoadOneMetadata(ID, Placeholders); 647 resolveForwardRefsAndPlaceholders(Placeholders); 648 return MetadataList.lookup(ID); 649 } 650 return MetadataList.getMetadataFwdRef(ID); 651 } 652 653 MDNode *getMDNodeFwdRefOrNull(unsigned Idx) { 654 return MetadataList.getMDNodeFwdRefOrNull(Idx); 655 } 656 657 DISubprogram *lookupSubprogramForFunction(Function *F) { 658 return FunctionsWithSPs.lookup(F); 659 } 660 661 bool hasSeenOldLoopTags() { return HasSeenOldLoopTags; } 662 663 Error parseMetadataAttachment( 664 Function &F, const SmallVectorImpl<Instruction *> &InstructionList); 665 666 Error parseMetadataKinds(); 667 668 void setStripTBAA(bool Value) { StripTBAA = Value; } 669 bool isStrippingTBAA() { return StripTBAA; } 670 671 unsigned size() const { return MetadataList.size(); } 672 void shrinkTo(unsigned N) { MetadataList.shrinkTo(N); } 673 void upgradeDebugIntrinsics(Function &F) { upgradeDeclareExpressions(F); } 674 }; 675 676 Expected<bool> 677 MetadataLoader::MetadataLoaderImpl::lazyLoadModuleMetadataBlock() { 678 IndexCursor = Stream; 679 SmallVector<uint64_t, 64> Record; 680 // Get the abbrevs, and preload record positions to make them lazy-loadable. 681 while (true) { 682 BitstreamEntry Entry = IndexCursor.advanceSkippingSubblocks( 683 BitstreamCursor::AF_DontPopBlockAtEnd); 684 switch (Entry.Kind) { 685 case BitstreamEntry::SubBlock: // Handled for us already. 686 case BitstreamEntry::Error: 687 return error("Malformed block"); 688 case BitstreamEntry::EndBlock: { 689 return true; 690 } 691 case BitstreamEntry::Record: { 692 // The interesting case. 693 ++NumMDRecordLoaded; 694 uint64_t CurrentPos = IndexCursor.GetCurrentBitNo(); 695 auto Code = IndexCursor.skipRecord(Entry.ID); 696 switch (Code) { 697 case bitc::METADATA_STRINGS: { 698 // Rewind and parse the strings. 699 IndexCursor.JumpToBit(CurrentPos); 700 StringRef Blob; 701 Record.clear(); 702 IndexCursor.readRecord(Entry.ID, Record, &Blob); 703 unsigned NumStrings = Record[0]; 704 MDStringRef.reserve(NumStrings); 705 auto IndexNextMDString = [&](StringRef Str) { 706 MDStringRef.push_back(Str); 707 }; 708 if (auto Err = parseMetadataStrings(Record, Blob, IndexNextMDString)) 709 return std::move(Err); 710 break; 711 } 712 case bitc::METADATA_INDEX_OFFSET: { 713 // This is the offset to the index, when we see this we skip all the 714 // records and load only an index to these. 715 IndexCursor.JumpToBit(CurrentPos); 716 Record.clear(); 717 IndexCursor.readRecord(Entry.ID, Record); 718 if (Record.size() != 2) 719 return error("Invalid record"); 720 auto Offset = Record[0] + (Record[1] << 32); 721 auto BeginPos = IndexCursor.GetCurrentBitNo(); 722 IndexCursor.JumpToBit(BeginPos + Offset); 723 Entry = IndexCursor.advanceSkippingSubblocks( 724 BitstreamCursor::AF_DontPopBlockAtEnd); 725 assert(Entry.Kind == BitstreamEntry::Record && 726 "Corrupted bitcode: Expected `Record` when trying to find the " 727 "Metadata index"); 728 Record.clear(); 729 auto Code = IndexCursor.readRecord(Entry.ID, Record); 730 (void)Code; 731 assert(Code == bitc::METADATA_INDEX && "Corrupted bitcode: Expected " 732 "`METADATA_INDEX` when trying " 733 "to find the Metadata index"); 734 735 // Delta unpack 736 auto CurrentValue = BeginPos; 737 GlobalMetadataBitPosIndex.reserve(Record.size()); 738 for (auto &Elt : Record) { 739 CurrentValue += Elt; 740 GlobalMetadataBitPosIndex.push_back(CurrentValue); 741 } 742 break; 743 } 744 case bitc::METADATA_INDEX: 745 // We don't expect to get there, the Index is loaded when we encounter 746 // the offset. 747 return error("Corrupted Metadata block"); 748 case bitc::METADATA_NAME: { 749 // Named metadata need to be materialized now and aren't deferred. 750 IndexCursor.JumpToBit(CurrentPos); 751 Record.clear(); 752 unsigned Code = IndexCursor.readRecord(Entry.ID, Record); 753 assert(Code == bitc::METADATA_NAME); 754 755 // Read name of the named metadata. 756 SmallString<8> Name(Record.begin(), Record.end()); 757 Code = IndexCursor.ReadCode(); 758 759 // Named Metadata comes in two parts, we expect the name to be followed 760 // by the node 761 Record.clear(); 762 unsigned NextBitCode = IndexCursor.readRecord(Code, Record); 763 assert(NextBitCode == bitc::METADATA_NAMED_NODE); 764 (void)NextBitCode; 765 766 // Read named metadata elements. 767 unsigned Size = Record.size(); 768 NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name); 769 for (unsigned i = 0; i != Size; ++i) { 770 // FIXME: We could use a placeholder here, however NamedMDNode are 771 // taking MDNode as operand and not using the Metadata infrastructure. 772 // It is acknowledged by 'TODO: Inherit from Metadata' in the 773 // NamedMDNode class definition. 774 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]); 775 assert(MD && "Invalid record"); 776 NMD->addOperand(MD); 777 } 778 break; 779 } 780 case bitc::METADATA_GLOBAL_DECL_ATTACHMENT: { 781 // FIXME: we need to do this early because we don't materialize global 782 // value explicitly. 783 IndexCursor.JumpToBit(CurrentPos); 784 Record.clear(); 785 IndexCursor.readRecord(Entry.ID, Record); 786 if (Record.size() % 2 == 0) 787 return error("Invalid record"); 788 unsigned ValueID = Record[0]; 789 if (ValueID >= ValueList.size()) 790 return error("Invalid record"); 791 if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID])) 792 if (Error Err = parseGlobalObjectAttachment( 793 *GO, ArrayRef<uint64_t>(Record).slice(1))) 794 return std::move(Err); 795 break; 796 } 797 case bitc::METADATA_KIND: 798 case bitc::METADATA_STRING_OLD: 799 case bitc::METADATA_OLD_FN_NODE: 800 case bitc::METADATA_OLD_NODE: 801 case bitc::METADATA_VALUE: 802 case bitc::METADATA_DISTINCT_NODE: 803 case bitc::METADATA_NODE: 804 case bitc::METADATA_LOCATION: 805 case bitc::METADATA_GENERIC_DEBUG: 806 case bitc::METADATA_SUBRANGE: 807 case bitc::METADATA_ENUMERATOR: 808 case bitc::METADATA_BASIC_TYPE: 809 case bitc::METADATA_DERIVED_TYPE: 810 case bitc::METADATA_COMPOSITE_TYPE: 811 case bitc::METADATA_SUBROUTINE_TYPE: 812 case bitc::METADATA_MODULE: 813 case bitc::METADATA_FILE: 814 case bitc::METADATA_COMPILE_UNIT: 815 case bitc::METADATA_SUBPROGRAM: 816 case bitc::METADATA_LEXICAL_BLOCK: 817 case bitc::METADATA_LEXICAL_BLOCK_FILE: 818 case bitc::METADATA_NAMESPACE: 819 case bitc::METADATA_MACRO: 820 case bitc::METADATA_MACRO_FILE: 821 case bitc::METADATA_TEMPLATE_TYPE: 822 case bitc::METADATA_TEMPLATE_VALUE: 823 case bitc::METADATA_GLOBAL_VAR: 824 case bitc::METADATA_LOCAL_VAR: 825 case bitc::METADATA_LABEL: 826 case bitc::METADATA_EXPRESSION: 827 case bitc::METADATA_OBJC_PROPERTY: 828 case bitc::METADATA_IMPORTED_ENTITY: 829 case bitc::METADATA_GLOBAL_VAR_EXPR: 830 // We don't expect to see any of these, if we see one, give up on 831 // lazy-loading and fallback. 832 MDStringRef.clear(); 833 GlobalMetadataBitPosIndex.clear(); 834 return false; 835 } 836 break; 837 } 838 } 839 } 840 } 841 842 /// Parse a METADATA_BLOCK. If ModuleLevel is true then we are parsing 843 /// module level metadata. 844 Error MetadataLoader::MetadataLoaderImpl::parseMetadata(bool ModuleLevel) { 845 if (!ModuleLevel && MetadataList.hasFwdRefs()) 846 return error("Invalid metadata: fwd refs into function blocks"); 847 848 // Record the entry position so that we can jump back here and efficiently 849 // skip the whole block in case we lazy-load. 850 auto EntryPos = Stream.GetCurrentBitNo(); 851 852 if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) 853 return error("Invalid record"); 854 855 SmallVector<uint64_t, 64> Record; 856 PlaceholderQueue Placeholders; 857 858 // We lazy-load module-level metadata: we build an index for each record, and 859 // then load individual record as needed, starting with the named metadata. 860 if (ModuleLevel && IsImporting && MetadataList.empty() && 861 !DisableLazyLoading) { 862 auto SuccessOrErr = lazyLoadModuleMetadataBlock(); 863 if (!SuccessOrErr) 864 return SuccessOrErr.takeError(); 865 if (SuccessOrErr.get()) { 866 // An index was successfully created and we will be able to load metadata 867 // on-demand. 868 MetadataList.resize(MDStringRef.size() + 869 GlobalMetadataBitPosIndex.size()); 870 871 // Reading the named metadata created forward references and/or 872 // placeholders, that we flush here. 873 resolveForwardRefsAndPlaceholders(Placeholders); 874 upgradeDebugInfo(); 875 // Return at the beginning of the block, since it is easy to skip it 876 // entirely from there. 877 Stream.ReadBlockEnd(); // Pop the abbrev block context. 878 Stream.JumpToBit(EntryPos); 879 if (Stream.SkipBlock()) 880 return error("Invalid record"); 881 return Error::success(); 882 } 883 // Couldn't load an index, fallback to loading all the block "old-style". 884 } 885 886 unsigned NextMetadataNo = MetadataList.size(); 887 888 // Read all the records. 889 while (true) { 890 BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 891 892 switch (Entry.Kind) { 893 case BitstreamEntry::SubBlock: // Handled for us already. 894 case BitstreamEntry::Error: 895 return error("Malformed block"); 896 case BitstreamEntry::EndBlock: 897 resolveForwardRefsAndPlaceholders(Placeholders); 898 upgradeDebugInfo(); 899 return Error::success(); 900 case BitstreamEntry::Record: 901 // The interesting case. 902 break; 903 } 904 905 // Read a record. 906 Record.clear(); 907 StringRef Blob; 908 ++NumMDRecordLoaded; 909 unsigned Code = Stream.readRecord(Entry.ID, Record, &Blob); 910 if (Error Err = 911 parseOneMetadata(Record, Code, Placeholders, Blob, NextMetadataNo)) 912 return Err; 913 } 914 } 915 916 MDString *MetadataLoader::MetadataLoaderImpl::lazyLoadOneMDString(unsigned ID) { 917 ++NumMDStringLoaded; 918 if (Metadata *MD = MetadataList.lookup(ID)) 919 return cast<MDString>(MD); 920 auto MDS = MDString::get(Context, MDStringRef[ID]); 921 MetadataList.assignValue(MDS, ID); 922 return MDS; 923 } 924 925 void MetadataLoader::MetadataLoaderImpl::lazyLoadOneMetadata( 926 unsigned ID, PlaceholderQueue &Placeholders) { 927 assert(ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size()); 928 assert(ID >= MDStringRef.size() && "Unexpected lazy-loading of MDString"); 929 // Lookup first if the metadata hasn't already been loaded. 930 if (auto *MD = MetadataList.lookup(ID)) { 931 auto *N = dyn_cast_or_null<MDNode>(MD); 932 if (!N->isTemporary()) 933 return; 934 } 935 SmallVector<uint64_t, 64> Record; 936 StringRef Blob; 937 IndexCursor.JumpToBit(GlobalMetadataBitPosIndex[ID - MDStringRef.size()]); 938 auto Entry = IndexCursor.advanceSkippingSubblocks(); 939 ++NumMDRecordLoaded; 940 unsigned Code = IndexCursor.readRecord(Entry.ID, Record, &Blob); 941 if (Error Err = parseOneMetadata(Record, Code, Placeholders, Blob, ID)) 942 report_fatal_error("Can't lazyload MD"); 943 } 944 945 /// Ensure that all forward-references and placeholders are resolved. 946 /// Iteratively lazy-loading metadata on-demand if needed. 947 void MetadataLoader::MetadataLoaderImpl::resolveForwardRefsAndPlaceholders( 948 PlaceholderQueue &Placeholders) { 949 DenseSet<unsigned> Temporaries; 950 while (1) { 951 // Populate Temporaries with the placeholders that haven't been loaded yet. 952 Placeholders.getTemporaries(MetadataList, Temporaries); 953 954 // If we don't have any temporary, or FwdReference, we're done! 955 if (Temporaries.empty() && !MetadataList.hasFwdRefs()) 956 break; 957 958 // First, load all the temporaries. This can add new placeholders or 959 // forward references. 960 for (auto ID : Temporaries) 961 lazyLoadOneMetadata(ID, Placeholders); 962 Temporaries.clear(); 963 964 // Second, load the forward-references. This can also add new placeholders 965 // or forward references. 966 while (MetadataList.hasFwdRefs()) 967 lazyLoadOneMetadata(MetadataList.getNextFwdRef(), Placeholders); 968 } 969 // At this point we don't have any forward reference remaining, or temporary 970 // that haven't been loaded. We can safely drop RAUW support and mark cycles 971 // as resolved. 972 MetadataList.tryToResolveCycles(); 973 974 // Finally, everything is in place, we can replace the placeholders operands 975 // with the final node they refer to. 976 Placeholders.flush(MetadataList); 977 } 978 979 Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata( 980 SmallVectorImpl<uint64_t> &Record, unsigned Code, 981 PlaceholderQueue &Placeholders, StringRef Blob, unsigned &NextMetadataNo) { 982 983 bool IsDistinct = false; 984 auto getMD = [&](unsigned ID) -> Metadata * { 985 if (ID < MDStringRef.size()) 986 return lazyLoadOneMDString(ID); 987 if (!IsDistinct) { 988 if (auto *MD = MetadataList.lookup(ID)) 989 return MD; 990 // If lazy-loading is enabled, we try recursively to load the operand 991 // instead of creating a temporary. 992 if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) { 993 // Create a temporary for the node that is referencing the operand we 994 // will lazy-load. It is needed before recursing in case there are 995 // uniquing cycles. 996 MetadataList.getMetadataFwdRef(NextMetadataNo); 997 lazyLoadOneMetadata(ID, Placeholders); 998 return MetadataList.lookup(ID); 999 } 1000 // Return a temporary. 1001 return MetadataList.getMetadataFwdRef(ID); 1002 } 1003 if (auto *MD = MetadataList.getMetadataIfResolved(ID)) 1004 return MD; 1005 return &Placeholders.getPlaceholderOp(ID); 1006 }; 1007 auto getMDOrNull = [&](unsigned ID) -> Metadata * { 1008 if (ID) 1009 return getMD(ID - 1); 1010 return nullptr; 1011 }; 1012 auto getMDOrNullWithoutPlaceholders = [&](unsigned ID) -> Metadata * { 1013 if (ID) 1014 return MetadataList.getMetadataFwdRef(ID - 1); 1015 return nullptr; 1016 }; 1017 auto getMDString = [&](unsigned ID) -> MDString * { 1018 // This requires that the ID is not really a forward reference. In 1019 // particular, the MDString must already have been resolved. 1020 auto MDS = getMDOrNull(ID); 1021 return cast_or_null<MDString>(MDS); 1022 }; 1023 1024 // Support for old type refs. 1025 auto getDITypeRefOrNull = [&](unsigned ID) { 1026 return MetadataList.upgradeTypeRef(getMDOrNull(ID)); 1027 }; 1028 1029 #define GET_OR_DISTINCT(CLASS, ARGS) \ 1030 (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS) 1031 1032 switch (Code) { 1033 default: // Default behavior: ignore. 1034 break; 1035 case bitc::METADATA_NAME: { 1036 // Read name of the named metadata. 1037 SmallString<8> Name(Record.begin(), Record.end()); 1038 Record.clear(); 1039 Code = Stream.ReadCode(); 1040 1041 ++NumMDRecordLoaded; 1042 unsigned NextBitCode = Stream.readRecord(Code, Record); 1043 if (NextBitCode != bitc::METADATA_NAMED_NODE) 1044 return error("METADATA_NAME not followed by METADATA_NAMED_NODE"); 1045 1046 // Read named metadata elements. 1047 unsigned Size = Record.size(); 1048 NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name); 1049 for (unsigned i = 0; i != Size; ++i) { 1050 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]); 1051 if (!MD) 1052 return error("Invalid record"); 1053 NMD->addOperand(MD); 1054 } 1055 break; 1056 } 1057 case bitc::METADATA_OLD_FN_NODE: { 1058 // FIXME: Remove in 4.0. 1059 // This is a LocalAsMetadata record, the only type of function-local 1060 // metadata. 1061 if (Record.size() % 2 == 1) 1062 return error("Invalid record"); 1063 1064 // If this isn't a LocalAsMetadata record, we're dropping it. This used 1065 // to be legal, but there's no upgrade path. 1066 auto dropRecord = [&] { 1067 MetadataList.assignValue(MDNode::get(Context, None), NextMetadataNo); 1068 NextMetadataNo++; 1069 }; 1070 if (Record.size() != 2) { 1071 dropRecord(); 1072 break; 1073 } 1074 1075 Type *Ty = getTypeByID(Record[0]); 1076 if (Ty->isMetadataTy() || Ty->isVoidTy()) { 1077 dropRecord(); 1078 break; 1079 } 1080 1081 MetadataList.assignValue( 1082 LocalAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)), 1083 NextMetadataNo); 1084 NextMetadataNo++; 1085 break; 1086 } 1087 case bitc::METADATA_OLD_NODE: { 1088 // FIXME: Remove in 4.0. 1089 if (Record.size() % 2 == 1) 1090 return error("Invalid record"); 1091 1092 unsigned Size = Record.size(); 1093 SmallVector<Metadata *, 8> Elts; 1094 for (unsigned i = 0; i != Size; i += 2) { 1095 Type *Ty = getTypeByID(Record[i]); 1096 if (!Ty) 1097 return error("Invalid record"); 1098 if (Ty->isMetadataTy()) 1099 Elts.push_back(getMD(Record[i + 1])); 1100 else if (!Ty->isVoidTy()) { 1101 auto *MD = 1102 ValueAsMetadata::get(ValueList.getValueFwdRef(Record[i + 1], Ty)); 1103 assert(isa<ConstantAsMetadata>(MD) && 1104 "Expected non-function-local metadata"); 1105 Elts.push_back(MD); 1106 } else 1107 Elts.push_back(nullptr); 1108 } 1109 MetadataList.assignValue(MDNode::get(Context, Elts), NextMetadataNo); 1110 NextMetadataNo++; 1111 break; 1112 } 1113 case bitc::METADATA_VALUE: { 1114 if (Record.size() != 2) 1115 return error("Invalid record"); 1116 1117 Type *Ty = getTypeByID(Record[0]); 1118 if (Ty->isMetadataTy() || Ty->isVoidTy()) 1119 return error("Invalid record"); 1120 1121 MetadataList.assignValue( 1122 ValueAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)), 1123 NextMetadataNo); 1124 NextMetadataNo++; 1125 break; 1126 } 1127 case bitc::METADATA_DISTINCT_NODE: 1128 IsDistinct = true; 1129 LLVM_FALLTHROUGH; 1130 case bitc::METADATA_NODE: { 1131 SmallVector<Metadata *, 8> Elts; 1132 Elts.reserve(Record.size()); 1133 for (unsigned ID : Record) 1134 Elts.push_back(getMDOrNull(ID)); 1135 MetadataList.assignValue(IsDistinct ? MDNode::getDistinct(Context, Elts) 1136 : MDNode::get(Context, Elts), 1137 NextMetadataNo); 1138 NextMetadataNo++; 1139 break; 1140 } 1141 case bitc::METADATA_LOCATION: { 1142 if (Record.size() != 5) 1143 return error("Invalid record"); 1144 1145 IsDistinct = Record[0]; 1146 unsigned Line = Record[1]; 1147 unsigned Column = Record[2]; 1148 Metadata *Scope = getMD(Record[3]); 1149 Metadata *InlinedAt = getMDOrNull(Record[4]); 1150 MetadataList.assignValue( 1151 GET_OR_DISTINCT(DILocation, (Context, Line, Column, Scope, InlinedAt)), 1152 NextMetadataNo); 1153 NextMetadataNo++; 1154 break; 1155 } 1156 case bitc::METADATA_GENERIC_DEBUG: { 1157 if (Record.size() < 4) 1158 return error("Invalid record"); 1159 1160 IsDistinct = Record[0]; 1161 unsigned Tag = Record[1]; 1162 unsigned Version = Record[2]; 1163 1164 if (Tag >= 1u << 16 || Version != 0) 1165 return error("Invalid record"); 1166 1167 auto *Header = getMDString(Record[3]); 1168 SmallVector<Metadata *, 8> DwarfOps; 1169 for (unsigned I = 4, E = Record.size(); I != E; ++I) 1170 DwarfOps.push_back(getMDOrNull(Record[I])); 1171 MetadataList.assignValue( 1172 GET_OR_DISTINCT(GenericDINode, (Context, Tag, Header, DwarfOps)), 1173 NextMetadataNo); 1174 NextMetadataNo++; 1175 break; 1176 } 1177 case bitc::METADATA_SUBRANGE: { 1178 Metadata *Val = nullptr; 1179 // Operand 'count' is interpreted as: 1180 // - Signed integer (version 0) 1181 // - Metadata node (version 1) 1182 switch (Record[0] >> 1) { 1183 case 0: 1184 Val = GET_OR_DISTINCT(DISubrange, 1185 (Context, Record[1], unrotateSign(Record.back()))); 1186 break; 1187 case 1: 1188 Val = GET_OR_DISTINCT(DISubrange, (Context, getMDOrNull(Record[1]), 1189 unrotateSign(Record.back()))); 1190 break; 1191 default: 1192 return error("Invalid record: Unsupported version of DISubrange"); 1193 } 1194 1195 MetadataList.assignValue(Val, NextMetadataNo); 1196 IsDistinct = Record[0] & 1; 1197 NextMetadataNo++; 1198 break; 1199 } 1200 case bitc::METADATA_ENUMERATOR: { 1201 if (Record.size() != 3) 1202 return error("Invalid record"); 1203 1204 IsDistinct = Record[0] & 1; 1205 bool IsUnsigned = Record[0] & 2; 1206 MetadataList.assignValue( 1207 GET_OR_DISTINCT(DIEnumerator, (Context, unrotateSign(Record[1]), 1208 IsUnsigned, getMDString(Record[2]))), 1209 NextMetadataNo); 1210 NextMetadataNo++; 1211 break; 1212 } 1213 case bitc::METADATA_BASIC_TYPE: { 1214 if (Record.size() != 6) 1215 return error("Invalid record"); 1216 1217 IsDistinct = Record[0]; 1218 MetadataList.assignValue( 1219 GET_OR_DISTINCT(DIBasicType, 1220 (Context, Record[1], getMDString(Record[2]), Record[3], 1221 Record[4], Record[5])), 1222 NextMetadataNo); 1223 NextMetadataNo++; 1224 break; 1225 } 1226 case bitc::METADATA_DERIVED_TYPE: { 1227 if (Record.size() < 12 || Record.size() > 13) 1228 return error("Invalid record"); 1229 1230 // DWARF address space is encoded as N->getDWARFAddressSpace() + 1. 0 means 1231 // that there is no DWARF address space associated with DIDerivedType. 1232 Optional<unsigned> DWARFAddressSpace; 1233 if (Record.size() > 12 && Record[12]) 1234 DWARFAddressSpace = Record[12] - 1; 1235 1236 IsDistinct = Record[0]; 1237 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]); 1238 MetadataList.assignValue( 1239 GET_OR_DISTINCT(DIDerivedType, 1240 (Context, Record[1], getMDString(Record[2]), 1241 getMDOrNull(Record[3]), Record[4], 1242 getDITypeRefOrNull(Record[5]), 1243 getDITypeRefOrNull(Record[6]), Record[7], Record[8], 1244 Record[9], DWARFAddressSpace, Flags, 1245 getDITypeRefOrNull(Record[11]))), 1246 NextMetadataNo); 1247 NextMetadataNo++; 1248 break; 1249 } 1250 case bitc::METADATA_COMPOSITE_TYPE: { 1251 if (Record.size() < 16 || Record.size() > 17) 1252 return error("Invalid record"); 1253 1254 // If we have a UUID and this is not a forward declaration, lookup the 1255 // mapping. 1256 IsDistinct = Record[0] & 0x1; 1257 bool IsNotUsedInTypeRef = Record[0] >= 2; 1258 unsigned Tag = Record[1]; 1259 MDString *Name = getMDString(Record[2]); 1260 Metadata *File = getMDOrNull(Record[3]); 1261 unsigned Line = Record[4]; 1262 Metadata *Scope = getDITypeRefOrNull(Record[5]); 1263 Metadata *BaseType = nullptr; 1264 uint64_t SizeInBits = Record[7]; 1265 if (Record[8] > (uint64_t)std::numeric_limits<uint32_t>::max()) 1266 return error("Alignment value is too large"); 1267 uint32_t AlignInBits = Record[8]; 1268 uint64_t OffsetInBits = 0; 1269 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]); 1270 Metadata *Elements = nullptr; 1271 unsigned RuntimeLang = Record[12]; 1272 Metadata *VTableHolder = nullptr; 1273 Metadata *TemplateParams = nullptr; 1274 Metadata *Discriminator = nullptr; 1275 auto *Identifier = getMDString(Record[15]); 1276 // If this module is being parsed so that it can be ThinLTO imported 1277 // into another module, composite types only need to be imported 1278 // as type declarations (unless full type definitions requested). 1279 // Create type declarations up front to save memory. Also, buildODRType 1280 // handles the case where this is type ODRed with a definition needed 1281 // by the importing module, in which case the existing definition is 1282 // used. 1283 if (IsImporting && !ImportFullTypeDefinitions && Identifier && 1284 (Tag == dwarf::DW_TAG_enumeration_type || 1285 Tag == dwarf::DW_TAG_class_type || 1286 Tag == dwarf::DW_TAG_structure_type || 1287 Tag == dwarf::DW_TAG_union_type)) { 1288 Flags = Flags | DINode::FlagFwdDecl; 1289 } else { 1290 BaseType = getDITypeRefOrNull(Record[6]); 1291 OffsetInBits = Record[9]; 1292 Elements = getMDOrNull(Record[11]); 1293 VTableHolder = getDITypeRefOrNull(Record[13]); 1294 TemplateParams = getMDOrNull(Record[14]); 1295 if (Record.size() > 16) 1296 Discriminator = getMDOrNull(Record[16]); 1297 } 1298 DICompositeType *CT = nullptr; 1299 if (Identifier) 1300 CT = DICompositeType::buildODRType( 1301 Context, *Identifier, Tag, Name, File, Line, Scope, BaseType, 1302 SizeInBits, AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, 1303 VTableHolder, TemplateParams, Discriminator); 1304 1305 // Create a node if we didn't get a lazy ODR type. 1306 if (!CT) 1307 CT = GET_OR_DISTINCT(DICompositeType, 1308 (Context, Tag, Name, File, Line, Scope, BaseType, 1309 SizeInBits, AlignInBits, OffsetInBits, Flags, 1310 Elements, RuntimeLang, VTableHolder, TemplateParams, 1311 Identifier)); 1312 if (!IsNotUsedInTypeRef && Identifier) 1313 MetadataList.addTypeRef(*Identifier, *cast<DICompositeType>(CT)); 1314 1315 MetadataList.assignValue(CT, NextMetadataNo); 1316 NextMetadataNo++; 1317 break; 1318 } 1319 case bitc::METADATA_SUBROUTINE_TYPE: { 1320 if (Record.size() < 3 || Record.size() > 4) 1321 return error("Invalid record"); 1322 bool IsOldTypeRefArray = Record[0] < 2; 1323 unsigned CC = (Record.size() > 3) ? Record[3] : 0; 1324 1325 IsDistinct = Record[0] & 0x1; 1326 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[1]); 1327 Metadata *Types = getMDOrNull(Record[2]); 1328 if (LLVM_UNLIKELY(IsOldTypeRefArray)) 1329 Types = MetadataList.upgradeTypeRefArray(Types); 1330 1331 MetadataList.assignValue( 1332 GET_OR_DISTINCT(DISubroutineType, (Context, Flags, CC, Types)), 1333 NextMetadataNo); 1334 NextMetadataNo++; 1335 break; 1336 } 1337 1338 case bitc::METADATA_MODULE: { 1339 if (Record.size() != 6) 1340 return error("Invalid record"); 1341 1342 IsDistinct = Record[0]; 1343 MetadataList.assignValue( 1344 GET_OR_DISTINCT(DIModule, 1345 (Context, getMDOrNull(Record[1]), 1346 getMDString(Record[2]), getMDString(Record[3]), 1347 getMDString(Record[4]), getMDString(Record[5]))), 1348 NextMetadataNo); 1349 NextMetadataNo++; 1350 break; 1351 } 1352 1353 case bitc::METADATA_FILE: { 1354 if (Record.size() != 3 && Record.size() != 5 && Record.size() != 6) 1355 return error("Invalid record"); 1356 1357 IsDistinct = Record[0]; 1358 Optional<DIFile::ChecksumInfo<MDString *>> Checksum; 1359 // The BitcodeWriter writes null bytes into Record[3:4] when the Checksum 1360 // is not present. This matches up with the old internal representation, 1361 // and the old encoding for CSK_None in the ChecksumKind. The new 1362 // representation reserves the value 0 in the ChecksumKind to continue to 1363 // encode None in a backwards-compatible way. 1364 if (Record.size() > 4 && Record[3] && Record[4]) 1365 Checksum.emplace(static_cast<DIFile::ChecksumKind>(Record[3]), 1366 getMDString(Record[4])); 1367 MetadataList.assignValue( 1368 GET_OR_DISTINCT( 1369 DIFile, 1370 (Context, getMDString(Record[1]), getMDString(Record[2]), Checksum, 1371 Record.size() > 5 ? Optional<MDString *>(getMDString(Record[5])) 1372 : None)), 1373 NextMetadataNo); 1374 NextMetadataNo++; 1375 break; 1376 } 1377 case bitc::METADATA_COMPILE_UNIT: { 1378 if (Record.size() < 14 || Record.size() > 19) 1379 return error("Invalid record"); 1380 1381 // Ignore Record[0], which indicates whether this compile unit is 1382 // distinct. It's always distinct. 1383 IsDistinct = true; 1384 auto *CU = DICompileUnit::getDistinct( 1385 Context, Record[1], getMDOrNull(Record[2]), getMDString(Record[3]), 1386 Record[4], getMDString(Record[5]), Record[6], getMDString(Record[7]), 1387 Record[8], getMDOrNull(Record[9]), getMDOrNull(Record[10]), 1388 getMDOrNull(Record[12]), getMDOrNull(Record[13]), 1389 Record.size() <= 15 ? nullptr : getMDOrNull(Record[15]), 1390 Record.size() <= 14 ? 0 : Record[14], 1391 Record.size() <= 16 ? true : Record[16], 1392 Record.size() <= 17 ? false : Record[17], 1393 Record.size() <= 18 ? false : Record[18]); 1394 1395 MetadataList.assignValue(CU, NextMetadataNo); 1396 NextMetadataNo++; 1397 1398 // Move the Upgrade the list of subprograms. 1399 if (Metadata *SPs = getMDOrNullWithoutPlaceholders(Record[11])) 1400 CUSubprograms.push_back({CU, SPs}); 1401 break; 1402 } 1403 case bitc::METADATA_SUBPROGRAM: { 1404 if (Record.size() < 18 || Record.size() > 21) 1405 return error("Invalid record"); 1406 1407 IsDistinct = 1408 (Record[0] & 1) || Record[8]; // All definitions should be distinct. 1409 // Version 1 has a Function as Record[15]. 1410 // Version 2 has removed Record[15]. 1411 // Version 3 has the Unit as Record[15]. 1412 // Version 4 added thisAdjustment. 1413 bool HasUnit = Record[0] >= 2; 1414 if (HasUnit && Record.size() < 19) 1415 return error("Invalid record"); 1416 Metadata *CUorFn = getMDOrNull(Record[15]); 1417 unsigned Offset = Record.size() >= 19 ? 1 : 0; 1418 bool HasFn = Offset && !HasUnit; 1419 bool HasThisAdj = Record.size() >= 20; 1420 bool HasThrownTypes = Record.size() >= 21; 1421 DISubprogram *SP = GET_OR_DISTINCT( 1422 DISubprogram, 1423 (Context, 1424 getDITypeRefOrNull(Record[1]), // scope 1425 getMDString(Record[2]), // name 1426 getMDString(Record[3]), // linkageName 1427 getMDOrNull(Record[4]), // file 1428 Record[5], // line 1429 getMDOrNull(Record[6]), // type 1430 Record[7], // isLocal 1431 Record[8], // isDefinition 1432 Record[9], // scopeLine 1433 getDITypeRefOrNull(Record[10]), // containingType 1434 Record[11], // virtuality 1435 Record[12], // virtualIndex 1436 HasThisAdj ? Record[19] : 0, // thisAdjustment 1437 static_cast<DINode::DIFlags>(Record[13]), // flags 1438 Record[14], // isOptimized 1439 HasUnit ? CUorFn : nullptr, // unit 1440 getMDOrNull(Record[15 + Offset]), // templateParams 1441 getMDOrNull(Record[16 + Offset]), // declaration 1442 getMDOrNull(Record[17 + Offset]), // retainedNodes 1443 HasThrownTypes ? getMDOrNull(Record[20]) : nullptr // thrownTypes 1444 )); 1445 MetadataList.assignValue(SP, NextMetadataNo); 1446 NextMetadataNo++; 1447 1448 // Upgrade sp->function mapping to function->sp mapping. 1449 if (HasFn) { 1450 if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(CUorFn)) 1451 if (auto *F = dyn_cast<Function>(CMD->getValue())) { 1452 if (F->isMaterializable()) 1453 // Defer until materialized; unmaterialized functions may not have 1454 // metadata. 1455 FunctionsWithSPs[F] = SP; 1456 else if (!F->empty()) 1457 F->setSubprogram(SP); 1458 } 1459 } 1460 break; 1461 } 1462 case bitc::METADATA_LEXICAL_BLOCK: { 1463 if (Record.size() != 5) 1464 return error("Invalid record"); 1465 1466 IsDistinct = Record[0]; 1467 MetadataList.assignValue( 1468 GET_OR_DISTINCT(DILexicalBlock, 1469 (Context, getMDOrNull(Record[1]), 1470 getMDOrNull(Record[2]), Record[3], Record[4])), 1471 NextMetadataNo); 1472 NextMetadataNo++; 1473 break; 1474 } 1475 case bitc::METADATA_LEXICAL_BLOCK_FILE: { 1476 if (Record.size() != 4) 1477 return error("Invalid record"); 1478 1479 IsDistinct = Record[0]; 1480 MetadataList.assignValue( 1481 GET_OR_DISTINCT(DILexicalBlockFile, 1482 (Context, getMDOrNull(Record[1]), 1483 getMDOrNull(Record[2]), Record[3])), 1484 NextMetadataNo); 1485 NextMetadataNo++; 1486 break; 1487 } 1488 case bitc::METADATA_NAMESPACE: { 1489 // Newer versions of DINamespace dropped file and line. 1490 MDString *Name; 1491 if (Record.size() == 3) 1492 Name = getMDString(Record[2]); 1493 else if (Record.size() == 5) 1494 Name = getMDString(Record[3]); 1495 else 1496 return error("Invalid record"); 1497 1498 IsDistinct = Record[0] & 1; 1499 bool ExportSymbols = Record[0] & 2; 1500 MetadataList.assignValue( 1501 GET_OR_DISTINCT(DINamespace, 1502 (Context, getMDOrNull(Record[1]), Name, ExportSymbols)), 1503 NextMetadataNo); 1504 NextMetadataNo++; 1505 break; 1506 } 1507 case bitc::METADATA_MACRO: { 1508 if (Record.size() != 5) 1509 return error("Invalid record"); 1510 1511 IsDistinct = Record[0]; 1512 MetadataList.assignValue( 1513 GET_OR_DISTINCT(DIMacro, 1514 (Context, Record[1], Record[2], getMDString(Record[3]), 1515 getMDString(Record[4]))), 1516 NextMetadataNo); 1517 NextMetadataNo++; 1518 break; 1519 } 1520 case bitc::METADATA_MACRO_FILE: { 1521 if (Record.size() != 5) 1522 return error("Invalid record"); 1523 1524 IsDistinct = Record[0]; 1525 MetadataList.assignValue( 1526 GET_OR_DISTINCT(DIMacroFile, 1527 (Context, Record[1], Record[2], getMDOrNull(Record[3]), 1528 getMDOrNull(Record[4]))), 1529 NextMetadataNo); 1530 NextMetadataNo++; 1531 break; 1532 } 1533 case bitc::METADATA_TEMPLATE_TYPE: { 1534 if (Record.size() != 3) 1535 return error("Invalid record"); 1536 1537 IsDistinct = Record[0]; 1538 MetadataList.assignValue(GET_OR_DISTINCT(DITemplateTypeParameter, 1539 (Context, getMDString(Record[1]), 1540 getDITypeRefOrNull(Record[2]))), 1541 NextMetadataNo); 1542 NextMetadataNo++; 1543 break; 1544 } 1545 case bitc::METADATA_TEMPLATE_VALUE: { 1546 if (Record.size() != 5) 1547 return error("Invalid record"); 1548 1549 IsDistinct = Record[0]; 1550 MetadataList.assignValue( 1551 GET_OR_DISTINCT(DITemplateValueParameter, 1552 (Context, Record[1], getMDString(Record[2]), 1553 getDITypeRefOrNull(Record[3]), 1554 getMDOrNull(Record[4]))), 1555 NextMetadataNo); 1556 NextMetadataNo++; 1557 break; 1558 } 1559 case bitc::METADATA_GLOBAL_VAR: { 1560 if (Record.size() < 11 || Record.size() > 12) 1561 return error("Invalid record"); 1562 1563 IsDistinct = Record[0] & 1; 1564 unsigned Version = Record[0] >> 1; 1565 1566 if (Version == 1) { 1567 MetadataList.assignValue( 1568 GET_OR_DISTINCT(DIGlobalVariable, 1569 (Context, getMDOrNull(Record[1]), 1570 getMDString(Record[2]), getMDString(Record[3]), 1571 getMDOrNull(Record[4]), Record[5], 1572 getDITypeRefOrNull(Record[6]), Record[7], Record[8], 1573 getMDOrNull(Record[10]), Record[11])), 1574 NextMetadataNo); 1575 NextMetadataNo++; 1576 } else if (Version == 0) { 1577 // Upgrade old metadata, which stored a global variable reference or a 1578 // ConstantInt here. 1579 NeedUpgradeToDIGlobalVariableExpression = true; 1580 Metadata *Expr = getMDOrNull(Record[9]); 1581 uint32_t AlignInBits = 0; 1582 if (Record.size() > 11) { 1583 if (Record[11] > (uint64_t)std::numeric_limits<uint32_t>::max()) 1584 return error("Alignment value is too large"); 1585 AlignInBits = Record[11]; 1586 } 1587 GlobalVariable *Attach = nullptr; 1588 if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(Expr)) { 1589 if (auto *GV = dyn_cast<GlobalVariable>(CMD->getValue())) { 1590 Attach = GV; 1591 Expr = nullptr; 1592 } else if (auto *CI = dyn_cast<ConstantInt>(CMD->getValue())) { 1593 Expr = DIExpression::get(Context, 1594 {dwarf::DW_OP_constu, CI->getZExtValue(), 1595 dwarf::DW_OP_stack_value}); 1596 } else { 1597 Expr = nullptr; 1598 } 1599 } 1600 DIGlobalVariable *DGV = GET_OR_DISTINCT( 1601 DIGlobalVariable, 1602 (Context, getMDOrNull(Record[1]), getMDString(Record[2]), 1603 getMDString(Record[3]), getMDOrNull(Record[4]), Record[5], 1604 getDITypeRefOrNull(Record[6]), Record[7], Record[8], 1605 getMDOrNull(Record[10]), AlignInBits)); 1606 1607 DIGlobalVariableExpression *DGVE = nullptr; 1608 if (Attach || Expr) 1609 DGVE = DIGlobalVariableExpression::getDistinct( 1610 Context, DGV, Expr ? Expr : DIExpression::get(Context, {})); 1611 if (Attach) 1612 Attach->addDebugInfo(DGVE); 1613 1614 auto *MDNode = Expr ? cast<Metadata>(DGVE) : cast<Metadata>(DGV); 1615 MetadataList.assignValue(MDNode, NextMetadataNo); 1616 NextMetadataNo++; 1617 } else 1618 return error("Invalid record"); 1619 1620 break; 1621 } 1622 case bitc::METADATA_LOCAL_VAR: { 1623 // 10th field is for the obseleted 'inlinedAt:' field. 1624 if (Record.size() < 8 || Record.size() > 10) 1625 return error("Invalid record"); 1626 1627 IsDistinct = Record[0] & 1; 1628 bool HasAlignment = Record[0] & 2; 1629 // 2nd field used to be an artificial tag, either DW_TAG_auto_variable or 1630 // DW_TAG_arg_variable, if we have alignment flag encoded it means, that 1631 // this is newer version of record which doesn't have artificial tag. 1632 bool HasTag = !HasAlignment && Record.size() > 8; 1633 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[7 + HasTag]); 1634 uint32_t AlignInBits = 0; 1635 if (HasAlignment) { 1636 if (Record[8 + HasTag] > (uint64_t)std::numeric_limits<uint32_t>::max()) 1637 return error("Alignment value is too large"); 1638 AlignInBits = Record[8 + HasTag]; 1639 } 1640 MetadataList.assignValue( 1641 GET_OR_DISTINCT(DILocalVariable, 1642 (Context, getMDOrNull(Record[1 + HasTag]), 1643 getMDString(Record[2 + HasTag]), 1644 getMDOrNull(Record[3 + HasTag]), Record[4 + HasTag], 1645 getDITypeRefOrNull(Record[5 + HasTag]), 1646 Record[6 + HasTag], Flags, AlignInBits)), 1647 NextMetadataNo); 1648 NextMetadataNo++; 1649 break; 1650 } 1651 case bitc::METADATA_LABEL: { 1652 if (Record.size() != 5) 1653 return error("Invalid record"); 1654 1655 IsDistinct = Record[0] & 1; 1656 MetadataList.assignValue( 1657 GET_OR_DISTINCT(DILabel, 1658 (Context, getMDOrNull(Record[1]), 1659 getMDString(Record[2]), 1660 getMDOrNull(Record[3]), Record[4])), 1661 NextMetadataNo); 1662 NextMetadataNo++; 1663 break; 1664 } 1665 case bitc::METADATA_EXPRESSION: { 1666 if (Record.size() < 1) 1667 return error("Invalid record"); 1668 1669 IsDistinct = Record[0] & 1; 1670 uint64_t Version = Record[0] >> 1; 1671 auto Elts = MutableArrayRef<uint64_t>(Record).slice(1); 1672 1673 SmallVector<uint64_t, 6> Buffer; 1674 if (Error Err = upgradeDIExpression(Version, Elts, Buffer)) 1675 return Err; 1676 1677 MetadataList.assignValue( 1678 GET_OR_DISTINCT(DIExpression, (Context, Elts)), NextMetadataNo); 1679 NextMetadataNo++; 1680 break; 1681 } 1682 case bitc::METADATA_GLOBAL_VAR_EXPR: { 1683 if (Record.size() != 3) 1684 return error("Invalid record"); 1685 1686 IsDistinct = Record[0]; 1687 Metadata *Expr = getMDOrNull(Record[2]); 1688 if (!Expr) 1689 Expr = DIExpression::get(Context, {}); 1690 MetadataList.assignValue( 1691 GET_OR_DISTINCT(DIGlobalVariableExpression, 1692 (Context, getMDOrNull(Record[1]), Expr)), 1693 NextMetadataNo); 1694 NextMetadataNo++; 1695 break; 1696 } 1697 case bitc::METADATA_OBJC_PROPERTY: { 1698 if (Record.size() != 8) 1699 return error("Invalid record"); 1700 1701 IsDistinct = Record[0]; 1702 MetadataList.assignValue( 1703 GET_OR_DISTINCT(DIObjCProperty, 1704 (Context, getMDString(Record[1]), 1705 getMDOrNull(Record[2]), Record[3], 1706 getMDString(Record[4]), getMDString(Record[5]), 1707 Record[6], getDITypeRefOrNull(Record[7]))), 1708 NextMetadataNo); 1709 NextMetadataNo++; 1710 break; 1711 } 1712 case bitc::METADATA_IMPORTED_ENTITY: { 1713 if (Record.size() != 6 && Record.size() != 7) 1714 return error("Invalid record"); 1715 1716 IsDistinct = Record[0]; 1717 bool HasFile = (Record.size() == 7); 1718 MetadataList.assignValue( 1719 GET_OR_DISTINCT(DIImportedEntity, 1720 (Context, Record[1], getMDOrNull(Record[2]), 1721 getDITypeRefOrNull(Record[3]), 1722 HasFile ? getMDOrNull(Record[6]) : nullptr, 1723 HasFile ? Record[4] : 0, getMDString(Record[5]))), 1724 NextMetadataNo); 1725 NextMetadataNo++; 1726 break; 1727 } 1728 case bitc::METADATA_STRING_OLD: { 1729 std::string String(Record.begin(), Record.end()); 1730 1731 // Test for upgrading !llvm.loop. 1732 HasSeenOldLoopTags |= mayBeOldLoopAttachmentTag(String); 1733 ++NumMDStringLoaded; 1734 Metadata *MD = MDString::get(Context, String); 1735 MetadataList.assignValue(MD, NextMetadataNo); 1736 NextMetadataNo++; 1737 break; 1738 } 1739 case bitc::METADATA_STRINGS: { 1740 auto CreateNextMDString = [&](StringRef Str) { 1741 ++NumMDStringLoaded; 1742 MetadataList.assignValue(MDString::get(Context, Str), NextMetadataNo); 1743 NextMetadataNo++; 1744 }; 1745 if (Error Err = parseMetadataStrings(Record, Blob, CreateNextMDString)) 1746 return Err; 1747 break; 1748 } 1749 case bitc::METADATA_GLOBAL_DECL_ATTACHMENT: { 1750 if (Record.size() % 2 == 0) 1751 return error("Invalid record"); 1752 unsigned ValueID = Record[0]; 1753 if (ValueID >= ValueList.size()) 1754 return error("Invalid record"); 1755 if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID])) 1756 if (Error Err = parseGlobalObjectAttachment( 1757 *GO, ArrayRef<uint64_t>(Record).slice(1))) 1758 return Err; 1759 break; 1760 } 1761 case bitc::METADATA_KIND: { 1762 // Support older bitcode files that had METADATA_KIND records in a 1763 // block with METADATA_BLOCK_ID. 1764 if (Error Err = parseMetadataKindRecord(Record)) 1765 return Err; 1766 break; 1767 } 1768 } 1769 return Error::success(); 1770 #undef GET_OR_DISTINCT 1771 } 1772 1773 Error MetadataLoader::MetadataLoaderImpl::parseMetadataStrings( 1774 ArrayRef<uint64_t> Record, StringRef Blob, 1775 function_ref<void(StringRef)> CallBack) { 1776 // All the MDStrings in the block are emitted together in a single 1777 // record. The strings are concatenated and stored in a blob along with 1778 // their sizes. 1779 if (Record.size() != 2) 1780 return error("Invalid record: metadata strings layout"); 1781 1782 unsigned NumStrings = Record[0]; 1783 unsigned StringsOffset = Record[1]; 1784 if (!NumStrings) 1785 return error("Invalid record: metadata strings with no strings"); 1786 if (StringsOffset > Blob.size()) 1787 return error("Invalid record: metadata strings corrupt offset"); 1788 1789 StringRef Lengths = Blob.slice(0, StringsOffset); 1790 SimpleBitstreamCursor R(Lengths); 1791 1792 StringRef Strings = Blob.drop_front(StringsOffset); 1793 do { 1794 if (R.AtEndOfStream()) 1795 return error("Invalid record: metadata strings bad length"); 1796 1797 unsigned Size = R.ReadVBR(6); 1798 if (Strings.size() < Size) 1799 return error("Invalid record: metadata strings truncated chars"); 1800 1801 CallBack(Strings.slice(0, Size)); 1802 Strings = Strings.drop_front(Size); 1803 } while (--NumStrings); 1804 1805 return Error::success(); 1806 } 1807 1808 Error MetadataLoader::MetadataLoaderImpl::parseGlobalObjectAttachment( 1809 GlobalObject &GO, ArrayRef<uint64_t> Record) { 1810 assert(Record.size() % 2 == 0); 1811 for (unsigned I = 0, E = Record.size(); I != E; I += 2) { 1812 auto K = MDKindMap.find(Record[I]); 1813 if (K == MDKindMap.end()) 1814 return error("Invalid ID"); 1815 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[I + 1]); 1816 if (!MD) 1817 return error("Invalid metadata attachment"); 1818 GO.addMetadata(K->second, *MD); 1819 } 1820 return Error::success(); 1821 } 1822 1823 /// Parse metadata attachments. 1824 Error MetadataLoader::MetadataLoaderImpl::parseMetadataAttachment( 1825 Function &F, const SmallVectorImpl<Instruction *> &InstructionList) { 1826 if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) 1827 return error("Invalid record"); 1828 1829 SmallVector<uint64_t, 64> Record; 1830 PlaceholderQueue Placeholders; 1831 1832 while (true) { 1833 BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 1834 1835 switch (Entry.Kind) { 1836 case BitstreamEntry::SubBlock: // Handled for us already. 1837 case BitstreamEntry::Error: 1838 return error("Malformed block"); 1839 case BitstreamEntry::EndBlock: 1840 resolveForwardRefsAndPlaceholders(Placeholders); 1841 return Error::success(); 1842 case BitstreamEntry::Record: 1843 // The interesting case. 1844 break; 1845 } 1846 1847 // Read a metadata attachment record. 1848 Record.clear(); 1849 ++NumMDRecordLoaded; 1850 switch (Stream.readRecord(Entry.ID, Record)) { 1851 default: // Default behavior: ignore. 1852 break; 1853 case bitc::METADATA_ATTACHMENT: { 1854 unsigned RecordLength = Record.size(); 1855 if (Record.empty()) 1856 return error("Invalid record"); 1857 if (RecordLength % 2 == 0) { 1858 // A function attachment. 1859 if (Error Err = parseGlobalObjectAttachment(F, Record)) 1860 return Err; 1861 continue; 1862 } 1863 1864 // An instruction attachment. 1865 Instruction *Inst = InstructionList[Record[0]]; 1866 for (unsigned i = 1; i != RecordLength; i = i + 2) { 1867 unsigned Kind = Record[i]; 1868 DenseMap<unsigned, unsigned>::iterator I = MDKindMap.find(Kind); 1869 if (I == MDKindMap.end()) 1870 return error("Invalid ID"); 1871 if (I->second == LLVMContext::MD_tbaa && StripTBAA) 1872 continue; 1873 1874 auto Idx = Record[i + 1]; 1875 if (Idx < (MDStringRef.size() + GlobalMetadataBitPosIndex.size()) && 1876 !MetadataList.lookup(Idx)) { 1877 // Load the attachment if it is in the lazy-loadable range and hasn't 1878 // been loaded yet. 1879 lazyLoadOneMetadata(Idx, Placeholders); 1880 resolveForwardRefsAndPlaceholders(Placeholders); 1881 } 1882 1883 Metadata *Node = MetadataList.getMetadataFwdRef(Idx); 1884 if (isa<LocalAsMetadata>(Node)) 1885 // Drop the attachment. This used to be legal, but there's no 1886 // upgrade path. 1887 break; 1888 MDNode *MD = dyn_cast_or_null<MDNode>(Node); 1889 if (!MD) 1890 return error("Invalid metadata attachment"); 1891 1892 if (HasSeenOldLoopTags && I->second == LLVMContext::MD_loop) 1893 MD = upgradeInstructionLoopAttachment(*MD); 1894 1895 if (I->second == LLVMContext::MD_tbaa) { 1896 assert(!MD->isTemporary() && "should load MDs before attachments"); 1897 MD = UpgradeTBAANode(*MD); 1898 } 1899 Inst->setMetadata(I->second, MD); 1900 } 1901 break; 1902 } 1903 } 1904 } 1905 } 1906 1907 /// Parse a single METADATA_KIND record, inserting result in MDKindMap. 1908 Error MetadataLoader::MetadataLoaderImpl::parseMetadataKindRecord( 1909 SmallVectorImpl<uint64_t> &Record) { 1910 if (Record.size() < 2) 1911 return error("Invalid record"); 1912 1913 unsigned Kind = Record[0]; 1914 SmallString<8> Name(Record.begin() + 1, Record.end()); 1915 1916 unsigned NewKind = TheModule.getMDKindID(Name.str()); 1917 if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) 1918 return error("Conflicting METADATA_KIND records"); 1919 return Error::success(); 1920 } 1921 1922 /// Parse the metadata kinds out of the METADATA_KIND_BLOCK. 1923 Error MetadataLoader::MetadataLoaderImpl::parseMetadataKinds() { 1924 if (Stream.EnterSubBlock(bitc::METADATA_KIND_BLOCK_ID)) 1925 return error("Invalid record"); 1926 1927 SmallVector<uint64_t, 64> Record; 1928 1929 // Read all the records. 1930 while (true) { 1931 BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 1932 1933 switch (Entry.Kind) { 1934 case BitstreamEntry::SubBlock: // Handled for us already. 1935 case BitstreamEntry::Error: 1936 return error("Malformed block"); 1937 case BitstreamEntry::EndBlock: 1938 return Error::success(); 1939 case BitstreamEntry::Record: 1940 // The interesting case. 1941 break; 1942 } 1943 1944 // Read a record. 1945 Record.clear(); 1946 ++NumMDRecordLoaded; 1947 unsigned Code = Stream.readRecord(Entry.ID, Record); 1948 switch (Code) { 1949 default: // Default behavior: ignore. 1950 break; 1951 case bitc::METADATA_KIND: { 1952 if (Error Err = parseMetadataKindRecord(Record)) 1953 return Err; 1954 break; 1955 } 1956 } 1957 } 1958 } 1959 1960 MetadataLoader &MetadataLoader::operator=(MetadataLoader &&RHS) { 1961 Pimpl = std::move(RHS.Pimpl); 1962 return *this; 1963 } 1964 MetadataLoader::MetadataLoader(MetadataLoader &&RHS) 1965 : Pimpl(std::move(RHS.Pimpl)) {} 1966 1967 MetadataLoader::~MetadataLoader() = default; 1968 MetadataLoader::MetadataLoader(BitstreamCursor &Stream, Module &TheModule, 1969 BitcodeReaderValueList &ValueList, 1970 bool IsImporting, 1971 std::function<Type *(unsigned)> getTypeByID) 1972 : Pimpl(llvm::make_unique<MetadataLoaderImpl>( 1973 Stream, TheModule, ValueList, std::move(getTypeByID), IsImporting)) {} 1974 1975 Error MetadataLoader::parseMetadata(bool ModuleLevel) { 1976 return Pimpl->parseMetadata(ModuleLevel); 1977 } 1978 1979 bool MetadataLoader::hasFwdRefs() const { return Pimpl->hasFwdRefs(); } 1980 1981 /// Return the given metadata, creating a replaceable forward reference if 1982 /// necessary. 1983 Metadata *MetadataLoader::getMetadataFwdRefOrLoad(unsigned Idx) { 1984 return Pimpl->getMetadataFwdRefOrLoad(Idx); 1985 } 1986 1987 MDNode *MetadataLoader::getMDNodeFwdRefOrNull(unsigned Idx) { 1988 return Pimpl->getMDNodeFwdRefOrNull(Idx); 1989 } 1990 1991 DISubprogram *MetadataLoader::lookupSubprogramForFunction(Function *F) { 1992 return Pimpl->lookupSubprogramForFunction(F); 1993 } 1994 1995 Error MetadataLoader::parseMetadataAttachment( 1996 Function &F, const SmallVectorImpl<Instruction *> &InstructionList) { 1997 return Pimpl->parseMetadataAttachment(F, InstructionList); 1998 } 1999 2000 Error MetadataLoader::parseMetadataKinds() { 2001 return Pimpl->parseMetadataKinds(); 2002 } 2003 2004 void MetadataLoader::setStripTBAA(bool StripTBAA) { 2005 return Pimpl->setStripTBAA(StripTBAA); 2006 } 2007 2008 bool MetadataLoader::isStrippingTBAA() { return Pimpl->isStrippingTBAA(); } 2009 2010 unsigned MetadataLoader::size() const { return Pimpl->size(); } 2011 void MetadataLoader::shrinkTo(unsigned N) { return Pimpl->shrinkTo(N); } 2012 2013 void MetadataLoader::upgradeDebugIntrinsics(Function &F) { 2014 return Pimpl->upgradeDebugIntrinsics(F); 2015 } 2016