1 //===- MetadataLoader.cpp - Internal BitcodeReader implementation ---------===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 #include "MetadataLoader.h"
10 #include "ValueList.h"
12 #include "llvm/ADT/APFloat.h"
13 #include "llvm/ADT/APInt.h"
14 #include "llvm/ADT/ArrayRef.h"
15 #include "llvm/ADT/DenseMap.h"
16 #include "llvm/ADT/DenseSet.h"
17 #include "llvm/ADT/None.h"
18 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/ADT/SmallString.h"
20 #include "llvm/ADT/Statistic.h"
21 #include "llvm/ADT/StringRef.h"
22 #include "llvm/ADT/Twine.h"
23 #include "llvm/Bitcode/BitcodeReader.h"
24 #include "llvm/Bitstream/BitstreamReader.h"
25 #include "llvm/Bitcode/LLVMBitCodes.h"
26 #include "llvm/IR/Argument.h"
27 #include "llvm/IR/Attributes.h"
28 #include "llvm/IR/AutoUpgrade.h"
29 #include "llvm/IR/BasicBlock.h"
30 #include "llvm/IR/CallingConv.h"
31 #include "llvm/IR/Comdat.h"
32 #include "llvm/IR/Constant.h"
33 #include "llvm/IR/Constants.h"
34 #include "llvm/IR/DebugInfo.h"
35 #include "llvm/IR/DebugInfoMetadata.h"
36 #include "llvm/IR/DebugLoc.h"
37 #include "llvm/IR/DerivedTypes.h"
38 #include "llvm/IR/DiagnosticPrinter.h"
39 #include "llvm/IR/Function.h"
40 #include "llvm/IR/GVMaterializer.h"
41 #include "llvm/IR/GlobalAlias.h"
42 #include "llvm/IR/GlobalIFunc.h"
43 #include "llvm/IR/GlobalIndirectSymbol.h"
44 #include "llvm/IR/GlobalObject.h"
45 #include "llvm/IR/GlobalValue.h"
46 #include "llvm/IR/GlobalVariable.h"
47 #include "llvm/IR/InlineAsm.h"
48 #include "llvm/IR/InstrTypes.h"
49 #include "llvm/IR/Instruction.h"
50 #include "llvm/IR/Instructions.h"
51 #include "llvm/IR/IntrinsicInst.h"
52 #include "llvm/IR/Intrinsics.h"
53 #include "llvm/IR/LLVMContext.h"
54 #include "llvm/IR/Module.h"
55 #include "llvm/IR/ModuleSummaryIndex.h"
56 #include "llvm/IR/OperandTraits.h"
57 #include "llvm/IR/TrackingMDRef.h"
58 #include "llvm/IR/Type.h"
59 #include "llvm/IR/ValueHandle.h"
60 #include "llvm/Support/AtomicOrdering.h"
61 #include "llvm/Support/Casting.h"
62 #include "llvm/Support/CommandLine.h"
63 #include "llvm/Support/Compiler.h"
64 #include "llvm/Support/Debug.h"
65 #include "llvm/Support/ErrorHandling.h"
66 #include "llvm/Support/ManagedStatic.h"
67 #include "llvm/Support/MemoryBuffer.h"
68 #include "llvm/Support/raw_ostream.h"
77 #include <system_error>
84 #define DEBUG_TYPE "bitcode-reader"
86 STATISTIC(NumMDStringLoaded, "Number of MDStrings loaded");
87 STATISTIC(NumMDNodeTemporary, "Number of MDNode::Temporary created");
88 STATISTIC(NumMDRecordLoaded, "Number of Metadata records loaded");
90 /// Flag whether we need to import full type definitions for ThinLTO.
91 /// Currently needed for Darwin and LLDB.
92 static cl::opt<bool> ImportFullTypeDefinitions(
93 "import-full-type-definitions", cl::init(false), cl::Hidden,
94 cl::desc("Import full type definitions for ThinLTO."));
96 static cl::opt<bool> DisableLazyLoading(
97 "disable-ondemand-mds-loading", cl::init(false), cl::Hidden,
98 cl::desc("Force disable the lazy-loading on-demand of metadata when "
99 "loading bitcode for importing."));
103 static int64_t unrotateSign(uint64_t U) { return (U & 1) ? ~(U >> 1) : U >> 1; }
105 class BitcodeReaderMetadataList {
106 /// Array of metadata references.
108 /// Don't use std::vector here. Some versions of libc++ copy (instead of
109 /// move) on resize, and TrackingMDRef is very expensive to copy.
110 SmallVector<TrackingMDRef, 1> MetadataPtrs;
112 /// The set of indices in MetadataPtrs above of forward references that were
114 SmallDenseSet<unsigned, 1> ForwardReference;
116 /// The set of indices in MetadataPtrs above of Metadata that need to be
118 SmallDenseSet<unsigned, 1> UnresolvedNodes;
120 /// Structures for resolving old type refs.
122 SmallDenseMap<MDString *, TempMDTuple, 1> Unknown;
123 SmallDenseMap<MDString *, DICompositeType *, 1> Final;
124 SmallDenseMap<MDString *, DICompositeType *, 1> FwdDecls;
125 SmallVector<std::pair<TrackingMDRef, TempMDTuple>, 1> Arrays;
128 LLVMContext &Context;
130 /// Maximum number of valid references. Forward references exceeding the
131 /// maximum must be invalid.
132 unsigned RefsUpperBound;
135 BitcodeReaderMetadataList(LLVMContext &C, size_t RefsUpperBound)
137 RefsUpperBound(std::min((size_t)std::numeric_limits<unsigned>::max(),
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(); }
149 Metadata *operator[](unsigned i) const {
150 assert(i < MetadataPtrs.size());
151 return MetadataPtrs[i];
154 Metadata *lookup(unsigned I) const {
155 if (I < MetadataPtrs.size())
156 return MetadataPtrs[I];
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);
167 /// Return the given metadata, creating a replaceable forward reference if
169 Metadata *getMetadataFwdRef(unsigned Idx);
171 /// Return the given metadata only if it is fully resolved.
173 /// Gives the same result as \a lookup(), unless \a MDNode::isResolved()
174 /// would give \c false.
175 Metadata *getMetadataIfResolved(unsigned Idx);
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();
186 /// Upgrade a type that had an MDString reference.
187 void addTypeRef(MDString &UUID, DICompositeType &CT);
189 /// Upgrade a type that had an MDString reference.
190 Metadata *upgradeTypeRef(Metadata *MaybeUUID);
192 /// Upgrade a type ref array that may have MDString references.
193 Metadata *upgradeTypeRefArray(Metadata *MaybeTuple);
196 Metadata *resolveTypeRefArray(Metadata *MaybeTuple);
199 void BitcodeReaderMetadataList::assignValue(Metadata *MD, unsigned Idx) {
200 if (auto *MDN = dyn_cast<MDNode>(MD))
201 if (!MDN->isResolved())
202 UnresolvedNodes.insert(Idx);
212 TrackingMDRef &OldMD = MetadataPtrs[Idx];
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);
224 Metadata *BitcodeReaderMetadataList::getMetadataFwdRef(unsigned Idx) {
225 // Bail out for a clearly invalid value.
226 if (Idx >= RefsUpperBound)
232 if (Metadata *MD = MetadataPtrs[Idx])
235 // Track forward refs to be resolved later.
236 ForwardReference.insert(Idx);
238 // Create and return a placeholder, which will later be RAUW'd.
239 ++NumMDNodeTemporary;
240 Metadata *MD = MDNode::getTemporary(Context, None).release();
241 MetadataPtrs[Idx].reset(MD);
245 Metadata *BitcodeReaderMetadataList::getMetadataIfResolved(unsigned Idx) {
246 Metadata *MD = lookup(Idx);
247 if (auto *N = dyn_cast_or_null<MDNode>(MD))
248 if (!N->isResolved())
253 MDNode *BitcodeReaderMetadataList::getMDNodeFwdRefOrNull(unsigned Idx) {
254 return dyn_cast_or_null<MDNode>(getMetadataFwdRef(Idx));
257 void BitcodeReaderMetadataList::tryToResolveCycles() {
258 if (!ForwardReference.empty())
259 // Still forward references... can't resolve cycles.
262 // Give up on finding a full definition for any forward decls that remain.
263 for (const auto &Ref : OldTypeRefs.FwdDecls)
264 OldTypeRefs.Final.insert(Ref);
265 OldTypeRefs.FwdDecls.clear();
267 // Upgrade from old type ref arrays. In strange cases, this could add to
268 // OldTypeRefs.Unknown.
269 for (const auto &Array : OldTypeRefs.Arrays)
270 Array.second->replaceAllUsesWith(resolveTypeRefArray(Array.first.get()));
271 OldTypeRefs.Arrays.clear();
273 // Replace old string-based type refs with the resolved node, if possible.
274 // If we haven't seen the node, leave it to the verifier to complain about
275 // the invalid string reference.
276 for (const auto &Ref : OldTypeRefs.Unknown) {
277 if (DICompositeType *CT = OldTypeRefs.Final.lookup(Ref.first))
278 Ref.second->replaceAllUsesWith(CT);
280 Ref.second->replaceAllUsesWith(Ref.first);
282 OldTypeRefs.Unknown.clear();
284 if (UnresolvedNodes.empty())
288 // Resolve any cycles.
289 for (unsigned I : UnresolvedNodes) {
290 auto &MD = MetadataPtrs[I];
291 auto *N = dyn_cast_or_null<MDNode>(MD);
295 assert(!N->isTemporary() && "Unexpected forward reference");
299 // Make sure we return early again until there's another unresolved ref.
300 UnresolvedNodes.clear();
303 void BitcodeReaderMetadataList::addTypeRef(MDString &UUID,
304 DICompositeType &CT) {
305 assert(CT.getRawIdentifier() == &UUID && "Mismatched UUID");
306 if (CT.isForwardDecl())
307 OldTypeRefs.FwdDecls.insert(std::make_pair(&UUID, &CT));
309 OldTypeRefs.Final.insert(std::make_pair(&UUID, &CT));
312 Metadata *BitcodeReaderMetadataList::upgradeTypeRef(Metadata *MaybeUUID) {
313 auto *UUID = dyn_cast_or_null<MDString>(MaybeUUID);
314 if (LLVM_LIKELY(!UUID))
317 if (auto *CT = OldTypeRefs.Final.lookup(UUID))
320 auto &Ref = OldTypeRefs.Unknown[UUID];
322 Ref = MDNode::getTemporary(Context, None);
326 Metadata *BitcodeReaderMetadataList::upgradeTypeRefArray(Metadata *MaybeTuple) {
327 auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
328 if (!Tuple || Tuple->isDistinct())
331 // Look through the array immediately if possible.
332 if (!Tuple->isTemporary())
333 return resolveTypeRefArray(Tuple);
335 // Create and return a placeholder to use for now. Eventually
336 // resolveTypeRefArrays() will be resolve this forward reference.
337 OldTypeRefs.Arrays.emplace_back(
338 std::piecewise_construct, std::forward_as_tuple(Tuple),
339 std::forward_as_tuple(MDTuple::getTemporary(Context, None)));
340 return OldTypeRefs.Arrays.back().second.get();
343 Metadata *BitcodeReaderMetadataList::resolveTypeRefArray(Metadata *MaybeTuple) {
344 auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
345 if (!Tuple || Tuple->isDistinct())
348 // Look through the DITypeRefArray, upgrading each DIType *.
349 SmallVector<Metadata *, 32> Ops;
350 Ops.reserve(Tuple->getNumOperands());
351 for (Metadata *MD : Tuple->operands())
352 Ops.push_back(upgradeTypeRef(MD));
354 return MDTuple::get(Context, Ops);
359 class PlaceholderQueue {
360 // Placeholders would thrash around when moved, so store in a std::deque
361 // instead of some sort of vector.
362 std::deque<DistinctMDOperandPlaceholder> PHs;
365 ~PlaceholderQueue() {
366 assert(empty() && "PlaceholderQueue hasn't been flushed before being destroyed");
368 bool empty() const { return PHs.empty(); }
369 DistinctMDOperandPlaceholder &getPlaceholderOp(unsigned ID);
370 void flush(BitcodeReaderMetadataList &MetadataList);
372 /// Return the list of temporaries nodes in the queue, these need to be
373 /// loaded before we can flush the queue.
374 void getTemporaries(BitcodeReaderMetadataList &MetadataList,
375 DenseSet<unsigned> &Temporaries) {
376 for (auto &PH : PHs) {
377 auto ID = PH.getID();
378 auto *MD = MetadataList.lookup(ID);
380 Temporaries.insert(ID);
383 auto *N = dyn_cast_or_null<MDNode>(MD);
384 if (N && N->isTemporary())
385 Temporaries.insert(ID);
390 } // end anonymous namespace
392 DistinctMDOperandPlaceholder &PlaceholderQueue::getPlaceholderOp(unsigned ID) {
393 PHs.emplace_back(ID);
397 void PlaceholderQueue::flush(BitcodeReaderMetadataList &MetadataList) {
398 while (!PHs.empty()) {
399 auto *MD = MetadataList.lookup(PHs.front().getID());
400 assert(MD && "Flushing placeholder on unassigned MD");
402 if (auto *MDN = dyn_cast<MDNode>(MD))
403 assert(MDN->isResolved() &&
404 "Flushing Placeholder while cycles aren't resolved");
406 PHs.front().replaceUseWith(MD);
411 } // anonymous namespace
413 static Error error(const Twine &Message) {
414 return make_error<StringError>(
415 Message, make_error_code(BitcodeError::CorruptedBitcode));
418 class MetadataLoader::MetadataLoaderImpl {
419 BitcodeReaderMetadataList MetadataList;
420 BitcodeReaderValueList &ValueList;
421 BitstreamCursor &Stream;
422 LLVMContext &Context;
424 std::function<Type *(unsigned)> getTypeByID;
426 /// Cursor associated with the lazy-loading of Metadata. This is the easy way
427 /// to keep around the right "context" (Abbrev list) to be able to jump in
428 /// the middle of the metadata block and load any record.
429 BitstreamCursor IndexCursor;
431 /// Index that keeps track of MDString values.
432 std::vector<StringRef> MDStringRef;
434 /// On-demand loading of a single MDString. Requires the index above to be
436 MDString *lazyLoadOneMDString(unsigned Idx);
438 /// Index that keeps track of where to find a metadata record in the stream.
439 std::vector<uint64_t> GlobalMetadataBitPosIndex;
441 /// Cursor position of the start of the global decl attachments, to enable
442 /// loading using the index built for lazy loading, instead of forward
444 uint64_t GlobalDeclAttachmentPos = 0;
447 /// Sanity check that we end up parsing all of the global decl attachments.
448 unsigned NumGlobalDeclAttachSkipped = 0;
449 unsigned NumGlobalDeclAttachParsed = 0;
452 /// Load the global decl attachments, using the index built for lazy loading.
453 Expected<bool> loadGlobalDeclAttachments();
455 /// Populate the index above to enable lazily loading of metadata, and load
456 /// the named metadata as well as the transitively referenced global
458 Expected<bool> lazyLoadModuleMetadataBlock();
460 /// On-demand loading of a single metadata. Requires the index above to be
462 void lazyLoadOneMetadata(unsigned Idx, PlaceholderQueue &Placeholders);
464 // Keep mapping of seens pair of old-style CU <-> SP, and update pointers to
465 // point from SP to CU after a block is completly parsed.
466 std::vector<std::pair<DICompileUnit *, Metadata *>> CUSubprograms;
468 /// Functions that need to be matched with subprograms when upgrading old
470 SmallDenseMap<Function *, DISubprogram *, 16> FunctionsWithSPs;
472 // Map the bitcode's custom MDKind ID to the Module's MDKind ID.
473 DenseMap<unsigned, unsigned> MDKindMap;
475 bool StripTBAA = false;
476 bool HasSeenOldLoopTags = false;
477 bool NeedUpgradeToDIGlobalVariableExpression = false;
478 bool NeedDeclareExpressionUpgrade = false;
480 /// True if metadata is being parsed for a module being ThinLTO imported.
481 bool IsImporting = false;
483 Error parseOneMetadata(SmallVectorImpl<uint64_t> &Record, unsigned Code,
484 PlaceholderQueue &Placeholders, StringRef Blob,
485 unsigned &NextMetadataNo);
486 Error parseMetadataStrings(ArrayRef<uint64_t> Record, StringRef Blob,
487 function_ref<void(StringRef)> CallBack);
488 Error parseGlobalObjectAttachment(GlobalObject &GO,
489 ArrayRef<uint64_t> Record);
490 Error parseMetadataKindRecord(SmallVectorImpl<uint64_t> &Record);
492 void resolveForwardRefsAndPlaceholders(PlaceholderQueue &Placeholders);
494 /// Upgrade old-style CU <-> SP pointers to point from SP to CU.
495 void upgradeCUSubprograms() {
496 for (auto CU_SP : CUSubprograms)
497 if (auto *SPs = dyn_cast_or_null<MDTuple>(CU_SP.second))
498 for (auto &Op : SPs->operands())
499 if (auto *SP = dyn_cast_or_null<DISubprogram>(Op))
500 SP->replaceUnit(CU_SP.first);
501 CUSubprograms.clear();
504 /// Upgrade old-style bare DIGlobalVariables to DIGlobalVariableExpressions.
505 void upgradeCUVariables() {
506 if (!NeedUpgradeToDIGlobalVariableExpression)
509 // Upgrade list of variables attached to the CUs.
510 if (NamedMDNode *CUNodes = TheModule.getNamedMetadata("llvm.dbg.cu"))
511 for (unsigned I = 0, E = CUNodes->getNumOperands(); I != E; ++I) {
512 auto *CU = cast<DICompileUnit>(CUNodes->getOperand(I));
513 if (auto *GVs = dyn_cast_or_null<MDTuple>(CU->getRawGlobalVariables()))
514 for (unsigned I = 0; I < GVs->getNumOperands(); I++)
516 dyn_cast_or_null<DIGlobalVariable>(GVs->getOperand(I))) {
517 auto *DGVE = DIGlobalVariableExpression::getDistinct(
518 Context, GV, DIExpression::get(Context, {}));
519 GVs->replaceOperandWith(I, DGVE);
523 // Upgrade variables attached to globals.
524 for (auto &GV : TheModule.globals()) {
525 SmallVector<MDNode *, 1> MDs;
526 GV.getMetadata(LLVMContext::MD_dbg, MDs);
527 GV.eraseMetadata(LLVMContext::MD_dbg);
529 if (auto *DGV = dyn_cast<DIGlobalVariable>(MD)) {
530 auto *DGVE = DIGlobalVariableExpression::getDistinct(
531 Context, DGV, DIExpression::get(Context, {}));
532 GV.addMetadata(LLVMContext::MD_dbg, *DGVE);
534 GV.addMetadata(LLVMContext::MD_dbg, *MD);
538 /// Remove a leading DW_OP_deref from DIExpressions in a dbg.declare that
539 /// describes a function argument.
540 void upgradeDeclareExpressions(Function &F) {
541 if (!NeedDeclareExpressionUpgrade)
546 if (auto *DDI = dyn_cast<DbgDeclareInst>(&I))
547 if (auto *DIExpr = DDI->getExpression())
548 if (DIExpr->startsWithDeref() &&
549 dyn_cast_or_null<Argument>(DDI->getAddress())) {
550 SmallVector<uint64_t, 8> Ops;
551 Ops.append(std::next(DIExpr->elements_begin()),
552 DIExpr->elements_end());
553 auto *E = DIExpression::get(Context, Ops);
554 DDI->setOperand(2, MetadataAsValue::get(Context, E));
558 /// Upgrade the expression from previous versions.
559 Error upgradeDIExpression(uint64_t FromVersion,
560 MutableArrayRef<uint64_t> &Expr,
561 SmallVectorImpl<uint64_t> &Buffer) {
562 auto N = Expr.size();
563 switch (FromVersion) {
565 return error("Invalid record");
567 if (N >= 3 && Expr[N - 3] == dwarf::DW_OP_bit_piece)
568 Expr[N - 3] = dwarf::DW_OP_LLVM_fragment;
571 // Move DW_OP_deref to the end.
572 if (N && Expr[0] == dwarf::DW_OP_deref) {
573 auto End = Expr.end();
574 if (Expr.size() >= 3 &&
575 *std::prev(End, 3) == dwarf::DW_OP_LLVM_fragment)
576 End = std::prev(End, 3);
577 std::move(std::next(Expr.begin()), End, Expr.begin());
578 *std::prev(End) = dwarf::DW_OP_deref;
580 NeedDeclareExpressionUpgrade = true;
583 // Change DW_OP_plus to DW_OP_plus_uconst.
584 // Change DW_OP_minus to DW_OP_uconst, DW_OP_minus
585 auto SubExpr = ArrayRef<uint64_t>(Expr);
586 while (!SubExpr.empty()) {
587 // Skip past other operators with their operands
588 // for this version of the IR, obtained from
589 // from historic DIExpression::ExprOperand::getSize().
591 switch (SubExpr.front()) {
595 case dwarf::DW_OP_constu:
596 case dwarf::DW_OP_minus:
597 case dwarf::DW_OP_plus:
600 case dwarf::DW_OP_LLVM_fragment:
605 // If the expression is malformed, make sure we don't
606 // copy more elements than we should.
607 HistoricSize = std::min(SubExpr.size(), HistoricSize);
608 ArrayRef<uint64_t> Args = SubExpr.slice(1, HistoricSize-1);
610 switch (SubExpr.front()) {
611 case dwarf::DW_OP_plus:
612 Buffer.push_back(dwarf::DW_OP_plus_uconst);
613 Buffer.append(Args.begin(), Args.end());
615 case dwarf::DW_OP_minus:
616 Buffer.push_back(dwarf::DW_OP_constu);
617 Buffer.append(Args.begin(), Args.end());
618 Buffer.push_back(dwarf::DW_OP_minus);
621 Buffer.push_back(*SubExpr.begin());
622 Buffer.append(Args.begin(), Args.end());
626 // Continue with remaining elements.
627 SubExpr = SubExpr.slice(HistoricSize);
629 Expr = MutableArrayRef<uint64_t>(Buffer);
637 return Error::success();
640 void upgradeDebugInfo() {
641 upgradeCUSubprograms();
642 upgradeCUVariables();
646 MetadataLoaderImpl(BitstreamCursor &Stream, Module &TheModule,
647 BitcodeReaderValueList &ValueList,
648 std::function<Type *(unsigned)> getTypeByID,
650 : MetadataList(TheModule.getContext(), Stream.SizeInBytes()),
651 ValueList(ValueList), Stream(Stream), Context(TheModule.getContext()),
652 TheModule(TheModule), getTypeByID(std::move(getTypeByID)),
653 IsImporting(IsImporting) {}
655 Error parseMetadata(bool ModuleLevel);
657 bool hasFwdRefs() const { return MetadataList.hasFwdRefs(); }
659 Metadata *getMetadataFwdRefOrLoad(unsigned ID) {
660 if (ID < MDStringRef.size())
661 return lazyLoadOneMDString(ID);
662 if (auto *MD = MetadataList.lookup(ID))
664 // If lazy-loading is enabled, we try recursively to load the operand
665 // instead of creating a temporary.
666 if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
667 PlaceholderQueue Placeholders;
668 lazyLoadOneMetadata(ID, Placeholders);
669 resolveForwardRefsAndPlaceholders(Placeholders);
670 return MetadataList.lookup(ID);
672 return MetadataList.getMetadataFwdRef(ID);
675 DISubprogram *lookupSubprogramForFunction(Function *F) {
676 return FunctionsWithSPs.lookup(F);
679 bool hasSeenOldLoopTags() const { return HasSeenOldLoopTags; }
681 Error parseMetadataAttachment(
682 Function &F, const SmallVectorImpl<Instruction *> &InstructionList);
684 Error parseMetadataKinds();
686 void setStripTBAA(bool Value) { StripTBAA = Value; }
687 bool isStrippingTBAA() const { return StripTBAA; }
689 unsigned size() const { return MetadataList.size(); }
690 void shrinkTo(unsigned N) { MetadataList.shrinkTo(N); }
691 void upgradeDebugIntrinsics(Function &F) { upgradeDeclareExpressions(F); }
695 MetadataLoader::MetadataLoaderImpl::lazyLoadModuleMetadataBlock() {
696 IndexCursor = Stream;
697 SmallVector<uint64_t, 64> Record;
698 GlobalDeclAttachmentPos = 0;
699 // Get the abbrevs, and preload record positions to make them lazy-loadable.
701 uint64_t SavedPos = IndexCursor.GetCurrentBitNo();
702 Expected<BitstreamEntry> MaybeEntry = IndexCursor.advanceSkippingSubblocks(
703 BitstreamCursor::AF_DontPopBlockAtEnd);
705 return MaybeEntry.takeError();
706 BitstreamEntry Entry = MaybeEntry.get();
708 switch (Entry.Kind) {
709 case BitstreamEntry::SubBlock: // Handled for us already.
710 case BitstreamEntry::Error:
711 return error("Malformed block");
712 case BitstreamEntry::EndBlock: {
715 case BitstreamEntry::Record: {
716 // The interesting case.
718 uint64_t CurrentPos = IndexCursor.GetCurrentBitNo();
719 Expected<unsigned> MaybeCode = IndexCursor.skipRecord(Entry.ID);
721 return MaybeCode.takeError();
722 unsigned Code = MaybeCode.get();
724 case bitc::METADATA_STRINGS: {
725 // Rewind and parse the strings.
726 if (Error Err = IndexCursor.JumpToBit(CurrentPos))
727 return std::move(Err);
730 if (Expected<unsigned> MaybeRecord =
731 IndexCursor.readRecord(Entry.ID, Record, &Blob))
734 return MaybeRecord.takeError();
735 unsigned NumStrings = Record[0];
736 MDStringRef.reserve(NumStrings);
737 auto IndexNextMDString = [&](StringRef Str) {
738 MDStringRef.push_back(Str);
740 if (auto Err = parseMetadataStrings(Record, Blob, IndexNextMDString))
741 return std::move(Err);
744 case bitc::METADATA_INDEX_OFFSET: {
745 // This is the offset to the index, when we see this we skip all the
746 // records and load only an index to these.
747 if (Error Err = IndexCursor.JumpToBit(CurrentPos))
748 return std::move(Err);
750 if (Expected<unsigned> MaybeRecord =
751 IndexCursor.readRecord(Entry.ID, Record))
754 return MaybeRecord.takeError();
755 if (Record.size() != 2)
756 return error("Invalid record");
757 auto Offset = Record[0] + (Record[1] << 32);
758 auto BeginPos = IndexCursor.GetCurrentBitNo();
759 if (Error Err = IndexCursor.JumpToBit(BeginPos + Offset))
760 return std::move(Err);
761 Expected<BitstreamEntry> MaybeEntry =
762 IndexCursor.advanceSkippingSubblocks(
763 BitstreamCursor::AF_DontPopBlockAtEnd);
765 return MaybeEntry.takeError();
766 Entry = MaybeEntry.get();
767 assert(Entry.Kind == BitstreamEntry::Record &&
768 "Corrupted bitcode: Expected `Record` when trying to find the "
771 if (Expected<unsigned> MaybeCode =
772 IndexCursor.readRecord(Entry.ID, Record))
773 assert(MaybeCode.get() == bitc::METADATA_INDEX &&
774 "Corrupted bitcode: Expected `METADATA_INDEX` when trying to "
775 "find the Metadata index");
777 return MaybeCode.takeError();
779 auto CurrentValue = BeginPos;
780 GlobalMetadataBitPosIndex.reserve(Record.size());
781 for (auto &Elt : Record) {
783 GlobalMetadataBitPosIndex.push_back(CurrentValue);
787 case bitc::METADATA_INDEX:
788 // We don't expect to get there, the Index is loaded when we encounter
790 return error("Corrupted Metadata block");
791 case bitc::METADATA_NAME: {
792 // Named metadata need to be materialized now and aren't deferred.
793 if (Error Err = IndexCursor.JumpToBit(CurrentPos))
794 return std::move(Err);
798 if (Expected<unsigned> MaybeCode =
799 IndexCursor.readRecord(Entry.ID, Record)) {
800 Code = MaybeCode.get();
801 assert(Code == bitc::METADATA_NAME);
803 return MaybeCode.takeError();
805 // Read name of the named metadata.
806 SmallString<8> Name(Record.begin(), Record.end());
807 if (Expected<unsigned> MaybeCode = IndexCursor.ReadCode())
808 Code = MaybeCode.get();
810 return MaybeCode.takeError();
812 // Named Metadata comes in two parts, we expect the name to be followed
815 if (Expected<unsigned> MaybeNextBitCode =
816 IndexCursor.readRecord(Code, Record))
817 assert(MaybeNextBitCode.get() == bitc::METADATA_NAMED_NODE);
819 return MaybeNextBitCode.takeError();
821 // Read named metadata elements.
822 unsigned Size = Record.size();
823 NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name);
824 for (unsigned i = 0; i != Size; ++i) {
825 // FIXME: We could use a placeholder here, however NamedMDNode are
826 // taking MDNode as operand and not using the Metadata infrastructure.
827 // It is acknowledged by 'TODO: Inherit from Metadata' in the
828 // NamedMDNode class definition.
829 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
830 assert(MD && "Invalid metadata: expect fwd ref to MDNode");
835 case bitc::METADATA_GLOBAL_DECL_ATTACHMENT: {
836 if (!GlobalDeclAttachmentPos)
837 GlobalDeclAttachmentPos = SavedPos;
839 NumGlobalDeclAttachSkipped++;
843 case bitc::METADATA_KIND:
844 case bitc::METADATA_STRING_OLD:
845 case bitc::METADATA_OLD_FN_NODE:
846 case bitc::METADATA_OLD_NODE:
847 case bitc::METADATA_VALUE:
848 case bitc::METADATA_DISTINCT_NODE:
849 case bitc::METADATA_NODE:
850 case bitc::METADATA_LOCATION:
851 case bitc::METADATA_GENERIC_DEBUG:
852 case bitc::METADATA_SUBRANGE:
853 case bitc::METADATA_ENUMERATOR:
854 case bitc::METADATA_BASIC_TYPE:
855 case bitc::METADATA_STRING_TYPE:
856 case bitc::METADATA_DERIVED_TYPE:
857 case bitc::METADATA_COMPOSITE_TYPE:
858 case bitc::METADATA_SUBROUTINE_TYPE:
859 case bitc::METADATA_MODULE:
860 case bitc::METADATA_FILE:
861 case bitc::METADATA_COMPILE_UNIT:
862 case bitc::METADATA_SUBPROGRAM:
863 case bitc::METADATA_LEXICAL_BLOCK:
864 case bitc::METADATA_LEXICAL_BLOCK_FILE:
865 case bitc::METADATA_NAMESPACE:
866 case bitc::METADATA_COMMON_BLOCK:
867 case bitc::METADATA_MACRO:
868 case bitc::METADATA_MACRO_FILE:
869 case bitc::METADATA_TEMPLATE_TYPE:
870 case bitc::METADATA_TEMPLATE_VALUE:
871 case bitc::METADATA_GLOBAL_VAR:
872 case bitc::METADATA_LOCAL_VAR:
873 case bitc::METADATA_LABEL:
874 case bitc::METADATA_EXPRESSION:
875 case bitc::METADATA_OBJC_PROPERTY:
876 case bitc::METADATA_IMPORTED_ENTITY:
877 case bitc::METADATA_GLOBAL_VAR_EXPR:
878 case bitc::METADATA_GENERIC_SUBRANGE:
879 // We don't expect to see any of these, if we see one, give up on
880 // lazy-loading and fallback.
882 GlobalMetadataBitPosIndex.clear();
891 // Load the global decl attachments after building the lazy loading index.
892 // We don't load them "lazily" - all global decl attachments must be
893 // parsed since they aren't materialized on demand. However, by delaying
894 // their parsing until after the index is created, we can use the index
895 // instead of creating temporaries.
896 Expected<bool> MetadataLoader::MetadataLoaderImpl::loadGlobalDeclAttachments() {
897 // Nothing to do if we didn't find any of these metadata records.
898 if (!GlobalDeclAttachmentPos)
900 // Use a temporary cursor so that we don't mess up the main Stream cursor or
901 // the lazy loading IndexCursor (which holds the necessary abbrev ids).
902 BitstreamCursor TempCursor = Stream;
903 SmallVector<uint64_t, 64> Record;
904 // Jump to the position before the first global decl attachment, so we can
905 // scan for the first BitstreamEntry record.
906 if (Error Err = TempCursor.JumpToBit(GlobalDeclAttachmentPos))
907 return std::move(Err);
909 Expected<BitstreamEntry> MaybeEntry = TempCursor.advanceSkippingSubblocks(
910 BitstreamCursor::AF_DontPopBlockAtEnd);
912 return MaybeEntry.takeError();
913 BitstreamEntry Entry = MaybeEntry.get();
915 switch (Entry.Kind) {
916 case BitstreamEntry::SubBlock: // Handled for us already.
917 case BitstreamEntry::Error:
918 return error("Malformed block");
919 case BitstreamEntry::EndBlock:
920 // Sanity check that we parsed them all.
921 assert(NumGlobalDeclAttachSkipped == NumGlobalDeclAttachParsed);
923 case BitstreamEntry::Record:
926 uint64_t CurrentPos = TempCursor.GetCurrentBitNo();
927 Expected<unsigned> MaybeCode = TempCursor.skipRecord(Entry.ID);
929 return MaybeCode.takeError();
930 if (MaybeCode.get() != bitc::METADATA_GLOBAL_DECL_ATTACHMENT) {
931 // Anything other than a global decl attachment signals the end of
932 // these records. sanity check that we parsed them all.
933 assert(NumGlobalDeclAttachSkipped == NumGlobalDeclAttachParsed);
937 NumGlobalDeclAttachParsed++;
939 // FIXME: we need to do this early because we don't materialize global
941 if (Error Err = TempCursor.JumpToBit(CurrentPos))
942 return std::move(Err);
944 if (Expected<unsigned> MaybeRecord =
945 TempCursor.readRecord(Entry.ID, Record))
948 return MaybeRecord.takeError();
949 if (Record.size() % 2 == 0)
950 return error("Invalid record");
951 unsigned ValueID = Record[0];
952 if (ValueID >= ValueList.size())
953 return error("Invalid record");
954 if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID])) {
955 // Need to save and restore the current position since
956 // parseGlobalObjectAttachment will resolve all forward references which
957 // would require parsing from locations stored in the index.
958 CurrentPos = TempCursor.GetCurrentBitNo();
959 if (Error Err = parseGlobalObjectAttachment(
960 *GO, ArrayRef<uint64_t>(Record).slice(1)))
961 return std::move(Err);
962 if (Error Err = TempCursor.JumpToBit(CurrentPos))
963 return std::move(Err);
968 /// Parse a METADATA_BLOCK. If ModuleLevel is true then we are parsing
969 /// module level metadata.
970 Error MetadataLoader::MetadataLoaderImpl::parseMetadata(bool ModuleLevel) {
971 if (!ModuleLevel && MetadataList.hasFwdRefs())
972 return error("Invalid metadata: fwd refs into function blocks");
974 // Record the entry position so that we can jump back here and efficiently
975 // skip the whole block in case we lazy-load.
976 auto EntryPos = Stream.GetCurrentBitNo();
978 if (Error Err = Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID))
981 SmallVector<uint64_t, 64> Record;
982 PlaceholderQueue Placeholders;
984 // We lazy-load module-level metadata: we build an index for each record, and
985 // then load individual record as needed, starting with the named metadata.
986 if (ModuleLevel && IsImporting && MetadataList.empty() &&
987 !DisableLazyLoading) {
988 auto SuccessOrErr = lazyLoadModuleMetadataBlock();
990 return SuccessOrErr.takeError();
991 if (SuccessOrErr.get()) {
992 // An index was successfully created and we will be able to load metadata
994 MetadataList.resize(MDStringRef.size() +
995 GlobalMetadataBitPosIndex.size());
997 // Now that we have built the index, load the global decl attachments
998 // that were deferred during that process. This avoids creating
1000 SuccessOrErr = loadGlobalDeclAttachments();
1002 return SuccessOrErr.takeError();
1003 assert(SuccessOrErr.get());
1005 // Reading the named metadata created forward references and/or
1006 // placeholders, that we flush here.
1007 resolveForwardRefsAndPlaceholders(Placeholders);
1009 // Return at the beginning of the block, since it is easy to skip it
1010 // entirely from there.
1011 Stream.ReadBlockEnd(); // Pop the abbrev block context.
1012 if (Error Err = IndexCursor.JumpToBit(EntryPos))
1014 if (Error Err = Stream.SkipBlock()) {
1015 // FIXME this drops the error on the floor, which
1016 // ThinLTO/X86/debuginfo-cu-import.ll relies on.
1017 consumeError(std::move(Err));
1018 return Error::success();
1020 return Error::success();
1022 // Couldn't load an index, fallback to loading all the block "old-style".
1025 unsigned NextMetadataNo = MetadataList.size();
1027 // Read all the records.
1029 Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
1031 return MaybeEntry.takeError();
1032 BitstreamEntry Entry = MaybeEntry.get();
1034 switch (Entry.Kind) {
1035 case BitstreamEntry::SubBlock: // Handled for us already.
1036 case BitstreamEntry::Error:
1037 return error("Malformed block");
1038 case BitstreamEntry::EndBlock:
1039 resolveForwardRefsAndPlaceholders(Placeholders);
1041 return Error::success();
1042 case BitstreamEntry::Record:
1043 // The interesting case.
1050 ++NumMDRecordLoaded;
1051 if (Expected<unsigned> MaybeCode =
1052 Stream.readRecord(Entry.ID, Record, &Blob)) {
1053 if (Error Err = parseOneMetadata(Record, MaybeCode.get(), Placeholders,
1054 Blob, NextMetadataNo))
1057 return MaybeCode.takeError();
1061 MDString *MetadataLoader::MetadataLoaderImpl::lazyLoadOneMDString(unsigned ID) {
1062 ++NumMDStringLoaded;
1063 if (Metadata *MD = MetadataList.lookup(ID))
1064 return cast<MDString>(MD);
1065 auto MDS = MDString::get(Context, MDStringRef[ID]);
1066 MetadataList.assignValue(MDS, ID);
1070 void MetadataLoader::MetadataLoaderImpl::lazyLoadOneMetadata(
1071 unsigned ID, PlaceholderQueue &Placeholders) {
1072 assert(ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size());
1073 assert(ID >= MDStringRef.size() && "Unexpected lazy-loading of MDString");
1074 // Lookup first if the metadata hasn't already been loaded.
1075 if (auto *MD = MetadataList.lookup(ID)) {
1076 auto *N = cast<MDNode>(MD);
1077 if (!N->isTemporary())
1080 SmallVector<uint64_t, 64> Record;
1082 if (Error Err = IndexCursor.JumpToBit(
1083 GlobalMetadataBitPosIndex[ID - MDStringRef.size()]))
1084 report_fatal_error("lazyLoadOneMetadata failed jumping: " +
1085 toString(std::move(Err)));
1086 Expected<BitstreamEntry> MaybeEntry = IndexCursor.advanceSkippingSubblocks();
1088 // FIXME this drops the error on the floor.
1089 report_fatal_error("lazyLoadOneMetadata failed advanceSkippingSubblocks: " +
1090 toString(MaybeEntry.takeError()));
1091 BitstreamEntry Entry = MaybeEntry.get();
1092 ++NumMDRecordLoaded;
1093 if (Expected<unsigned> MaybeCode =
1094 IndexCursor.readRecord(Entry.ID, Record, &Blob)) {
1096 parseOneMetadata(Record, MaybeCode.get(), Placeholders, Blob, ID))
1097 report_fatal_error("Can't lazyload MD, parseOneMetadata: " +
1098 toString(std::move(Err)));
1100 report_fatal_error("Can't lazyload MD: " + toString(MaybeCode.takeError()));
1103 /// Ensure that all forward-references and placeholders are resolved.
1104 /// Iteratively lazy-loading metadata on-demand if needed.
1105 void MetadataLoader::MetadataLoaderImpl::resolveForwardRefsAndPlaceholders(
1106 PlaceholderQueue &Placeholders) {
1107 DenseSet<unsigned> Temporaries;
1109 // Populate Temporaries with the placeholders that haven't been loaded yet.
1110 Placeholders.getTemporaries(MetadataList, Temporaries);
1112 // If we don't have any temporary, or FwdReference, we're done!
1113 if (Temporaries.empty() && !MetadataList.hasFwdRefs())
1116 // First, load all the temporaries. This can add new placeholders or
1117 // forward references.
1118 for (auto ID : Temporaries)
1119 lazyLoadOneMetadata(ID, Placeholders);
1120 Temporaries.clear();
1122 // Second, load the forward-references. This can also add new placeholders
1123 // or forward references.
1124 while (MetadataList.hasFwdRefs())
1125 lazyLoadOneMetadata(MetadataList.getNextFwdRef(), Placeholders);
1127 // At this point we don't have any forward reference remaining, or temporary
1128 // that haven't been loaded. We can safely drop RAUW support and mark cycles
1130 MetadataList.tryToResolveCycles();
1132 // Finally, everything is in place, we can replace the placeholders operands
1133 // with the final node they refer to.
1134 Placeholders.flush(MetadataList);
1137 Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata(
1138 SmallVectorImpl<uint64_t> &Record, unsigned Code,
1139 PlaceholderQueue &Placeholders, StringRef Blob, unsigned &NextMetadataNo) {
1141 bool IsDistinct = false;
1142 auto getMD = [&](unsigned ID) -> Metadata * {
1143 if (ID < MDStringRef.size())
1144 return lazyLoadOneMDString(ID);
1146 if (auto *MD = MetadataList.lookup(ID))
1148 // If lazy-loading is enabled, we try recursively to load the operand
1149 // instead of creating a temporary.
1150 if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
1151 // Create a temporary for the node that is referencing the operand we
1152 // will lazy-load. It is needed before recursing in case there are
1154 MetadataList.getMetadataFwdRef(NextMetadataNo);
1155 lazyLoadOneMetadata(ID, Placeholders);
1156 return MetadataList.lookup(ID);
1158 // Return a temporary.
1159 return MetadataList.getMetadataFwdRef(ID);
1161 if (auto *MD = MetadataList.getMetadataIfResolved(ID))
1163 return &Placeholders.getPlaceholderOp(ID);
1165 auto getMDOrNull = [&](unsigned ID) -> Metadata * {
1167 return getMD(ID - 1);
1170 auto getMDOrNullWithoutPlaceholders = [&](unsigned ID) -> Metadata * {
1172 return MetadataList.getMetadataFwdRef(ID - 1);
1175 auto getMDString = [&](unsigned ID) -> MDString * {
1176 // This requires that the ID is not really a forward reference. In
1177 // particular, the MDString must already have been resolved.
1178 auto MDS = getMDOrNull(ID);
1179 return cast_or_null<MDString>(MDS);
1182 // Support for old type refs.
1183 auto getDITypeRefOrNull = [&](unsigned ID) {
1184 return MetadataList.upgradeTypeRef(getMDOrNull(ID));
1187 #define GET_OR_DISTINCT(CLASS, ARGS) \
1188 (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
1191 default: // Default behavior: ignore.
1193 case bitc::METADATA_NAME: {
1194 // Read name of the named metadata.
1195 SmallString<8> Name(Record.begin(), Record.end());
1197 Expected<unsigned> MaybeCode = Stream.ReadCode();
1199 return MaybeCode.takeError();
1200 Code = MaybeCode.get();
1202 ++NumMDRecordLoaded;
1203 if (Expected<unsigned> MaybeNextBitCode = Stream.readRecord(Code, Record)) {
1204 if (MaybeNextBitCode.get() != bitc::METADATA_NAMED_NODE)
1205 return error("METADATA_NAME not followed by METADATA_NAMED_NODE");
1207 return MaybeNextBitCode.takeError();
1209 // Read named metadata elements.
1210 unsigned Size = Record.size();
1211 NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name);
1212 for (unsigned i = 0; i != Size; ++i) {
1213 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
1215 return error("Invalid named metadata: expect fwd ref to MDNode");
1216 NMD->addOperand(MD);
1220 case bitc::METADATA_OLD_FN_NODE: {
1221 // Deprecated, but still needed to read old bitcode files.
1222 // This is a LocalAsMetadata record, the only type of function-local
1224 if (Record.size() % 2 == 1)
1225 return error("Invalid record");
1227 // If this isn't a LocalAsMetadata record, we're dropping it. This used
1228 // to be legal, but there's no upgrade path.
1229 auto dropRecord = [&] {
1230 MetadataList.assignValue(MDNode::get(Context, None), NextMetadataNo);
1233 if (Record.size() != 2) {
1238 Type *Ty = getTypeByID(Record[0]);
1239 if (Ty->isMetadataTy() || Ty->isVoidTy()) {
1244 MetadataList.assignValue(
1245 LocalAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
1250 case bitc::METADATA_OLD_NODE: {
1251 // Deprecated, but still needed to read old bitcode files.
1252 if (Record.size() % 2 == 1)
1253 return error("Invalid record");
1255 unsigned Size = Record.size();
1256 SmallVector<Metadata *, 8> Elts;
1257 for (unsigned i = 0; i != Size; i += 2) {
1258 Type *Ty = getTypeByID(Record[i]);
1260 return error("Invalid record");
1261 if (Ty->isMetadataTy())
1262 Elts.push_back(getMD(Record[i + 1]));
1263 else if (!Ty->isVoidTy()) {
1265 ValueAsMetadata::get(ValueList.getValueFwdRef(Record[i + 1], Ty));
1266 assert(isa<ConstantAsMetadata>(MD) &&
1267 "Expected non-function-local metadata");
1270 Elts.push_back(nullptr);
1272 MetadataList.assignValue(MDNode::get(Context, Elts), NextMetadataNo);
1276 case bitc::METADATA_VALUE: {
1277 if (Record.size() != 2)
1278 return error("Invalid record");
1280 Type *Ty = getTypeByID(Record[0]);
1281 if (Ty->isMetadataTy() || Ty->isVoidTy())
1282 return error("Invalid record");
1284 MetadataList.assignValue(
1285 ValueAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
1290 case bitc::METADATA_DISTINCT_NODE:
1293 case bitc::METADATA_NODE: {
1294 SmallVector<Metadata *, 8> Elts;
1295 Elts.reserve(Record.size());
1296 for (unsigned ID : Record)
1297 Elts.push_back(getMDOrNull(ID));
1298 MetadataList.assignValue(IsDistinct ? MDNode::getDistinct(Context, Elts)
1299 : MDNode::get(Context, Elts),
1304 case bitc::METADATA_LOCATION: {
1305 if (Record.size() != 5 && Record.size() != 6)
1306 return error("Invalid record");
1308 IsDistinct = Record[0];
1309 unsigned Line = Record[1];
1310 unsigned Column = Record[2];
1311 Metadata *Scope = getMD(Record[3]);
1312 Metadata *InlinedAt = getMDOrNull(Record[4]);
1313 bool ImplicitCode = Record.size() == 6 && Record[5];
1314 MetadataList.assignValue(
1315 GET_OR_DISTINCT(DILocation, (Context, Line, Column, Scope, InlinedAt,
1321 case bitc::METADATA_GENERIC_DEBUG: {
1322 if (Record.size() < 4)
1323 return error("Invalid record");
1325 IsDistinct = Record[0];
1326 unsigned Tag = Record[1];
1327 unsigned Version = Record[2];
1329 if (Tag >= 1u << 16 || Version != 0)
1330 return error("Invalid record");
1332 auto *Header = getMDString(Record[3]);
1333 SmallVector<Metadata *, 8> DwarfOps;
1334 for (unsigned I = 4, E = Record.size(); I != E; ++I)
1335 DwarfOps.push_back(getMDOrNull(Record[I]));
1336 MetadataList.assignValue(
1337 GET_OR_DISTINCT(GenericDINode, (Context, Tag, Header, DwarfOps)),
1342 case bitc::METADATA_SUBRANGE: {
1343 Metadata *Val = nullptr;
1344 // Operand 'count' is interpreted as:
1345 // - Signed integer (version 0)
1346 // - Metadata node (version 1)
1347 // Operand 'lowerBound' is interpreted as:
1348 // - Signed integer (version 0 and 1)
1349 // - Metadata node (version 2)
1350 // Operands 'upperBound' and 'stride' are interpreted as:
1351 // - Metadata node (version 2)
1352 switch (Record[0] >> 1) {
1354 Val = GET_OR_DISTINCT(DISubrange,
1355 (Context, Record[1], unrotateSign(Record[2])));
1358 Val = GET_OR_DISTINCT(DISubrange, (Context, getMDOrNull(Record[1]),
1359 unrotateSign(Record[2])));
1362 Val = GET_OR_DISTINCT(
1363 DISubrange, (Context, getMDOrNull(Record[1]), getMDOrNull(Record[2]),
1364 getMDOrNull(Record[3]), getMDOrNull(Record[4])));
1367 return error("Invalid record: Unsupported version of DISubrange");
1370 MetadataList.assignValue(Val, NextMetadataNo);
1371 IsDistinct = Record[0] & 1;
1375 case bitc::METADATA_GENERIC_SUBRANGE: {
1376 Metadata *Val = nullptr;
1377 Val = GET_OR_DISTINCT(DIGenericSubrange,
1378 (Context, getMDOrNull(Record[1]),
1379 getMDOrNull(Record[2]), getMDOrNull(Record[3]),
1380 getMDOrNull(Record[4])));
1382 MetadataList.assignValue(Val, NextMetadataNo);
1383 IsDistinct = Record[0] & 1;
1387 case bitc::METADATA_ENUMERATOR: {
1388 if (Record.size() < 3)
1389 return error("Invalid record");
1391 IsDistinct = Record[0] & 1;
1392 bool IsUnsigned = Record[0] & 2;
1393 bool IsBigInt = Record[0] & 4;
1397 const uint64_t BitWidth = Record[1];
1398 const size_t NumWords = Record.size() - 3;
1399 Value = readWideAPInt(makeArrayRef(&Record[3], NumWords), BitWidth);
1401 Value = APInt(64, unrotateSign(Record[1]), !IsUnsigned);
1403 MetadataList.assignValue(
1404 GET_OR_DISTINCT(DIEnumerator,
1405 (Context, Value, IsUnsigned, getMDString(Record[2]))),
1410 case bitc::METADATA_BASIC_TYPE: {
1411 if (Record.size() < 6 || Record.size() > 7)
1412 return error("Invalid record");
1414 IsDistinct = Record[0];
1415 DINode::DIFlags Flags = (Record.size() > 6) ?
1416 static_cast<DINode::DIFlags>(Record[6]) : DINode::FlagZero;
1418 MetadataList.assignValue(
1419 GET_OR_DISTINCT(DIBasicType,
1420 (Context, Record[1], getMDString(Record[2]), Record[3],
1421 Record[4], Record[5], Flags)),
1426 case bitc::METADATA_STRING_TYPE: {
1427 if (Record.size() != 8)
1428 return error("Invalid record");
1430 IsDistinct = Record[0];
1431 MetadataList.assignValue(
1432 GET_OR_DISTINCT(DIStringType,
1433 (Context, Record[1], getMDString(Record[2]),
1434 getMDOrNull(Record[3]), getMDOrNull(Record[4]),
1435 Record[5], Record[6], Record[7])),
1440 case bitc::METADATA_DERIVED_TYPE: {
1441 if (Record.size() < 12 || Record.size() > 13)
1442 return error("Invalid record");
1444 // DWARF address space is encoded as N->getDWARFAddressSpace() + 1. 0 means
1445 // that there is no DWARF address space associated with DIDerivedType.
1446 Optional<unsigned> DWARFAddressSpace;
1447 if (Record.size() > 12 && Record[12])
1448 DWARFAddressSpace = Record[12] - 1;
1450 IsDistinct = Record[0];
1451 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]);
1452 MetadataList.assignValue(
1453 GET_OR_DISTINCT(DIDerivedType,
1454 (Context, Record[1], getMDString(Record[2]),
1455 getMDOrNull(Record[3]), Record[4],
1456 getDITypeRefOrNull(Record[5]),
1457 getDITypeRefOrNull(Record[6]), Record[7], Record[8],
1458 Record[9], DWARFAddressSpace, Flags,
1459 getDITypeRefOrNull(Record[11]))),
1464 case bitc::METADATA_COMPOSITE_TYPE: {
1465 if (Record.size() < 16 || Record.size() > 21)
1466 return error("Invalid record");
1468 // If we have a UUID and this is not a forward declaration, lookup the
1470 IsDistinct = Record[0] & 0x1;
1471 bool IsNotUsedInTypeRef = Record[0] >= 2;
1472 unsigned Tag = Record[1];
1473 MDString *Name = getMDString(Record[2]);
1474 Metadata *File = getMDOrNull(Record[3]);
1475 unsigned Line = Record[4];
1476 Metadata *Scope = getDITypeRefOrNull(Record[5]);
1477 Metadata *BaseType = nullptr;
1478 uint64_t SizeInBits = Record[7];
1479 if (Record[8] > (uint64_t)std::numeric_limits<uint32_t>::max())
1480 return error("Alignment value is too large");
1481 uint32_t AlignInBits = Record[8];
1482 uint64_t OffsetInBits = 0;
1483 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]);
1484 Metadata *Elements = nullptr;
1485 unsigned RuntimeLang = Record[12];
1486 Metadata *VTableHolder = nullptr;
1487 Metadata *TemplateParams = nullptr;
1488 Metadata *Discriminator = nullptr;
1489 Metadata *DataLocation = nullptr;
1490 Metadata *Associated = nullptr;
1491 Metadata *Allocated = nullptr;
1492 Metadata *Rank = nullptr;
1493 auto *Identifier = getMDString(Record[15]);
1494 // If this module is being parsed so that it can be ThinLTO imported
1495 // into another module, composite types only need to be imported
1496 // as type declarations (unless full type definitions requested).
1497 // Create type declarations up front to save memory. Also, buildODRType
1498 // handles the case where this is type ODRed with a definition needed
1499 // by the importing module, in which case the existing definition is
1501 if (IsImporting && !ImportFullTypeDefinitions && Identifier &&
1502 (Tag == dwarf::DW_TAG_enumeration_type ||
1503 Tag == dwarf::DW_TAG_class_type ||
1504 Tag == dwarf::DW_TAG_structure_type ||
1505 Tag == dwarf::DW_TAG_union_type)) {
1506 Flags = Flags | DINode::FlagFwdDecl;
1508 BaseType = getDITypeRefOrNull(Record[6]);
1509 OffsetInBits = Record[9];
1510 Elements = getMDOrNull(Record[11]);
1511 VTableHolder = getDITypeRefOrNull(Record[13]);
1512 TemplateParams = getMDOrNull(Record[14]);
1513 if (Record.size() > 16)
1514 Discriminator = getMDOrNull(Record[16]);
1515 if (Record.size() > 17)
1516 DataLocation = getMDOrNull(Record[17]);
1517 if (Record.size() > 19) {
1518 Associated = getMDOrNull(Record[18]);
1519 Allocated = getMDOrNull(Record[19]);
1521 if (Record.size() > 20) {
1522 Rank = getMDOrNull(Record[20]);
1525 DICompositeType *CT = nullptr;
1527 CT = DICompositeType::buildODRType(
1528 Context, *Identifier, Tag, Name, File, Line, Scope, BaseType,
1529 SizeInBits, AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
1530 VTableHolder, TemplateParams, Discriminator, DataLocation, Associated,
1533 // Create a node if we didn't get a lazy ODR type.
1535 CT = GET_OR_DISTINCT(DICompositeType,
1536 (Context, Tag, Name, File, Line, Scope, BaseType,
1537 SizeInBits, AlignInBits, OffsetInBits, Flags,
1538 Elements, RuntimeLang, VTableHolder, TemplateParams,
1539 Identifier, Discriminator, DataLocation, Associated,
1541 if (!IsNotUsedInTypeRef && Identifier)
1542 MetadataList.addTypeRef(*Identifier, *cast<DICompositeType>(CT));
1544 MetadataList.assignValue(CT, NextMetadataNo);
1548 case bitc::METADATA_SUBROUTINE_TYPE: {
1549 if (Record.size() < 3 || Record.size() > 4)
1550 return error("Invalid record");
1551 bool IsOldTypeRefArray = Record[0] < 2;
1552 unsigned CC = (Record.size() > 3) ? Record[3] : 0;
1554 IsDistinct = Record[0] & 0x1;
1555 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[1]);
1556 Metadata *Types = getMDOrNull(Record[2]);
1557 if (LLVM_UNLIKELY(IsOldTypeRefArray))
1558 Types = MetadataList.upgradeTypeRefArray(Types);
1560 MetadataList.assignValue(
1561 GET_OR_DISTINCT(DISubroutineType, (Context, Flags, CC, Types)),
1567 case bitc::METADATA_MODULE: {
1568 if (Record.size() < 5 || Record.size() > 9)
1569 return error("Invalid record");
1571 unsigned Offset = Record.size() >= 8 ? 2 : 1;
1572 IsDistinct = Record[0];
1573 MetadataList.assignValue(
1576 (Context, Record.size() >= 8 ? getMDOrNull(Record[1]) : nullptr,
1577 getMDOrNull(Record[0 + Offset]), getMDString(Record[1 + Offset]),
1578 getMDString(Record[2 + Offset]), getMDString(Record[3 + Offset]),
1579 getMDString(Record[4 + Offset]),
1580 Record.size() <= 7 ? 0 : Record[7],
1581 Record.size() <= 8 ? false : Record[8])),
1587 case bitc::METADATA_FILE: {
1588 if (Record.size() != 3 && Record.size() != 5 && Record.size() != 6)
1589 return error("Invalid record");
1591 IsDistinct = Record[0];
1592 Optional<DIFile::ChecksumInfo<MDString *>> Checksum;
1593 // The BitcodeWriter writes null bytes into Record[3:4] when the Checksum
1594 // is not present. This matches up with the old internal representation,
1595 // and the old encoding for CSK_None in the ChecksumKind. The new
1596 // representation reserves the value 0 in the ChecksumKind to continue to
1597 // encode None in a backwards-compatible way.
1598 if (Record.size() > 4 && Record[3] && Record[4])
1599 Checksum.emplace(static_cast<DIFile::ChecksumKind>(Record[3]),
1600 getMDString(Record[4]));
1601 MetadataList.assignValue(
1604 (Context, getMDString(Record[1]), getMDString(Record[2]), Checksum,
1605 Record.size() > 5 ? Optional<MDString *>(getMDString(Record[5]))
1611 case bitc::METADATA_COMPILE_UNIT: {
1612 if (Record.size() < 14 || Record.size() > 22)
1613 return error("Invalid record");
1615 // Ignore Record[0], which indicates whether this compile unit is
1616 // distinct. It's always distinct.
1618 auto *CU = DICompileUnit::getDistinct(
1619 Context, Record[1], getMDOrNull(Record[2]), getMDString(Record[3]),
1620 Record[4], getMDString(Record[5]), Record[6], getMDString(Record[7]),
1621 Record[8], getMDOrNull(Record[9]), getMDOrNull(Record[10]),
1622 getMDOrNull(Record[12]), getMDOrNull(Record[13]),
1623 Record.size() <= 15 ? nullptr : getMDOrNull(Record[15]),
1624 Record.size() <= 14 ? 0 : Record[14],
1625 Record.size() <= 16 ? true : Record[16],
1626 Record.size() <= 17 ? false : Record[17],
1627 Record.size() <= 18 ? 0 : Record[18],
1628 Record.size() <= 19 ? 0 : Record[19],
1629 Record.size() <= 20 ? nullptr : getMDString(Record[20]),
1630 Record.size() <= 21 ? nullptr : getMDString(Record[21]));
1632 MetadataList.assignValue(CU, NextMetadataNo);
1635 // Move the Upgrade the list of subprograms.
1636 if (Metadata *SPs = getMDOrNullWithoutPlaceholders(Record[11]))
1637 CUSubprograms.push_back({CU, SPs});
1640 case bitc::METADATA_SUBPROGRAM: {
1641 if (Record.size() < 18 || Record.size() > 21)
1642 return error("Invalid record");
1644 bool HasSPFlags = Record[0] & 4;
1646 DINode::DIFlags Flags;
1647 DISubprogram::DISPFlags SPFlags;
1649 Flags = static_cast<DINode::DIFlags>(Record[11 + 2]);
1651 Flags = static_cast<DINode::DIFlags>(Record[11]);
1652 SPFlags = static_cast<DISubprogram::DISPFlags>(Record[9]);
1655 // Support for old metadata when
1656 // subprogram specific flags are placed in DIFlags.
1657 const unsigned DIFlagMainSubprogram = 1 << 21;
1658 bool HasOldMainSubprogramFlag = Flags & DIFlagMainSubprogram;
1659 if (HasOldMainSubprogramFlag)
1660 // Remove old DIFlagMainSubprogram from DIFlags.
1661 // Note: This assumes that any future use of bit 21 defaults to it
1663 Flags &= ~static_cast<DINode::DIFlags>(DIFlagMainSubprogram);
1665 if (HasOldMainSubprogramFlag && HasSPFlags)
1666 SPFlags |= DISubprogram::SPFlagMainSubprogram;
1667 else if (!HasSPFlags)
1668 SPFlags = DISubprogram::toSPFlags(
1669 /*IsLocalToUnit=*/Record[7], /*IsDefinition=*/Record[8],
1670 /*IsOptimized=*/Record[14], /*Virtuality=*/Record[11],
1671 /*DIFlagMainSubprogram*/HasOldMainSubprogramFlag);
1673 // All definitions should be distinct.
1674 IsDistinct = (Record[0] & 1) || (SPFlags & DISubprogram::SPFlagDefinition);
1675 // Version 1 has a Function as Record[15].
1676 // Version 2 has removed Record[15].
1677 // Version 3 has the Unit as Record[15].
1678 // Version 4 added thisAdjustment.
1679 // Version 5 repacked flags into DISPFlags, changing many element numbers.
1680 bool HasUnit = Record[0] & 2;
1681 if (!HasSPFlags && HasUnit && Record.size() < 19)
1682 return error("Invalid record");
1683 if (HasSPFlags && !HasUnit)
1684 return error("Invalid record");
1685 // Accommodate older formats.
1687 bool HasThisAdj = true;
1688 bool HasThrownTypes = true;
1689 unsigned OffsetA = 0;
1690 unsigned OffsetB = 0;
1694 if (Record.size() >= 19) {
1698 HasThisAdj = Record.size() >= 20;
1699 HasThrownTypes = Record.size() >= 21;
1701 Metadata *CUorFn = getMDOrNull(Record[12 + OffsetB]);
1702 DISubprogram *SP = GET_OR_DISTINCT(
1705 getDITypeRefOrNull(Record[1]), // scope
1706 getMDString(Record[2]), // name
1707 getMDString(Record[3]), // linkageName
1708 getMDOrNull(Record[4]), // file
1710 getMDOrNull(Record[6]), // type
1711 Record[7 + OffsetA], // scopeLine
1712 getDITypeRefOrNull(Record[8 + OffsetA]), // containingType
1713 Record[10 + OffsetA], // virtualIndex
1714 HasThisAdj ? Record[16 + OffsetB] : 0, // thisAdjustment
1717 HasUnit ? CUorFn : nullptr, // unit
1718 getMDOrNull(Record[13 + OffsetB]), // templateParams
1719 getMDOrNull(Record[14 + OffsetB]), // declaration
1720 getMDOrNull(Record[15 + OffsetB]), // retainedNodes
1721 HasThrownTypes ? getMDOrNull(Record[17 + OffsetB])
1722 : nullptr // thrownTypes
1724 MetadataList.assignValue(SP, NextMetadataNo);
1727 // Upgrade sp->function mapping to function->sp mapping.
1729 if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(CUorFn))
1730 if (auto *F = dyn_cast<Function>(CMD->getValue())) {
1731 if (F->isMaterializable())
1732 // Defer until materialized; unmaterialized functions may not have
1734 FunctionsWithSPs[F] = SP;
1735 else if (!F->empty())
1736 F->setSubprogram(SP);
1741 case bitc::METADATA_LEXICAL_BLOCK: {
1742 if (Record.size() != 5)
1743 return error("Invalid record");
1745 IsDistinct = Record[0];
1746 MetadataList.assignValue(
1747 GET_OR_DISTINCT(DILexicalBlock,
1748 (Context, getMDOrNull(Record[1]),
1749 getMDOrNull(Record[2]), Record[3], Record[4])),
1754 case bitc::METADATA_LEXICAL_BLOCK_FILE: {
1755 if (Record.size() != 4)
1756 return error("Invalid record");
1758 IsDistinct = Record[0];
1759 MetadataList.assignValue(
1760 GET_OR_DISTINCT(DILexicalBlockFile,
1761 (Context, getMDOrNull(Record[1]),
1762 getMDOrNull(Record[2]), Record[3])),
1767 case bitc::METADATA_COMMON_BLOCK: {
1768 IsDistinct = Record[0] & 1;
1769 MetadataList.assignValue(
1770 GET_OR_DISTINCT(DICommonBlock,
1771 (Context, getMDOrNull(Record[1]),
1772 getMDOrNull(Record[2]), getMDString(Record[3]),
1773 getMDOrNull(Record[4]), Record[5])),
1778 case bitc::METADATA_NAMESPACE: {
1779 // Newer versions of DINamespace dropped file and line.
1781 if (Record.size() == 3)
1782 Name = getMDString(Record[2]);
1783 else if (Record.size() == 5)
1784 Name = getMDString(Record[3]);
1786 return error("Invalid record");
1788 IsDistinct = Record[0] & 1;
1789 bool ExportSymbols = Record[0] & 2;
1790 MetadataList.assignValue(
1791 GET_OR_DISTINCT(DINamespace,
1792 (Context, getMDOrNull(Record[1]), Name, ExportSymbols)),
1797 case bitc::METADATA_MACRO: {
1798 if (Record.size() != 5)
1799 return error("Invalid record");
1801 IsDistinct = Record[0];
1802 MetadataList.assignValue(
1803 GET_OR_DISTINCT(DIMacro,
1804 (Context, Record[1], Record[2], getMDString(Record[3]),
1805 getMDString(Record[4]))),
1810 case bitc::METADATA_MACRO_FILE: {
1811 if (Record.size() != 5)
1812 return error("Invalid record");
1814 IsDistinct = Record[0];
1815 MetadataList.assignValue(
1816 GET_OR_DISTINCT(DIMacroFile,
1817 (Context, Record[1], Record[2], getMDOrNull(Record[3]),
1818 getMDOrNull(Record[4]))),
1823 case bitc::METADATA_TEMPLATE_TYPE: {
1824 if (Record.size() < 3 || Record.size() > 4)
1825 return error("Invalid record");
1827 IsDistinct = Record[0];
1828 MetadataList.assignValue(
1829 GET_OR_DISTINCT(DITemplateTypeParameter,
1830 (Context, getMDString(Record[1]),
1831 getDITypeRefOrNull(Record[2]),
1832 (Record.size() == 4) ? getMDOrNull(Record[3])
1833 : getMDOrNull(false))),
1838 case bitc::METADATA_TEMPLATE_VALUE: {
1839 if (Record.size() < 5 || Record.size() > 6)
1840 return error("Invalid record");
1842 IsDistinct = Record[0];
1844 MetadataList.assignValue(
1846 DITemplateValueParameter,
1847 (Context, Record[1], getMDString(Record[2]),
1848 getDITypeRefOrNull(Record[3]),
1849 (Record.size() == 6) ? getMDOrNull(Record[4]) : getMDOrNull(false),
1850 (Record.size() == 6) ? getMDOrNull(Record[5])
1851 : getMDOrNull(Record[4]))),
1856 case bitc::METADATA_GLOBAL_VAR: {
1857 if (Record.size() < 11 || Record.size() > 13)
1858 return error("Invalid record");
1860 IsDistinct = Record[0] & 1;
1861 unsigned Version = Record[0] >> 1;
1864 MetadataList.assignValue(
1867 (Context, getMDOrNull(Record[1]), getMDString(Record[2]),
1868 getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
1869 getDITypeRefOrNull(Record[6]), Record[7], Record[8],
1870 getMDOrNull(Record[9]), getMDOrNull(Record[10]), Record[11])),
1874 } else if (Version == 1) {
1875 // No upgrade necessary. A null field will be introduced to indicate
1876 // that no parameter information is available.
1877 MetadataList.assignValue(
1878 GET_OR_DISTINCT(DIGlobalVariable,
1879 (Context, getMDOrNull(Record[1]),
1880 getMDString(Record[2]), getMDString(Record[3]),
1881 getMDOrNull(Record[4]), Record[5],
1882 getDITypeRefOrNull(Record[6]), Record[7], Record[8],
1883 getMDOrNull(Record[10]), nullptr, Record[11])),
1887 } else if (Version == 0) {
1888 // Upgrade old metadata, which stored a global variable reference or a
1889 // ConstantInt here.
1890 NeedUpgradeToDIGlobalVariableExpression = true;
1891 Metadata *Expr = getMDOrNull(Record[9]);
1892 uint32_t AlignInBits = 0;
1893 if (Record.size() > 11) {
1894 if (Record[11] > (uint64_t)std::numeric_limits<uint32_t>::max())
1895 return error("Alignment value is too large");
1896 AlignInBits = Record[11];
1898 GlobalVariable *Attach = nullptr;
1899 if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(Expr)) {
1900 if (auto *GV = dyn_cast<GlobalVariable>(CMD->getValue())) {
1903 } else if (auto *CI = dyn_cast<ConstantInt>(CMD->getValue())) {
1904 Expr = DIExpression::get(Context,
1905 {dwarf::DW_OP_constu, CI->getZExtValue(),
1906 dwarf::DW_OP_stack_value});
1911 DIGlobalVariable *DGV = GET_OR_DISTINCT(
1913 (Context, getMDOrNull(Record[1]), getMDString(Record[2]),
1914 getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
1915 getDITypeRefOrNull(Record[6]), Record[7], Record[8],
1916 getMDOrNull(Record[10]), nullptr, AlignInBits));
1918 DIGlobalVariableExpression *DGVE = nullptr;
1920 DGVE = DIGlobalVariableExpression::getDistinct(
1921 Context, DGV, Expr ? Expr : DIExpression::get(Context, {}));
1923 Attach->addDebugInfo(DGVE);
1925 auto *MDNode = Expr ? cast<Metadata>(DGVE) : cast<Metadata>(DGV);
1926 MetadataList.assignValue(MDNode, NextMetadataNo);
1929 return error("Invalid record");
1933 case bitc::METADATA_LOCAL_VAR: {
1934 // 10th field is for the obseleted 'inlinedAt:' field.
1935 if (Record.size() < 8 || Record.size() > 10)
1936 return error("Invalid record");
1938 IsDistinct = Record[0] & 1;
1939 bool HasAlignment = Record[0] & 2;
1940 // 2nd field used to be an artificial tag, either DW_TAG_auto_variable or
1941 // DW_TAG_arg_variable, if we have alignment flag encoded it means, that
1942 // this is newer version of record which doesn't have artificial tag.
1943 bool HasTag = !HasAlignment && Record.size() > 8;
1944 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[7 + HasTag]);
1945 uint32_t AlignInBits = 0;
1947 if (Record[8 + HasTag] > (uint64_t)std::numeric_limits<uint32_t>::max())
1948 return error("Alignment value is too large");
1949 AlignInBits = Record[8 + HasTag];
1951 MetadataList.assignValue(
1952 GET_OR_DISTINCT(DILocalVariable,
1953 (Context, getMDOrNull(Record[1 + HasTag]),
1954 getMDString(Record[2 + HasTag]),
1955 getMDOrNull(Record[3 + HasTag]), Record[4 + HasTag],
1956 getDITypeRefOrNull(Record[5 + HasTag]),
1957 Record[6 + HasTag], Flags, AlignInBits)),
1962 case bitc::METADATA_LABEL: {
1963 if (Record.size() != 5)
1964 return error("Invalid record");
1966 IsDistinct = Record[0] & 1;
1967 MetadataList.assignValue(
1968 GET_OR_DISTINCT(DILabel,
1969 (Context, getMDOrNull(Record[1]),
1970 getMDString(Record[2]),
1971 getMDOrNull(Record[3]), Record[4])),
1976 case bitc::METADATA_EXPRESSION: {
1977 if (Record.size() < 1)
1978 return error("Invalid record");
1980 IsDistinct = Record[0] & 1;
1981 uint64_t Version = Record[0] >> 1;
1982 auto Elts = MutableArrayRef<uint64_t>(Record).slice(1);
1984 SmallVector<uint64_t, 6> Buffer;
1985 if (Error Err = upgradeDIExpression(Version, Elts, Buffer))
1988 MetadataList.assignValue(
1989 GET_OR_DISTINCT(DIExpression, (Context, Elts)), NextMetadataNo);
1993 case bitc::METADATA_GLOBAL_VAR_EXPR: {
1994 if (Record.size() != 3)
1995 return error("Invalid record");
1997 IsDistinct = Record[0];
1998 Metadata *Expr = getMDOrNull(Record[2]);
2000 Expr = DIExpression::get(Context, {});
2001 MetadataList.assignValue(
2002 GET_OR_DISTINCT(DIGlobalVariableExpression,
2003 (Context, getMDOrNull(Record[1]), Expr)),
2008 case bitc::METADATA_OBJC_PROPERTY: {
2009 if (Record.size() != 8)
2010 return error("Invalid record");
2012 IsDistinct = Record[0];
2013 MetadataList.assignValue(
2014 GET_OR_DISTINCT(DIObjCProperty,
2015 (Context, getMDString(Record[1]),
2016 getMDOrNull(Record[2]), Record[3],
2017 getMDString(Record[4]), getMDString(Record[5]),
2018 Record[6], getDITypeRefOrNull(Record[7]))),
2023 case bitc::METADATA_IMPORTED_ENTITY: {
2024 if (Record.size() != 6 && Record.size() != 7)
2025 return error("Invalid record");
2027 IsDistinct = Record[0];
2028 bool HasFile = (Record.size() == 7);
2029 MetadataList.assignValue(
2030 GET_OR_DISTINCT(DIImportedEntity,
2031 (Context, Record[1], getMDOrNull(Record[2]),
2032 getDITypeRefOrNull(Record[3]),
2033 HasFile ? getMDOrNull(Record[6]) : nullptr,
2034 HasFile ? Record[4] : 0, getMDString(Record[5]))),
2039 case bitc::METADATA_STRING_OLD: {
2040 std::string String(Record.begin(), Record.end());
2042 // Test for upgrading !llvm.loop.
2043 HasSeenOldLoopTags |= mayBeOldLoopAttachmentTag(String);
2044 ++NumMDStringLoaded;
2045 Metadata *MD = MDString::get(Context, String);
2046 MetadataList.assignValue(MD, NextMetadataNo);
2050 case bitc::METADATA_STRINGS: {
2051 auto CreateNextMDString = [&](StringRef Str) {
2052 ++NumMDStringLoaded;
2053 MetadataList.assignValue(MDString::get(Context, Str), NextMetadataNo);
2056 if (Error Err = parseMetadataStrings(Record, Blob, CreateNextMDString))
2060 case bitc::METADATA_GLOBAL_DECL_ATTACHMENT: {
2061 if (Record.size() % 2 == 0)
2062 return error("Invalid record");
2063 unsigned ValueID = Record[0];
2064 if (ValueID >= ValueList.size())
2065 return error("Invalid record");
2066 if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID]))
2067 if (Error Err = parseGlobalObjectAttachment(
2068 *GO, ArrayRef<uint64_t>(Record).slice(1)))
2072 case bitc::METADATA_KIND: {
2073 // Support older bitcode files that had METADATA_KIND records in a
2074 // block with METADATA_BLOCK_ID.
2075 if (Error Err = parseMetadataKindRecord(Record))
2080 return Error::success();
2081 #undef GET_OR_DISTINCT
2084 Error MetadataLoader::MetadataLoaderImpl::parseMetadataStrings(
2085 ArrayRef<uint64_t> Record, StringRef Blob,
2086 function_ref<void(StringRef)> CallBack) {
2087 // All the MDStrings in the block are emitted together in a single
2088 // record. The strings are concatenated and stored in a blob along with
2090 if (Record.size() != 2)
2091 return error("Invalid record: metadata strings layout");
2093 unsigned NumStrings = Record[0];
2094 unsigned StringsOffset = Record[1];
2096 return error("Invalid record: metadata strings with no strings");
2097 if (StringsOffset > Blob.size())
2098 return error("Invalid record: metadata strings corrupt offset");
2100 StringRef Lengths = Blob.slice(0, StringsOffset);
2101 SimpleBitstreamCursor R(Lengths);
2103 StringRef Strings = Blob.drop_front(StringsOffset);
2105 if (R.AtEndOfStream())
2106 return error("Invalid record: metadata strings bad length");
2108 Expected<uint32_t> MaybeSize = R.ReadVBR(6);
2110 return MaybeSize.takeError();
2111 uint32_t Size = MaybeSize.get();
2112 if (Strings.size() < Size)
2113 return error("Invalid record: metadata strings truncated chars");
2115 CallBack(Strings.slice(0, Size));
2116 Strings = Strings.drop_front(Size);
2117 } while (--NumStrings);
2119 return Error::success();
2122 Error MetadataLoader::MetadataLoaderImpl::parseGlobalObjectAttachment(
2123 GlobalObject &GO, ArrayRef<uint64_t> Record) {
2124 assert(Record.size() % 2 == 0);
2125 for (unsigned I = 0, E = Record.size(); I != E; I += 2) {
2126 auto K = MDKindMap.find(Record[I]);
2127 if (K == MDKindMap.end())
2128 return error("Invalid ID");
2130 dyn_cast_or_null<MDNode>(getMetadataFwdRefOrLoad(Record[I + 1]));
2132 return error("Invalid metadata attachment: expect fwd ref to MDNode");
2133 GO.addMetadata(K->second, *MD);
2135 return Error::success();
2138 /// Parse metadata attachments.
2139 Error MetadataLoader::MetadataLoaderImpl::parseMetadataAttachment(
2140 Function &F, const SmallVectorImpl<Instruction *> &InstructionList) {
2141 if (Error Err = Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))
2144 SmallVector<uint64_t, 64> Record;
2145 PlaceholderQueue Placeholders;
2148 Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
2150 return MaybeEntry.takeError();
2151 BitstreamEntry Entry = MaybeEntry.get();
2153 switch (Entry.Kind) {
2154 case BitstreamEntry::SubBlock: // Handled for us already.
2155 case BitstreamEntry::Error:
2156 return error("Malformed block");
2157 case BitstreamEntry::EndBlock:
2158 resolveForwardRefsAndPlaceholders(Placeholders);
2159 return Error::success();
2160 case BitstreamEntry::Record:
2161 // The interesting case.
2165 // Read a metadata attachment record.
2167 ++NumMDRecordLoaded;
2168 Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
2170 return MaybeRecord.takeError();
2171 switch (MaybeRecord.get()) {
2172 default: // Default behavior: ignore.
2174 case bitc::METADATA_ATTACHMENT: {
2175 unsigned RecordLength = Record.size();
2177 return error("Invalid record");
2178 if (RecordLength % 2 == 0) {
2179 // A function attachment.
2180 if (Error Err = parseGlobalObjectAttachment(F, Record))
2185 // An instruction attachment.
2186 Instruction *Inst = InstructionList[Record[0]];
2187 for (unsigned i = 1; i != RecordLength; i = i + 2) {
2188 unsigned Kind = Record[i];
2189 DenseMap<unsigned, unsigned>::iterator I = MDKindMap.find(Kind);
2190 if (I == MDKindMap.end())
2191 return error("Invalid ID");
2192 if (I->second == LLVMContext::MD_tbaa && StripTBAA)
2195 auto Idx = Record[i + 1];
2196 if (Idx < (MDStringRef.size() + GlobalMetadataBitPosIndex.size()) &&
2197 !MetadataList.lookup(Idx)) {
2198 // Load the attachment if it is in the lazy-loadable range and hasn't
2200 lazyLoadOneMetadata(Idx, Placeholders);
2201 resolveForwardRefsAndPlaceholders(Placeholders);
2204 Metadata *Node = MetadataList.getMetadataFwdRef(Idx);
2205 if (isa<LocalAsMetadata>(Node))
2206 // Drop the attachment. This used to be legal, but there's no
2209 MDNode *MD = dyn_cast_or_null<MDNode>(Node);
2211 return error("Invalid metadata attachment");
2213 if (HasSeenOldLoopTags && I->second == LLVMContext::MD_loop)
2214 MD = upgradeInstructionLoopAttachment(*MD);
2216 if (I->second == LLVMContext::MD_tbaa) {
2217 assert(!MD->isTemporary() && "should load MDs before attachments");
2218 MD = UpgradeTBAANode(*MD);
2220 Inst->setMetadata(I->second, MD);
2228 /// Parse a single METADATA_KIND record, inserting result in MDKindMap.
2229 Error MetadataLoader::MetadataLoaderImpl::parseMetadataKindRecord(
2230 SmallVectorImpl<uint64_t> &Record) {
2231 if (Record.size() < 2)
2232 return error("Invalid record");
2234 unsigned Kind = Record[0];
2235 SmallString<8> Name(Record.begin() + 1, Record.end());
2237 unsigned NewKind = TheModule.getMDKindID(Name.str());
2238 if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second)
2239 return error("Conflicting METADATA_KIND records");
2240 return Error::success();
2243 /// Parse the metadata kinds out of the METADATA_KIND_BLOCK.
2244 Error MetadataLoader::MetadataLoaderImpl::parseMetadataKinds() {
2245 if (Error Err = Stream.EnterSubBlock(bitc::METADATA_KIND_BLOCK_ID))
2248 SmallVector<uint64_t, 64> Record;
2250 // Read all the records.
2252 Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();
2254 return MaybeEntry.takeError();
2255 BitstreamEntry Entry = MaybeEntry.get();
2257 switch (Entry.Kind) {
2258 case BitstreamEntry::SubBlock: // Handled for us already.
2259 case BitstreamEntry::Error:
2260 return error("Malformed block");
2261 case BitstreamEntry::EndBlock:
2262 return Error::success();
2263 case BitstreamEntry::Record:
2264 // The interesting case.
2270 ++NumMDRecordLoaded;
2271 Expected<unsigned> MaybeCode = Stream.readRecord(Entry.ID, Record);
2273 return MaybeCode.takeError();
2274 switch (MaybeCode.get()) {
2275 default: // Default behavior: ignore.
2277 case bitc::METADATA_KIND: {
2278 if (Error Err = parseMetadataKindRecord(Record))
2286 MetadataLoader &MetadataLoader::operator=(MetadataLoader &&RHS) {
2287 Pimpl = std::move(RHS.Pimpl);
2290 MetadataLoader::MetadataLoader(MetadataLoader &&RHS)
2291 : Pimpl(std::move(RHS.Pimpl)) {}
2293 MetadataLoader::~MetadataLoader() = default;
2294 MetadataLoader::MetadataLoader(BitstreamCursor &Stream, Module &TheModule,
2295 BitcodeReaderValueList &ValueList,
2297 std::function<Type *(unsigned)> getTypeByID)
2298 : Pimpl(std::make_unique<MetadataLoaderImpl>(
2299 Stream, TheModule, ValueList, std::move(getTypeByID), IsImporting)) {}
2301 Error MetadataLoader::parseMetadata(bool ModuleLevel) {
2302 return Pimpl->parseMetadata(ModuleLevel);
2305 bool MetadataLoader::hasFwdRefs() const { return Pimpl->hasFwdRefs(); }
2307 /// Return the given metadata, creating a replaceable forward reference if
2309 Metadata *MetadataLoader::getMetadataFwdRefOrLoad(unsigned Idx) {
2310 return Pimpl->getMetadataFwdRefOrLoad(Idx);
2313 DISubprogram *MetadataLoader::lookupSubprogramForFunction(Function *F) {
2314 return Pimpl->lookupSubprogramForFunction(F);
2317 Error MetadataLoader::parseMetadataAttachment(
2318 Function &F, const SmallVectorImpl<Instruction *> &InstructionList) {
2319 return Pimpl->parseMetadataAttachment(F, InstructionList);
2322 Error MetadataLoader::parseMetadataKinds() {
2323 return Pimpl->parseMetadataKinds();
2326 void MetadataLoader::setStripTBAA(bool StripTBAA) {
2327 return Pimpl->setStripTBAA(StripTBAA);
2330 bool MetadataLoader::isStrippingTBAA() { return Pimpl->isStrippingTBAA(); }
2332 unsigned MetadataLoader::size() const { return Pimpl->size(); }
2333 void MetadataLoader::shrinkTo(unsigned N) { return Pimpl->shrinkTo(N); }
2335 void MetadataLoader::upgradeDebugIntrinsics(Function &F) {
2336 return Pimpl->upgradeDebugIntrinsics(F);