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