LLVM 19.0.0git
MetadataLoader.cpp
Go to the documentation of this file.
1//===- MetadataLoader.cpp - Internal BitcodeReader implementation ---------===//
2//
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
6//
7//===----------------------------------------------------------------------===//
8
9#include "MetadataLoader.h"
10#include "ValueList.h"
11
12#include "llvm/ADT/APInt.h"
13#include "llvm/ADT/ArrayRef.h"
15#include "llvm/ADT/DenseMap.h"
16#include "llvm/ADT/DenseSet.h"
18#include "llvm/ADT/SetVector.h"
21#include "llvm/ADT/Statistic.h"
22#include "llvm/ADT/StringRef.h"
23#include "llvm/ADT/Twine.h"
29#include "llvm/IR/AutoUpgrade.h"
30#include "llvm/IR/BasicBlock.h"
31#include "llvm/IR/Constants.h"
33#include "llvm/IR/Function.h"
36#include "llvm/IR/Instruction.h"
38#include "llvm/IR/LLVMContext.h"
39#include "llvm/IR/Metadata.h"
40#include "llvm/IR/Module.h"
42#include "llvm/IR/Type.h"
48
49#include <algorithm>
50#include <cassert>
51#include <cstddef>
52#include <cstdint>
53#include <deque>
54#include <iterator>
55#include <limits>
56#include <map>
57#include <optional>
58#include <string>
59#include <tuple>
60#include <type_traits>
61#include <utility>
62#include <vector>
63namespace llvm {
64class Argument;
65}
66
67using namespace llvm;
68
69#define DEBUG_TYPE "bitcode-reader"
70
71STATISTIC(NumMDStringLoaded, "Number of MDStrings loaded");
72STATISTIC(NumMDNodeTemporary, "Number of MDNode::Temporary created");
73STATISTIC(NumMDRecordLoaded, "Number of Metadata records loaded");
74
75/// Flag whether we need to import full type definitions for ThinLTO.
76/// Currently needed for Darwin and LLDB.
78 "import-full-type-definitions", cl::init(false), cl::Hidden,
79 cl::desc("Import full type definitions for ThinLTO."));
80
82 "disable-ondemand-mds-loading", cl::init(false), cl::Hidden,
83 cl::desc("Force disable the lazy-loading on-demand of metadata when "
84 "loading bitcode for importing."));
85
86namespace {
87
88static int64_t unrotateSign(uint64_t U) { return (U & 1) ? ~(U >> 1) : U >> 1; }
89
90class BitcodeReaderMetadataList {
91 /// Array of metadata references.
92 ///
93 /// Don't use std::vector here. Some versions of libc++ copy (instead of
94 /// move) on resize, and TrackingMDRef is very expensive to copy.
96
97 /// The set of indices in MetadataPtrs above of forward references that were
98 /// generated.
100
101 /// The set of indices in MetadataPtrs above of Metadata that need to be
102 /// resolved.
103 SmallDenseSet<unsigned, 1> UnresolvedNodes;
104
105 /// Structures for resolving old type refs.
106 struct {
111 } OldTypeRefs;
112
114
115 /// Maximum number of valid references. Forward references exceeding the
116 /// maximum must be invalid.
117 unsigned RefsUpperBound;
118
119public:
120 BitcodeReaderMetadataList(LLVMContext &C, size_t RefsUpperBound)
121 : Context(C),
122 RefsUpperBound(std::min((size_t)std::numeric_limits<unsigned>::max(),
123 RefsUpperBound)) {}
124
125 // vector compatibility methods
126 unsigned size() const { return MetadataPtrs.size(); }
127 void resize(unsigned N) { MetadataPtrs.resize(N); }
128 void push_back(Metadata *MD) { MetadataPtrs.emplace_back(MD); }
129 void clear() { MetadataPtrs.clear(); }
130 Metadata *back() const { return MetadataPtrs.back(); }
131 void pop_back() { MetadataPtrs.pop_back(); }
132 bool empty() const { return MetadataPtrs.empty(); }
133
134 Metadata *operator[](unsigned i) const {
135 assert(i < MetadataPtrs.size());
136 return MetadataPtrs[i];
137 }
138
139 Metadata *lookup(unsigned I) const {
140 if (I < MetadataPtrs.size())
141 return MetadataPtrs[I];
142 return nullptr;
143 }
144
145 void shrinkTo(unsigned N) {
146 assert(N <= size() && "Invalid shrinkTo request!");
147 assert(ForwardReference.empty() && "Unexpected forward refs");
148 assert(UnresolvedNodes.empty() && "Unexpected unresolved node");
149 MetadataPtrs.resize(N);
150 }
151
152 /// Return the given metadata, creating a replaceable forward reference if
153 /// necessary.
154 Metadata *getMetadataFwdRef(unsigned Idx);
155
156 /// Return the given metadata only if it is fully resolved.
157 ///
158 /// Gives the same result as \a lookup(), unless \a MDNode::isResolved()
159 /// would give \c false.
160 Metadata *getMetadataIfResolved(unsigned Idx);
161
162 MDNode *getMDNodeFwdRefOrNull(unsigned Idx);
163 void assignValue(Metadata *MD, unsigned Idx);
164 void tryToResolveCycles();
165 bool hasFwdRefs() const { return !ForwardReference.empty(); }
166 int getNextFwdRef() {
167 assert(hasFwdRefs());
168 return *ForwardReference.begin();
169 }
170
171 /// Upgrade a type that had an MDString reference.
172 void addTypeRef(MDString &UUID, DICompositeType &CT);
173
174 /// Upgrade a type that had an MDString reference.
175 Metadata *upgradeTypeRef(Metadata *MaybeUUID);
176
177 /// Upgrade a type ref array that may have MDString references.
178 Metadata *upgradeTypeRefArray(Metadata *MaybeTuple);
179
180private:
181 Metadata *resolveTypeRefArray(Metadata *MaybeTuple);
182};
183
184void BitcodeReaderMetadataList::assignValue(Metadata *MD, unsigned Idx) {
185 if (auto *MDN = dyn_cast<MDNode>(MD))
186 if (!MDN->isResolved())
187 UnresolvedNodes.insert(Idx);
188
189 if (Idx == size()) {
190 push_back(MD);
191 return;
192 }
193
194 if (Idx >= size())
195 resize(Idx + 1);
196
197 TrackingMDRef &OldMD = MetadataPtrs[Idx];
198 if (!OldMD) {
199 OldMD.reset(MD);
200 return;
201 }
202
203 // If there was a forward reference to this value, replace it.
204 TempMDTuple PrevMD(cast<MDTuple>(OldMD.get()));
205 PrevMD->replaceAllUsesWith(MD);
206 ForwardReference.erase(Idx);
207}
208
209Metadata *BitcodeReaderMetadataList::getMetadataFwdRef(unsigned Idx) {
210 // Bail out for a clearly invalid value.
211 if (Idx >= RefsUpperBound)
212 return nullptr;
213
214 if (Idx >= size())
215 resize(Idx + 1);
216
217 if (Metadata *MD = MetadataPtrs[Idx])
218 return MD;
219
220 // Track forward refs to be resolved later.
221 ForwardReference.insert(Idx);
222
223 // Create and return a placeholder, which will later be RAUW'd.
224 ++NumMDNodeTemporary;
225 Metadata *MD = MDNode::getTemporary(Context, std::nullopt).release();
226 MetadataPtrs[Idx].reset(MD);
227 return MD;
228}
229
230Metadata *BitcodeReaderMetadataList::getMetadataIfResolved(unsigned Idx) {
231 Metadata *MD = lookup(Idx);
232 if (auto *N = dyn_cast_or_null<MDNode>(MD))
233 if (!N->isResolved())
234 return nullptr;
235 return MD;
236}
237
238MDNode *BitcodeReaderMetadataList::getMDNodeFwdRefOrNull(unsigned Idx) {
239 return dyn_cast_or_null<MDNode>(getMetadataFwdRef(Idx));
240}
241
242void BitcodeReaderMetadataList::tryToResolveCycles() {
243 if (!ForwardReference.empty())
244 // Still forward references... can't resolve cycles.
245 return;
246
247 // Give up on finding a full definition for any forward decls that remain.
248 for (const auto &Ref : OldTypeRefs.FwdDecls)
249 OldTypeRefs.Final.insert(Ref);
250 OldTypeRefs.FwdDecls.clear();
251
252 // Upgrade from old type ref arrays. In strange cases, this could add to
253 // OldTypeRefs.Unknown.
254 for (const auto &Array : OldTypeRefs.Arrays)
255 Array.second->replaceAllUsesWith(resolveTypeRefArray(Array.first.get()));
256 OldTypeRefs.Arrays.clear();
257
258 // Replace old string-based type refs with the resolved node, if possible.
259 // If we haven't seen the node, leave it to the verifier to complain about
260 // the invalid string reference.
261 for (const auto &Ref : OldTypeRefs.Unknown) {
262 if (DICompositeType *CT = OldTypeRefs.Final.lookup(Ref.first))
263 Ref.second->replaceAllUsesWith(CT);
264 else
265 Ref.second->replaceAllUsesWith(Ref.first);
266 }
267 OldTypeRefs.Unknown.clear();
268
269 if (UnresolvedNodes.empty())
270 // Nothing to do.
271 return;
272
273 // Resolve any cycles.
274 for (unsigned I : UnresolvedNodes) {
275 auto &MD = MetadataPtrs[I];
276 auto *N = dyn_cast_or_null<MDNode>(MD);
277 if (!N)
278 continue;
279
280 assert(!N->isTemporary() && "Unexpected forward reference");
281 N->resolveCycles();
282 }
283
284 // Make sure we return early again until there's another unresolved ref.
285 UnresolvedNodes.clear();
286}
287
288void BitcodeReaderMetadataList::addTypeRef(MDString &UUID,
289 DICompositeType &CT) {
290 assert(CT.getRawIdentifier() == &UUID && "Mismatched UUID");
291 if (CT.isForwardDecl())
292 OldTypeRefs.FwdDecls.insert(std::make_pair(&UUID, &CT));
293 else
294 OldTypeRefs.Final.insert(std::make_pair(&UUID, &CT));
295}
296
297Metadata *BitcodeReaderMetadataList::upgradeTypeRef(Metadata *MaybeUUID) {
298 auto *UUID = dyn_cast_or_null<MDString>(MaybeUUID);
299 if (LLVM_LIKELY(!UUID))
300 return MaybeUUID;
301
302 if (auto *CT = OldTypeRefs.Final.lookup(UUID))
303 return CT;
304
305 auto &Ref = OldTypeRefs.Unknown[UUID];
306 if (!Ref)
307 Ref = MDNode::getTemporary(Context, std::nullopt);
308 return Ref.get();
309}
310
311Metadata *BitcodeReaderMetadataList::upgradeTypeRefArray(Metadata *MaybeTuple) {
312 auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
313 if (!Tuple || Tuple->isDistinct())
314 return MaybeTuple;
315
316 // Look through the array immediately if possible.
317 if (!Tuple->isTemporary())
318 return resolveTypeRefArray(Tuple);
319
320 // Create and return a placeholder to use for now. Eventually
321 // resolveTypeRefArrays() will be resolve this forward reference.
322 OldTypeRefs.Arrays.emplace_back(
323 std::piecewise_construct, std::forward_as_tuple(Tuple),
324 std::forward_as_tuple(MDTuple::getTemporary(Context, std::nullopt)));
325 return OldTypeRefs.Arrays.back().second.get();
326}
327
328Metadata *BitcodeReaderMetadataList::resolveTypeRefArray(Metadata *MaybeTuple) {
329 auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
330 if (!Tuple || Tuple->isDistinct())
331 return MaybeTuple;
332
333 // Look through the DITypeRefArray, upgrading each DIType *.
335 Ops.reserve(Tuple->getNumOperands());
336 for (Metadata *MD : Tuple->operands())
337 Ops.push_back(upgradeTypeRef(MD));
338
339 return MDTuple::get(Context, Ops);
340}
341
342namespace {
343
344class PlaceholderQueue {
345 // Placeholders would thrash around when moved, so store in a std::deque
346 // instead of some sort of vector.
347 std::deque<DistinctMDOperandPlaceholder> PHs;
348
349public:
350 ~PlaceholderQueue() {
351 assert(empty() &&
352 "PlaceholderQueue hasn't been flushed before being destroyed");
353 }
354 bool empty() const { return PHs.empty(); }
355 DistinctMDOperandPlaceholder &getPlaceholderOp(unsigned ID);
356 void flush(BitcodeReaderMetadataList &MetadataList);
357
358 /// Return the list of temporaries nodes in the queue, these need to be
359 /// loaded before we can flush the queue.
360 void getTemporaries(BitcodeReaderMetadataList &MetadataList,
361 DenseSet<unsigned> &Temporaries) {
362 for (auto &PH : PHs) {
363 auto ID = PH.getID();
364 auto *MD = MetadataList.lookup(ID);
365 if (!MD) {
366 Temporaries.insert(ID);
367 continue;
368 }
369 auto *N = dyn_cast_or_null<MDNode>(MD);
370 if (N && N->isTemporary())
371 Temporaries.insert(ID);
372 }
373 }
374};
375
376} // end anonymous namespace
377
378DistinctMDOperandPlaceholder &PlaceholderQueue::getPlaceholderOp(unsigned ID) {
379 PHs.emplace_back(ID);
380 return PHs.back();
381}
382
383void PlaceholderQueue::flush(BitcodeReaderMetadataList &MetadataList) {
384 while (!PHs.empty()) {
385 auto *MD = MetadataList.lookup(PHs.front().getID());
386 assert(MD && "Flushing placeholder on unassigned MD");
387#ifndef NDEBUG
388 if (auto *MDN = dyn_cast<MDNode>(MD))
389 assert(MDN->isResolved() &&
390 "Flushing Placeholder while cycles aren't resolved");
391#endif
392 PHs.front().replaceUseWith(MD);
393 PHs.pop_front();
394 }
395}
396
397} // anonymous namespace
398
399static Error error(const Twine &Message) {
400 return make_error<StringError>(
401 Message, make_error_code(BitcodeError::CorruptedBitcode));
402}
403
405 BitcodeReaderMetadataList MetadataList;
406 BitcodeReaderValueList &ValueList;
407 BitstreamCursor &Stream;
409 Module &TheModule;
410 MetadataLoaderCallbacks Callbacks;
411
412 /// Cursor associated with the lazy-loading of Metadata. This is the easy way
413 /// to keep around the right "context" (Abbrev list) to be able to jump in
414 /// the middle of the metadata block and load any record.
415 BitstreamCursor IndexCursor;
416
417 /// Index that keeps track of MDString values.
418 std::vector<StringRef> MDStringRef;
419
420 /// On-demand loading of a single MDString. Requires the index above to be
421 /// populated.
422 MDString *lazyLoadOneMDString(unsigned Idx);
423
424 /// Index that keeps track of where to find a metadata record in the stream.
425 std::vector<uint64_t> GlobalMetadataBitPosIndex;
426
427 /// Cursor position of the start of the global decl attachments, to enable
428 /// loading using the index built for lazy loading, instead of forward
429 /// references.
430 uint64_t GlobalDeclAttachmentPos = 0;
431
432#ifndef NDEBUG
433 /// Baisic correctness check that we end up parsing all of the global decl
434 /// attachments.
435 unsigned NumGlobalDeclAttachSkipped = 0;
436 unsigned NumGlobalDeclAttachParsed = 0;
437#endif
438
439 /// Load the global decl attachments, using the index built for lazy loading.
440 Expected<bool> loadGlobalDeclAttachments();
441
442 /// Populate the index above to enable lazily loading of metadata, and load
443 /// the named metadata as well as the transitively referenced global
444 /// Metadata.
445 Expected<bool> lazyLoadModuleMetadataBlock();
446
447 /// On-demand loading of a single metadata. Requires the index above to be
448 /// populated.
449 void lazyLoadOneMetadata(unsigned Idx, PlaceholderQueue &Placeholders);
450
451 // Keep mapping of seens pair of old-style CU <-> SP, and update pointers to
452 // point from SP to CU after a block is completly parsed.
453 std::vector<std::pair<DICompileUnit *, Metadata *>> CUSubprograms;
454
455 /// Functions that need to be matched with subprograms when upgrading old
456 /// metadata.
458
459 // Map the bitcode's custom MDKind ID to the Module's MDKind ID.
461
462 bool StripTBAA = false;
463 bool HasSeenOldLoopTags = false;
464 bool NeedUpgradeToDIGlobalVariableExpression = false;
465 bool NeedDeclareExpressionUpgrade = false;
466
467 /// Map DILocalScope to the enclosing DISubprogram, if any.
469
470 /// True if metadata is being parsed for a module being ThinLTO imported.
471 bool IsImporting = false;
472
473 Error parseOneMetadata(SmallVectorImpl<uint64_t> &Record, unsigned Code,
474 PlaceholderQueue &Placeholders, StringRef Blob,
475 unsigned &NextMetadataNo);
476 Error parseMetadataStrings(ArrayRef<uint64_t> Record, StringRef Blob,
477 function_ref<void(StringRef)> CallBack);
478 Error parseGlobalObjectAttachment(GlobalObject &GO,
480 Error parseMetadataKindRecord(SmallVectorImpl<uint64_t> &Record);
481
482 void resolveForwardRefsAndPlaceholders(PlaceholderQueue &Placeholders);
483
484 /// Upgrade old-style CU <-> SP pointers to point from SP to CU.
485 void upgradeCUSubprograms() {
486 for (auto CU_SP : CUSubprograms)
487 if (auto *SPs = dyn_cast_or_null<MDTuple>(CU_SP.second))
488 for (auto &Op : SPs->operands())
489 if (auto *SP = dyn_cast_or_null<DISubprogram>(Op))
490 SP->replaceUnit(CU_SP.first);
491 CUSubprograms.clear();
492 }
493
494 /// Upgrade old-style bare DIGlobalVariables to DIGlobalVariableExpressions.
495 void upgradeCUVariables() {
496 if (!NeedUpgradeToDIGlobalVariableExpression)
497 return;
498
499 // Upgrade list of variables attached to the CUs.
500 if (NamedMDNode *CUNodes = TheModule.getNamedMetadata("llvm.dbg.cu"))
501 for (unsigned I = 0, E = CUNodes->getNumOperands(); I != E; ++I) {
502 auto *CU = cast<DICompileUnit>(CUNodes->getOperand(I));
503 if (auto *GVs = dyn_cast_or_null<MDTuple>(CU->getRawGlobalVariables()))
504 for (unsigned I = 0; I < GVs->getNumOperands(); I++)
505 if (auto *GV =
506 dyn_cast_or_null<DIGlobalVariable>(GVs->getOperand(I))) {
509 GVs->replaceOperandWith(I, DGVE);
510 }
511 }
512
513 // Upgrade variables attached to globals.
514 for (auto &GV : TheModule.globals()) {
516 GV.getMetadata(LLVMContext::MD_dbg, MDs);
517 GV.eraseMetadata(LLVMContext::MD_dbg);
518 for (auto *MD : MDs)
519 if (auto *DGV = dyn_cast<DIGlobalVariable>(MD)) {
522 GV.addMetadata(LLVMContext::MD_dbg, *DGVE);
523 } else
524 GV.addMetadata(LLVMContext::MD_dbg, *MD);
525 }
526 }
527
528 DISubprogram *findEnclosingSubprogram(DILocalScope *S) {
529 if (!S)
530 return nullptr;
531 if (auto *SP = ParentSubprogram[S]) {
532 return SP;
533 }
534
535 DILocalScope *InitialScope = S;
537 while (S && !isa<DISubprogram>(S)) {
538 S = dyn_cast_or_null<DILocalScope>(S->getScope());
539 if (Visited.contains(S))
540 break;
541 Visited.insert(S);
542 }
543 ParentSubprogram[InitialScope] = llvm::dyn_cast_or_null<DISubprogram>(S);
544
545 return ParentSubprogram[InitialScope];
546 }
547
548 /// Move local imports from DICompileUnit's 'imports' field to
549 /// DISubprogram's retainedNodes.
550 void upgradeCULocals() {
551 if (NamedMDNode *CUNodes = TheModule.getNamedMetadata("llvm.dbg.cu")) {
552 for (unsigned I = 0, E = CUNodes->getNumOperands(); I != E; ++I) {
553 auto *CU = dyn_cast<DICompileUnit>(CUNodes->getOperand(I));
554 if (!CU)
555 continue;
556
557 if (CU->getRawImportedEntities()) {
558 // Collect a set of imported entities to be moved.
559 SetVector<Metadata *> EntitiesToRemove;
560 for (Metadata *Op : CU->getImportedEntities()->operands()) {
561 auto *IE = cast<DIImportedEntity>(Op);
562 if (dyn_cast_or_null<DILocalScope>(IE->getScope())) {
563 EntitiesToRemove.insert(IE);
564 }
565 }
566
567 if (!EntitiesToRemove.empty()) {
568 // Make a new list of CU's 'imports'.
569 SmallVector<Metadata *> NewImports;
570 for (Metadata *Op : CU->getImportedEntities()->operands()) {
571 if (!EntitiesToRemove.contains(cast<DIImportedEntity>(Op))) {
572 NewImports.push_back(Op);
573 }
574 }
575
576 // Find DISubprogram corresponding to each entity.
577 std::map<DISubprogram *, SmallVector<Metadata *>> SPToEntities;
578 for (auto *I : EntitiesToRemove) {
579 auto *Entity = cast<DIImportedEntity>(I);
580 if (auto *SP = findEnclosingSubprogram(
581 cast<DILocalScope>(Entity->getScope()))) {
582 SPToEntities[SP].push_back(Entity);
583 }
584 }
585
586 // Update DISubprograms' retainedNodes.
587 for (auto I = SPToEntities.begin(); I != SPToEntities.end(); ++I) {
588 auto *SP = I->first;
589 auto RetainedNodes = SP->getRetainedNodes();
590 SmallVector<Metadata *> MDs(RetainedNodes.begin(),
591 RetainedNodes.end());
592 MDs.append(I->second);
593 SP->replaceRetainedNodes(MDNode::get(Context, MDs));
594 }
595
596 // Remove entities with local scope from CU.
597 CU->replaceImportedEntities(MDTuple::get(Context, NewImports));
598 }
599 }
600 }
601 }
602
603 ParentSubprogram.clear();
604 }
605
606 /// Remove a leading DW_OP_deref from DIExpressions in a dbg.declare that
607 /// describes a function argument.
608 void upgradeDeclareExpressions(Function &F) {
609 if (!NeedDeclareExpressionUpgrade)
610 return;
611
612 for (auto &BB : F)
613 for (auto &I : BB)
614 if (auto *DDI = dyn_cast<DbgDeclareInst>(&I))
615 if (auto *DIExpr = DDI->getExpression())
616 if (DIExpr->startsWithDeref() &&
617 isa_and_nonnull<Argument>(DDI->getAddress())) {
619 Ops.append(std::next(DIExpr->elements_begin()),
620 DIExpr->elements_end());
621 DDI->setExpression(DIExpression::get(Context, Ops));
622 }
623 }
624
625 /// Upgrade the expression from previous versions.
626 Error upgradeDIExpression(uint64_t FromVersion,
629 auto N = Expr.size();
630 switch (FromVersion) {
631 default:
632 return error("Invalid record");
633 case 0:
634 if (N >= 3 && Expr[N - 3] == dwarf::DW_OP_bit_piece)
635 Expr[N - 3] = dwarf::DW_OP_LLVM_fragment;
636 [[fallthrough]];
637 case 1:
638 // Move DW_OP_deref to the end.
639 if (N && Expr[0] == dwarf::DW_OP_deref) {
640 auto End = Expr.end();
641 if (Expr.size() >= 3 &&
642 *std::prev(End, 3) == dwarf::DW_OP_LLVM_fragment)
643 End = std::prev(End, 3);
644 std::move(std::next(Expr.begin()), End, Expr.begin());
645 *std::prev(End) = dwarf::DW_OP_deref;
646 }
647 NeedDeclareExpressionUpgrade = true;
648 [[fallthrough]];
649 case 2: {
650 // Change DW_OP_plus to DW_OP_plus_uconst.
651 // Change DW_OP_minus to DW_OP_uconst, DW_OP_minus
652 auto SubExpr = ArrayRef<uint64_t>(Expr);
653 while (!SubExpr.empty()) {
654 // Skip past other operators with their operands
655 // for this version of the IR, obtained from
656 // from historic DIExpression::ExprOperand::getSize().
657 size_t HistoricSize;
658 switch (SubExpr.front()) {
659 default:
660 HistoricSize = 1;
661 break;
662 case dwarf::DW_OP_constu:
663 case dwarf::DW_OP_minus:
664 case dwarf::DW_OP_plus:
665 HistoricSize = 2;
666 break;
668 HistoricSize = 3;
669 break;
670 }
671
672 // If the expression is malformed, make sure we don't
673 // copy more elements than we should.
674 HistoricSize = std::min(SubExpr.size(), HistoricSize);
675 ArrayRef<uint64_t> Args = SubExpr.slice(1, HistoricSize - 1);
676
677 switch (SubExpr.front()) {
678 case dwarf::DW_OP_plus:
679 Buffer.push_back(dwarf::DW_OP_plus_uconst);
680 Buffer.append(Args.begin(), Args.end());
681 break;
682 case dwarf::DW_OP_minus:
683 Buffer.push_back(dwarf::DW_OP_constu);
684 Buffer.append(Args.begin(), Args.end());
685 Buffer.push_back(dwarf::DW_OP_minus);
686 break;
687 default:
688 Buffer.push_back(*SubExpr.begin());
689 Buffer.append(Args.begin(), Args.end());
690 break;
691 }
692
693 // Continue with remaining elements.
694 SubExpr = SubExpr.slice(HistoricSize);
695 }
696 Expr = MutableArrayRef<uint64_t>(Buffer);
697 [[fallthrough]];
698 }
699 case 3:
700 // Up-to-date!
701 break;
702 }
703
704 return Error::success();
705 }
706
707 void upgradeDebugInfo(bool ModuleLevel) {
708 upgradeCUSubprograms();
709 upgradeCUVariables();
710 if (ModuleLevel)
711 upgradeCULocals();
712 }
713
714 void callMDTypeCallback(Metadata **Val, unsigned TypeID);
715
716public:
718 BitcodeReaderValueList &ValueList,
719 MetadataLoaderCallbacks Callbacks, bool IsImporting)
720 : MetadataList(TheModule.getContext(), Stream.SizeInBytes()),
721 ValueList(ValueList), Stream(Stream), Context(TheModule.getContext()),
722 TheModule(TheModule), Callbacks(std::move(Callbacks)),
723 IsImporting(IsImporting) {}
724
725 Error parseMetadata(bool ModuleLevel);
726
727 bool hasFwdRefs() const { return MetadataList.hasFwdRefs(); }
728
730 if (ID < MDStringRef.size())
731 return lazyLoadOneMDString(ID);
732 if (auto *MD = MetadataList.lookup(ID))
733 return MD;
734 // If lazy-loading is enabled, we try recursively to load the operand
735 // instead of creating a temporary.
736 if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
737 PlaceholderQueue Placeholders;
738 lazyLoadOneMetadata(ID, Placeholders);
739 resolveForwardRefsAndPlaceholders(Placeholders);
740 return MetadataList.lookup(ID);
741 }
742 return MetadataList.getMetadataFwdRef(ID);
743 }
744
746 return FunctionsWithSPs.lookup(F);
747 }
748
749 bool hasSeenOldLoopTags() const { return HasSeenOldLoopTags; }
750
752 ArrayRef<Instruction *> InstructionList);
753
755
756 void setStripTBAA(bool Value) { StripTBAA = Value; }
757 bool isStrippingTBAA() const { return StripTBAA; }
758
759 unsigned size() const { return MetadataList.size(); }
760 void shrinkTo(unsigned N) { MetadataList.shrinkTo(N); }
761 void upgradeDebugIntrinsics(Function &F) { upgradeDeclareExpressions(F); }
762};
763
765MetadataLoader::MetadataLoaderImpl::lazyLoadModuleMetadataBlock() {
766 IndexCursor = Stream;
768 GlobalDeclAttachmentPos = 0;
769 // Get the abbrevs, and preload record positions to make them lazy-loadable.
770 while (true) {
771 uint64_t SavedPos = IndexCursor.GetCurrentBitNo();
772 BitstreamEntry Entry;
773 if (Error E =
774 IndexCursor
775 .advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd)
776 .moveInto(Entry))
777 return std::move(E);
778
779 switch (Entry.Kind) {
780 case BitstreamEntry::SubBlock: // Handled for us already.
782 return error("Malformed block");
784 return true;
785 }
787 // The interesting case.
788 ++NumMDRecordLoaded;
789 uint64_t CurrentPos = IndexCursor.GetCurrentBitNo();
790 unsigned Code;
791 if (Error E = IndexCursor.skipRecord(Entry.ID).moveInto(Code))
792 return std::move(E);
793 switch (Code) {
795 // Rewind and parse the strings.
796 if (Error Err = IndexCursor.JumpToBit(CurrentPos))
797 return std::move(Err);
798 StringRef Blob;
799 Record.clear();
800 if (Expected<unsigned> MaybeRecord =
801 IndexCursor.readRecord(Entry.ID, Record, &Blob))
802 ;
803 else
804 return MaybeRecord.takeError();
805 unsigned NumStrings = Record[0];
806 MDStringRef.reserve(NumStrings);
807 auto IndexNextMDString = [&](StringRef Str) {
808 MDStringRef.push_back(Str);
809 };
810 if (auto Err = parseMetadataStrings(Record, Blob, IndexNextMDString))
811 return std::move(Err);
812 break;
813 }
815 // This is the offset to the index, when we see this we skip all the
816 // records and load only an index to these.
817 if (Error Err = IndexCursor.JumpToBit(CurrentPos))
818 return std::move(Err);
819 Record.clear();
820 if (Expected<unsigned> MaybeRecord =
821 IndexCursor.readRecord(Entry.ID, Record))
822 ;
823 else
824 return MaybeRecord.takeError();
825 if (Record.size() != 2)
826 return error("Invalid record");
827 auto Offset = Record[0] + (Record[1] << 32);
828 auto BeginPos = IndexCursor.GetCurrentBitNo();
829 if (Error Err = IndexCursor.JumpToBit(BeginPos + Offset))
830 return std::move(Err);
831 Expected<BitstreamEntry> MaybeEntry =
832 IndexCursor.advanceSkippingSubblocks(
834 if (!MaybeEntry)
835 return MaybeEntry.takeError();
836 Entry = MaybeEntry.get();
837 assert(Entry.Kind == BitstreamEntry::Record &&
838 "Corrupted bitcode: Expected `Record` when trying to find the "
839 "Metadata index");
840 Record.clear();
841 if (Expected<unsigned> MaybeCode =
842 IndexCursor.readRecord(Entry.ID, Record))
843 assert(MaybeCode.get() == bitc::METADATA_INDEX &&
844 "Corrupted bitcode: Expected `METADATA_INDEX` when trying to "
845 "find the Metadata index");
846 else
847 return MaybeCode.takeError();
848 // Delta unpack
849 auto CurrentValue = BeginPos;
850 GlobalMetadataBitPosIndex.reserve(Record.size());
851 for (auto &Elt : Record) {
852 CurrentValue += Elt;
853 GlobalMetadataBitPosIndex.push_back(CurrentValue);
854 }
855 break;
856 }
858 // We don't expect to get there, the Index is loaded when we encounter
859 // the offset.
860 return error("Corrupted Metadata block");
861 case bitc::METADATA_NAME: {
862 // Named metadata need to be materialized now and aren't deferred.
863 if (Error Err = IndexCursor.JumpToBit(CurrentPos))
864 return std::move(Err);
865 Record.clear();
866
867 unsigned Code;
868 if (Expected<unsigned> MaybeCode =
869 IndexCursor.readRecord(Entry.ID, Record)) {
870 Code = MaybeCode.get();
872 } else
873 return MaybeCode.takeError();
874
875 // Read name of the named metadata.
876 SmallString<8> Name(Record.begin(), Record.end());
877 if (Expected<unsigned> MaybeCode = IndexCursor.ReadCode())
878 Code = MaybeCode.get();
879 else
880 return MaybeCode.takeError();
881
882 // Named Metadata comes in two parts, we expect the name to be followed
883 // by the node
884 Record.clear();
885 if (Expected<unsigned> MaybeNextBitCode =
886 IndexCursor.readRecord(Code, Record))
887 assert(MaybeNextBitCode.get() == bitc::METADATA_NAMED_NODE);
888 else
889 return MaybeNextBitCode.takeError();
890
891 // Read named metadata elements.
892 unsigned Size = Record.size();
893 NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name);
894 for (unsigned i = 0; i != Size; ++i) {
895 // FIXME: We could use a placeholder here, however NamedMDNode are
896 // taking MDNode as operand and not using the Metadata infrastructure.
897 // It is acknowledged by 'TODO: Inherit from Metadata' in the
898 // NamedMDNode class definition.
899 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
900 assert(MD && "Invalid metadata: expect fwd ref to MDNode");
901 NMD->addOperand(MD);
902 }
903 break;
904 }
906 if (!GlobalDeclAttachmentPos)
907 GlobalDeclAttachmentPos = SavedPos;
908#ifndef NDEBUG
909 NumGlobalDeclAttachSkipped++;
910#endif
911 break;
912 }
950 // We don't expect to see any of these, if we see one, give up on
951 // lazy-loading and fallback.
952 MDStringRef.clear();
953 GlobalMetadataBitPosIndex.clear();
954 return false;
955 }
956 break;
957 }
958 }
959 }
960}
961
962// Load the global decl attachments after building the lazy loading index.
963// We don't load them "lazily" - all global decl attachments must be
964// parsed since they aren't materialized on demand. However, by delaying
965// their parsing until after the index is created, we can use the index
966// instead of creating temporaries.
967Expected<bool> MetadataLoader::MetadataLoaderImpl::loadGlobalDeclAttachments() {
968 // Nothing to do if we didn't find any of these metadata records.
969 if (!GlobalDeclAttachmentPos)
970 return true;
971 // Use a temporary cursor so that we don't mess up the main Stream cursor or
972 // the lazy loading IndexCursor (which holds the necessary abbrev ids).
973 BitstreamCursor TempCursor = Stream;
975 // Jump to the position before the first global decl attachment, so we can
976 // scan for the first BitstreamEntry record.
977 if (Error Err = TempCursor.JumpToBit(GlobalDeclAttachmentPos))
978 return std::move(Err);
979 while (true) {
980 BitstreamEntry Entry;
981 if (Error E =
982 TempCursor
983 .advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd)
984 .moveInto(Entry))
985 return std::move(E);
986
987 switch (Entry.Kind) {
988 case BitstreamEntry::SubBlock: // Handled for us already.
990 return error("Malformed block");
992 // Check that we parsed them all.
993 assert(NumGlobalDeclAttachSkipped == NumGlobalDeclAttachParsed);
994 return true;
996 break;
997 }
998 uint64_t CurrentPos = TempCursor.GetCurrentBitNo();
999 Expected<unsigned> MaybeCode = TempCursor.skipRecord(Entry.ID);
1000 if (!MaybeCode)
1001 return MaybeCode.takeError();
1002 if (MaybeCode.get() != bitc::METADATA_GLOBAL_DECL_ATTACHMENT) {
1003 // Anything other than a global decl attachment signals the end of
1004 // these records. Check that we parsed them all.
1005 assert(NumGlobalDeclAttachSkipped == NumGlobalDeclAttachParsed);
1006 return true;
1007 }
1008#ifndef NDEBUG
1009 NumGlobalDeclAttachParsed++;
1010#endif
1011 // FIXME: we need to do this early because we don't materialize global
1012 // value explicitly.
1013 if (Error Err = TempCursor.JumpToBit(CurrentPos))
1014 return std::move(Err);
1015 Record.clear();
1016 if (Expected<unsigned> MaybeRecord =
1017 TempCursor.readRecord(Entry.ID, Record))
1018 ;
1019 else
1020 return MaybeRecord.takeError();
1021 if (Record.size() % 2 == 0)
1022 return error("Invalid record");
1023 unsigned ValueID = Record[0];
1024 if (ValueID >= ValueList.size())
1025 return error("Invalid record");
1026 if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID])) {
1027 // Need to save and restore the current position since
1028 // parseGlobalObjectAttachment will resolve all forward references which
1029 // would require parsing from locations stored in the index.
1030 CurrentPos = TempCursor.GetCurrentBitNo();
1031 if (Error Err = parseGlobalObjectAttachment(
1032 *GO, ArrayRef<uint64_t>(Record).slice(1)))
1033 return std::move(Err);
1034 if (Error Err = TempCursor.JumpToBit(CurrentPos))
1035 return std::move(Err);
1036 }
1037 }
1038}
1039
1040void MetadataLoader::MetadataLoaderImpl::callMDTypeCallback(Metadata **Val,
1041 unsigned TypeID) {
1042 if (Callbacks.MDType) {
1043 (*Callbacks.MDType)(Val, TypeID, Callbacks.GetTypeByID,
1044 Callbacks.GetContainedTypeID);
1045 }
1046}
1047
1048/// Parse a METADATA_BLOCK. If ModuleLevel is true then we are parsing
1049/// module level metadata.
1051 if (!ModuleLevel && MetadataList.hasFwdRefs())
1052 return error("Invalid metadata: fwd refs into function blocks");
1053
1054 // Record the entry position so that we can jump back here and efficiently
1055 // skip the whole block in case we lazy-load.
1056 auto EntryPos = Stream.GetCurrentBitNo();
1057
1058 if (Error Err = Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID))
1059 return Err;
1060
1062 PlaceholderQueue Placeholders;
1063
1064 // We lazy-load module-level metadata: we build an index for each record, and
1065 // then load individual record as needed, starting with the named metadata.
1066 if (ModuleLevel && IsImporting && MetadataList.empty() &&
1068 auto SuccessOrErr = lazyLoadModuleMetadataBlock();
1069 if (!SuccessOrErr)
1070 return SuccessOrErr.takeError();
1071 if (SuccessOrErr.get()) {
1072 // An index was successfully created and we will be able to load metadata
1073 // on-demand.
1074 MetadataList.resize(MDStringRef.size() +
1075 GlobalMetadataBitPosIndex.size());
1076
1077 // Now that we have built the index, load the global decl attachments
1078 // that were deferred during that process. This avoids creating
1079 // temporaries.
1080 SuccessOrErr = loadGlobalDeclAttachments();
1081 if (!SuccessOrErr)
1082 return SuccessOrErr.takeError();
1083 assert(SuccessOrErr.get());
1084
1085 // Reading the named metadata created forward references and/or
1086 // placeholders, that we flush here.
1087 resolveForwardRefsAndPlaceholders(Placeholders);
1088 upgradeDebugInfo(ModuleLevel);
1089 // Return at the beginning of the block, since it is easy to skip it
1090 // entirely from there.
1091 Stream.ReadBlockEnd(); // Pop the abbrev block context.
1092 if (Error Err = IndexCursor.JumpToBit(EntryPos))
1093 return Err;
1094 if (Error Err = Stream.SkipBlock()) {
1095 // FIXME this drops the error on the floor, which
1096 // ThinLTO/X86/debuginfo-cu-import.ll relies on.
1097 consumeError(std::move(Err));
1098 return Error::success();
1099 }
1100 return Error::success();
1101 }
1102 // Couldn't load an index, fallback to loading all the block "old-style".
1103 }
1104
1105 unsigned NextMetadataNo = MetadataList.size();
1106
1107 // Read all the records.
1108 while (true) {
1109 BitstreamEntry Entry;
1110 if (Error E = Stream.advanceSkippingSubblocks().moveInto(Entry))
1111 return E;
1112
1113 switch (Entry.Kind) {
1114 case BitstreamEntry::SubBlock: // Handled for us already.
1116 return error("Malformed block");
1118 resolveForwardRefsAndPlaceholders(Placeholders);
1119 upgradeDebugInfo(ModuleLevel);
1120 return Error::success();
1122 // The interesting case.
1123 break;
1124 }
1125
1126 // Read a record.
1127 Record.clear();
1128 StringRef Blob;
1129 ++NumMDRecordLoaded;
1130 if (Expected<unsigned> MaybeCode =
1131 Stream.readRecord(Entry.ID, Record, &Blob)) {
1132 if (Error Err = parseOneMetadata(Record, MaybeCode.get(), Placeholders,
1133 Blob, NextMetadataNo))
1134 return Err;
1135 } else
1136 return MaybeCode.takeError();
1137 }
1138}
1139
1140MDString *MetadataLoader::MetadataLoaderImpl::lazyLoadOneMDString(unsigned ID) {
1141 ++NumMDStringLoaded;
1142 if (Metadata *MD = MetadataList.lookup(ID))
1143 return cast<MDString>(MD);
1144 auto MDS = MDString::get(Context, MDStringRef[ID]);
1145 MetadataList.assignValue(MDS, ID);
1146 return MDS;
1147}
1148
1149void MetadataLoader::MetadataLoaderImpl::lazyLoadOneMetadata(
1150 unsigned ID, PlaceholderQueue &Placeholders) {
1151 assert(ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size());
1152 assert(ID >= MDStringRef.size() && "Unexpected lazy-loading of MDString");
1153 // Lookup first if the metadata hasn't already been loaded.
1154 if (auto *MD = MetadataList.lookup(ID)) {
1155 auto *N = cast<MDNode>(MD);
1156 if (!N->isTemporary())
1157 return;
1158 }
1160 StringRef Blob;
1161 if (Error Err = IndexCursor.JumpToBit(
1162 GlobalMetadataBitPosIndex[ID - MDStringRef.size()]))
1163 report_fatal_error("lazyLoadOneMetadata failed jumping: " +
1164 Twine(toString(std::move(Err))));
1165 BitstreamEntry Entry;
1166 if (Error E = IndexCursor.advanceSkippingSubblocks().moveInto(Entry))
1167 // FIXME this drops the error on the floor.
1168 report_fatal_error("lazyLoadOneMetadata failed advanceSkippingSubblocks: " +
1169 Twine(toString(std::move(E))));
1170 ++NumMDRecordLoaded;
1171 if (Expected<unsigned> MaybeCode =
1172 IndexCursor.readRecord(Entry.ID, Record, &Blob)) {
1173 if (Error Err =
1174 parseOneMetadata(Record, MaybeCode.get(), Placeholders, Blob, ID))
1175 report_fatal_error("Can't lazyload MD, parseOneMetadata: " +
1176 Twine(toString(std::move(Err))));
1177 } else
1178 report_fatal_error("Can't lazyload MD: " +
1179 Twine(toString(MaybeCode.takeError())));
1180}
1181
1182/// Ensure that all forward-references and placeholders are resolved.
1183/// Iteratively lazy-loading metadata on-demand if needed.
1184void MetadataLoader::MetadataLoaderImpl::resolveForwardRefsAndPlaceholders(
1185 PlaceholderQueue &Placeholders) {
1186 DenseSet<unsigned> Temporaries;
1187 while (true) {
1188 // Populate Temporaries with the placeholders that haven't been loaded yet.
1189 Placeholders.getTemporaries(MetadataList, Temporaries);
1190
1191 // If we don't have any temporary, or FwdReference, we're done!
1192 if (Temporaries.empty() && !MetadataList.hasFwdRefs())
1193 break;
1194
1195 // First, load all the temporaries. This can add new placeholders or
1196 // forward references.
1197 for (auto ID : Temporaries)
1198 lazyLoadOneMetadata(ID, Placeholders);
1199 Temporaries.clear();
1200
1201 // Second, load the forward-references. This can also add new placeholders
1202 // or forward references.
1203 while (MetadataList.hasFwdRefs())
1204 lazyLoadOneMetadata(MetadataList.getNextFwdRef(), Placeholders);
1205 }
1206 // At this point we don't have any forward reference remaining, or temporary
1207 // that haven't been loaded. We can safely drop RAUW support and mark cycles
1208 // as resolved.
1209 MetadataList.tryToResolveCycles();
1210
1211 // Finally, everything is in place, we can replace the placeholders operands
1212 // with the final node they refer to.
1213 Placeholders.flush(MetadataList);
1214}
1215
1216static Value *getValueFwdRef(BitcodeReaderValueList &ValueList, unsigned Idx,
1217 Type *Ty, unsigned TyID) {
1218 Value *V = ValueList.getValueFwdRef(Idx, Ty, TyID,
1219 /*ConstExprInsertBB*/ nullptr);
1220 if (V)
1221 return V;
1222
1223 // This is a reference to a no longer supported constant expression.
1224 // Pretend that the constant was deleted, which will replace metadata
1225 // references with undef.
1226 // TODO: This is a rather indirect check. It would be more elegant to use
1227 // a separate ErrorInfo for constant materialization failure and thread
1228 // the error reporting through getValueFwdRef().
1229 if (Idx < ValueList.size() && ValueList[Idx] &&
1230 ValueList[Idx]->getType() == Ty)
1231 return UndefValue::get(Ty);
1232
1233 return nullptr;
1234}
1235
1236Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata(
1237 SmallVectorImpl<uint64_t> &Record, unsigned Code,
1238 PlaceholderQueue &Placeholders, StringRef Blob, unsigned &NextMetadataNo) {
1239
1240 bool IsDistinct = false;
1241 auto getMD = [&](unsigned ID) -> Metadata * {
1242 if (ID < MDStringRef.size())
1243 return lazyLoadOneMDString(ID);
1244 if (!IsDistinct) {
1245 if (auto *MD = MetadataList.lookup(ID))
1246 return MD;
1247 // If lazy-loading is enabled, we try recursively to load the operand
1248 // instead of creating a temporary.
1249 if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
1250 // Create a temporary for the node that is referencing the operand we
1251 // will lazy-load. It is needed before recursing in case there are
1252 // uniquing cycles.
1253 MetadataList.getMetadataFwdRef(NextMetadataNo);
1254 lazyLoadOneMetadata(ID, Placeholders);
1255 return MetadataList.lookup(ID);
1256 }
1257 // Return a temporary.
1258 return MetadataList.getMetadataFwdRef(ID);
1259 }
1260 if (auto *MD = MetadataList.getMetadataIfResolved(ID))
1261 return MD;
1262 return &Placeholders.getPlaceholderOp(ID);
1263 };
1264 auto getMDOrNull = [&](unsigned ID) -> Metadata * {
1265 if (ID)
1266 return getMD(ID - 1);
1267 return nullptr;
1268 };
1269 auto getMDOrNullWithoutPlaceholders = [&](unsigned ID) -> Metadata * {
1270 if (ID)
1271 return MetadataList.getMetadataFwdRef(ID - 1);
1272 return nullptr;
1273 };
1274 auto getMDString = [&](unsigned ID) -> MDString * {
1275 // This requires that the ID is not really a forward reference. In
1276 // particular, the MDString must already have been resolved.
1277 auto MDS = getMDOrNull(ID);
1278 return cast_or_null<MDString>(MDS);
1279 };
1280
1281 // Support for old type refs.
1282 auto getDITypeRefOrNull = [&](unsigned ID) {
1283 return MetadataList.upgradeTypeRef(getMDOrNull(ID));
1284 };
1285
1286#define GET_OR_DISTINCT(CLASS, ARGS) \
1287 (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
1288
1289 switch (Code) {
1290 default: // Default behavior: ignore.
1291 break;
1292 case bitc::METADATA_NAME: {
1293 // Read name of the named metadata.
1294 SmallString<8> Name(Record.begin(), Record.end());
1295 Record.clear();
1296 if (Error E = Stream.ReadCode().moveInto(Code))
1297 return E;
1298
1299 ++NumMDRecordLoaded;
1300 if (Expected<unsigned> MaybeNextBitCode = Stream.readRecord(Code, Record)) {
1301 if (MaybeNextBitCode.get() != bitc::METADATA_NAMED_NODE)
1302 return error("METADATA_NAME not followed by METADATA_NAMED_NODE");
1303 } else
1304 return MaybeNextBitCode.takeError();
1305
1306 // Read named metadata elements.
1307 unsigned Size = Record.size();
1308 NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name);
1309 for (unsigned i = 0; i != Size; ++i) {
1310 MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
1311 if (!MD)
1312 return error("Invalid named metadata: expect fwd ref to MDNode");
1313 NMD->addOperand(MD);
1314 }
1315 break;
1316 }
1318 // Deprecated, but still needed to read old bitcode files.
1319 // This is a LocalAsMetadata record, the only type of function-local
1320 // metadata.
1321 if (Record.size() % 2 == 1)
1322 return error("Invalid record");
1323
1324 // If this isn't a LocalAsMetadata record, we're dropping it. This used
1325 // to be legal, but there's no upgrade path.
1326 auto dropRecord = [&] {
1327 MetadataList.assignValue(MDNode::get(Context, std::nullopt),
1328 NextMetadataNo);
1329 NextMetadataNo++;
1330 };
1331 if (Record.size() != 2) {
1332 dropRecord();
1333 break;
1334 }
1335
1336 unsigned TyID = Record[0];
1337 Type *Ty = Callbacks.GetTypeByID(TyID);
1338 if (!Ty || Ty->isMetadataTy() || Ty->isVoidTy()) {
1339 dropRecord();
1340 break;
1341 }
1342
1343 Value *V = ValueList.getValueFwdRef(Record[1], Ty, TyID,
1344 /*ConstExprInsertBB*/ nullptr);
1345 if (!V)
1346 return error("Invalid value reference from old fn metadata");
1347
1348 MetadataList.assignValue(LocalAsMetadata::get(V), NextMetadataNo);
1349 NextMetadataNo++;
1350 break;
1351 }
1353 // Deprecated, but still needed to read old bitcode files.
1354 if (Record.size() % 2 == 1)
1355 return error("Invalid record");
1356
1357 unsigned Size = Record.size();
1359 for (unsigned i = 0; i != Size; i += 2) {
1360 unsigned TyID = Record[i];
1361 Type *Ty = Callbacks.GetTypeByID(TyID);
1362 if (!Ty)
1363 return error("Invalid record");
1364 if (Ty->isMetadataTy())
1365 Elts.push_back(getMD(Record[i + 1]));
1366 else if (!Ty->isVoidTy()) {
1367 Value *V = getValueFwdRef(ValueList, Record[i + 1], Ty, TyID);
1368 if (!V)
1369 return error("Invalid value reference from old metadata");
1371 assert(isa<ConstantAsMetadata>(MD) &&
1372 "Expected non-function-local metadata");
1373 callMDTypeCallback(&MD, TyID);
1374 Elts.push_back(MD);
1375 } else
1376 Elts.push_back(nullptr);
1377 }
1378 MetadataList.assignValue(MDNode::get(Context, Elts), NextMetadataNo);
1379 NextMetadataNo++;
1380 break;
1381 }
1382 case bitc::METADATA_VALUE: {
1383 if (Record.size() != 2)
1384 return error("Invalid record");
1385
1386 unsigned TyID = Record[0];
1387 Type *Ty = Callbacks.GetTypeByID(TyID);
1388 if (!Ty || Ty->isMetadataTy() || Ty->isVoidTy())
1389 return error("Invalid record");
1390
1391 Value *V = getValueFwdRef(ValueList, Record[1], Ty, TyID);
1392 if (!V)
1393 return error("Invalid value reference from metadata");
1394
1396 callMDTypeCallback(&MD, TyID);
1397 MetadataList.assignValue(MD, NextMetadataNo);
1398 NextMetadataNo++;
1399 break;
1400 }
1402 IsDistinct = true;
1403 [[fallthrough]];
1404 case bitc::METADATA_NODE: {
1406 Elts.reserve(Record.size());
1407 for (unsigned ID : Record)
1408 Elts.push_back(getMDOrNull(ID));
1409 MetadataList.assignValue(IsDistinct ? MDNode::getDistinct(Context, Elts)
1410 : MDNode::get(Context, Elts),
1411 NextMetadataNo);
1412 NextMetadataNo++;
1413 break;
1414 }
1416 if (Record.size() != 5 && Record.size() != 6)
1417 return error("Invalid record");
1418
1419 IsDistinct = Record[0];
1420 unsigned Line = Record[1];
1421 unsigned Column = Record[2];
1422 Metadata *Scope = getMD(Record[3]);
1423 Metadata *InlinedAt = getMDOrNull(Record[4]);
1424 bool ImplicitCode = Record.size() == 6 && Record[5];
1425 MetadataList.assignValue(
1426 GET_OR_DISTINCT(DILocation, (Context, Line, Column, Scope, InlinedAt,
1427 ImplicitCode)),
1428 NextMetadataNo);
1429 NextMetadataNo++;
1430 break;
1431 }
1433 if (Record.size() < 4)
1434 return error("Invalid record");
1435
1436 IsDistinct = Record[0];
1437 unsigned Tag = Record[1];
1438 unsigned Version = Record[2];
1439
1440 if (Tag >= 1u << 16 || Version != 0)
1441 return error("Invalid record");
1442
1443 auto *Header = getMDString(Record[3]);
1445 for (unsigned I = 4, E = Record.size(); I != E; ++I)
1446 DwarfOps.push_back(getMDOrNull(Record[I]));
1447 MetadataList.assignValue(
1448 GET_OR_DISTINCT(GenericDINode, (Context, Tag, Header, DwarfOps)),
1449 NextMetadataNo);
1450 NextMetadataNo++;
1451 break;
1452 }
1454 Metadata *Val = nullptr;
1455 // Operand 'count' is interpreted as:
1456 // - Signed integer (version 0)
1457 // - Metadata node (version 1)
1458 // Operand 'lowerBound' is interpreted as:
1459 // - Signed integer (version 0 and 1)
1460 // - Metadata node (version 2)
1461 // Operands 'upperBound' and 'stride' are interpreted as:
1462 // - Metadata node (version 2)
1463 switch (Record[0] >> 1) {
1464 case 0:
1466 (Context, Record[1], unrotateSign(Record[2])));
1467 break;
1468 case 1:
1469 Val = GET_OR_DISTINCT(DISubrange, (Context, getMDOrNull(Record[1]),
1470 unrotateSign(Record[2])));
1471 break;
1472 case 2:
1473 Val = GET_OR_DISTINCT(
1474 DISubrange, (Context, getMDOrNull(Record[1]), getMDOrNull(Record[2]),
1475 getMDOrNull(Record[3]), getMDOrNull(Record[4])));
1476 break;
1477 default:
1478 return error("Invalid record: Unsupported version of DISubrange");
1479 }
1480
1481 MetadataList.assignValue(Val, NextMetadataNo);
1482 IsDistinct = Record[0] & 1;
1483 NextMetadataNo++;
1484 break;
1485 }
1487 Metadata *Val = nullptr;
1489 (Context, getMDOrNull(Record[1]),
1490 getMDOrNull(Record[2]), getMDOrNull(Record[3]),
1491 getMDOrNull(Record[4])));
1492
1493 MetadataList.assignValue(Val, NextMetadataNo);
1494 IsDistinct = Record[0] & 1;
1495 NextMetadataNo++;
1496 break;
1497 }
1499 if (Record.size() < 3)
1500 return error("Invalid record");
1501
1502 IsDistinct = Record[0] & 1;
1503 bool IsUnsigned = Record[0] & 2;
1504 bool IsBigInt = Record[0] & 4;
1505 APInt Value;
1506
1507 if (IsBigInt) {
1508 const uint64_t BitWidth = Record[1];
1509 const size_t NumWords = Record.size() - 3;
1510 Value = readWideAPInt(ArrayRef(&Record[3], NumWords), BitWidth);
1511 } else
1512 Value = APInt(64, unrotateSign(Record[1]), !IsUnsigned);
1513
1514 MetadataList.assignValue(
1516 (Context, Value, IsUnsigned, getMDString(Record[2]))),
1517 NextMetadataNo);
1518 NextMetadataNo++;
1519 break;
1520 }
1522 if (Record.size() < 6 || Record.size() > 7)
1523 return error("Invalid record");
1524
1525 IsDistinct = Record[0];
1526 DINode::DIFlags Flags = (Record.size() > 6)
1527 ? static_cast<DINode::DIFlags>(Record[6])
1528 : DINode::FlagZero;
1529
1530 MetadataList.assignValue(
1532 (Context, Record[1], getMDString(Record[2]), Record[3],
1533 Record[4], Record[5], Flags)),
1534 NextMetadataNo);
1535 NextMetadataNo++;
1536 break;
1537 }
1539 if (Record.size() > 9 || Record.size() < 8)
1540 return error("Invalid record");
1541
1542 IsDistinct = Record[0];
1543 bool SizeIs8 = Record.size() == 8;
1544 // StringLocationExp (i.e. Record[5]) is added at a later time
1545 // than the other fields. The code here enables backward compatibility.
1546 Metadata *StringLocationExp = SizeIs8 ? nullptr : getMDOrNull(Record[5]);
1547 unsigned Offset = SizeIs8 ? 5 : 6;
1548 MetadataList.assignValue(
1550 (Context, Record[1], getMDString(Record[2]),
1551 getMDOrNull(Record[3]), getMDOrNull(Record[4]),
1552 StringLocationExp, Record[Offset], Record[Offset + 1],
1553 Record[Offset + 2])),
1554 NextMetadataNo);
1555 NextMetadataNo++;
1556 break;
1557 }
1559 if (Record.size() < 12 || Record.size() > 14)
1560 return error("Invalid record");
1561
1562 // DWARF address space is encoded as N->getDWARFAddressSpace() + 1. 0 means
1563 // that there is no DWARF address space associated with DIDerivedType.
1564 std::optional<unsigned> DWARFAddressSpace;
1565 if (Record.size() > 12 && Record[12])
1566 DWARFAddressSpace = Record[12] - 1;
1567
1568 Metadata *Annotations = nullptr;
1569 if (Record.size() > 13 && Record[13])
1570 Annotations = getMDOrNull(Record[13]);
1571
1572 IsDistinct = Record[0];
1573 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]);
1574 MetadataList.assignValue(
1576 (Context, Record[1], getMDString(Record[2]),
1577 getMDOrNull(Record[3]), Record[4],
1578 getDITypeRefOrNull(Record[5]),
1579 getDITypeRefOrNull(Record[6]), Record[7], Record[8],
1580 Record[9], DWARFAddressSpace, Flags,
1581 getDITypeRefOrNull(Record[11]), Annotations)),
1582 NextMetadataNo);
1583 NextMetadataNo++;
1584 break;
1585 }
1587 if (Record.size() < 16 || Record.size() > 22)
1588 return error("Invalid record");
1589
1590 // If we have a UUID and this is not a forward declaration, lookup the
1591 // mapping.
1592 IsDistinct = Record[0] & 0x1;
1593 bool IsNotUsedInTypeRef = Record[0] >= 2;
1594 unsigned Tag = Record[1];
1595 MDString *Name = getMDString(Record[2]);
1596 Metadata *File = getMDOrNull(Record[3]);
1597 unsigned Line = Record[4];
1598 Metadata *Scope = getDITypeRefOrNull(Record[5]);
1599 Metadata *BaseType = nullptr;
1600 uint64_t SizeInBits = Record[7];
1601 if (Record[8] > (uint64_t)std::numeric_limits<uint32_t>::max())
1602 return error("Alignment value is too large");
1603 uint32_t AlignInBits = Record[8];
1604 uint64_t OffsetInBits = 0;
1605 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]);
1606 Metadata *Elements = nullptr;
1607 unsigned RuntimeLang = Record[12];
1608 Metadata *VTableHolder = nullptr;
1609 Metadata *TemplateParams = nullptr;
1610 Metadata *Discriminator = nullptr;
1611 Metadata *DataLocation = nullptr;
1612 Metadata *Associated = nullptr;
1613 Metadata *Allocated = nullptr;
1614 Metadata *Rank = nullptr;
1615 Metadata *Annotations = nullptr;
1616 auto *Identifier = getMDString(Record[15]);
1617 // If this module is being parsed so that it can be ThinLTO imported
1618 // into another module, composite types only need to be imported as
1619 // type declarations (unless full type definitions are requested).
1620 // Create type declarations up front to save memory. This is only
1621 // done for types which have an Identifier, and are therefore
1622 // subject to the ODR.
1623 //
1624 // buildODRType handles the case where this is type ODRed with a
1625 // definition needed by the importing module, in which case the
1626 // existing definition is used.
1627 //
1628 // We always import full definitions for anonymous composite types,
1629 // as without a name, debuggers cannot easily resolve a declaration
1630 // to its definition.
1631 if (IsImporting && !ImportFullTypeDefinitions && Identifier && Name &&
1632 (Tag == dwarf::DW_TAG_enumeration_type ||
1633 Tag == dwarf::DW_TAG_class_type ||
1634 Tag == dwarf::DW_TAG_structure_type ||
1635 Tag == dwarf::DW_TAG_union_type)) {
1636 Flags = Flags | DINode::FlagFwdDecl;
1637 // This is a hack around preserving template parameters for simplified
1638 // template names - it should probably be replaced with a
1639 // DICompositeType flag specifying whether template parameters are
1640 // required on declarations of this type.
1641 StringRef NameStr = Name->getString();
1642 if (!NameStr.contains('<') || NameStr.starts_with("_STN|"))
1643 TemplateParams = getMDOrNull(Record[14]);
1644 } else {
1645 BaseType = getDITypeRefOrNull(Record[6]);
1646 OffsetInBits = Record[9];
1647 Elements = getMDOrNull(Record[11]);
1648 VTableHolder = getDITypeRefOrNull(Record[13]);
1649 TemplateParams = getMDOrNull(Record[14]);
1650 if (Record.size() > 16)
1651 Discriminator = getMDOrNull(Record[16]);
1652 if (Record.size() > 17)
1653 DataLocation = getMDOrNull(Record[17]);
1654 if (Record.size() > 19) {
1655 Associated = getMDOrNull(Record[18]);
1656 Allocated = getMDOrNull(Record[19]);
1657 }
1658 if (Record.size() > 20) {
1659 Rank = getMDOrNull(Record[20]);
1660 }
1661 if (Record.size() > 21) {
1662 Annotations = getMDOrNull(Record[21]);
1663 }
1664 }
1665 DICompositeType *CT = nullptr;
1666 if (Identifier)
1668 Context, *Identifier, Tag, Name, File, Line, Scope, BaseType,
1669 SizeInBits, AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
1670 VTableHolder, TemplateParams, Discriminator, DataLocation, Associated,
1671 Allocated, Rank, Annotations);
1672
1673 // Create a node if we didn't get a lazy ODR type.
1674 if (!CT)
1676 (Context, Tag, Name, File, Line, Scope, BaseType,
1677 SizeInBits, AlignInBits, OffsetInBits, Flags,
1678 Elements, RuntimeLang, VTableHolder, TemplateParams,
1679 Identifier, Discriminator, DataLocation, Associated,
1680 Allocated, Rank, Annotations));
1681 if (!IsNotUsedInTypeRef && Identifier)
1682 MetadataList.addTypeRef(*Identifier, *cast<DICompositeType>(CT));
1683
1684 MetadataList.assignValue(CT, NextMetadataNo);
1685 NextMetadataNo++;
1686 break;
1687 }
1689 if (Record.size() < 3 || Record.size() > 4)
1690 return error("Invalid record");
1691 bool IsOldTypeRefArray = Record[0] < 2;
1692 unsigned CC = (Record.size() > 3) ? Record[3] : 0;
1693
1694 IsDistinct = Record[0] & 0x1;
1695 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[1]);
1696 Metadata *Types = getMDOrNull(Record[2]);
1697 if (LLVM_UNLIKELY(IsOldTypeRefArray))
1698 Types = MetadataList.upgradeTypeRefArray(Types);
1699
1700 MetadataList.assignValue(
1701 GET_OR_DISTINCT(DISubroutineType, (Context, Flags, CC, Types)),
1702 NextMetadataNo);
1703 NextMetadataNo++;
1704 break;
1705 }
1706
1707 case bitc::METADATA_MODULE: {
1708 if (Record.size() < 5 || Record.size() > 9)
1709 return error("Invalid record");
1710
1711 unsigned Offset = Record.size() >= 8 ? 2 : 1;
1712 IsDistinct = Record[0];
1713 MetadataList.assignValue(
1715 DIModule,
1716 (Context, Record.size() >= 8 ? getMDOrNull(Record[1]) : nullptr,
1717 getMDOrNull(Record[0 + Offset]), getMDString(Record[1 + Offset]),
1718 getMDString(Record[2 + Offset]), getMDString(Record[3 + Offset]),
1719 getMDString(Record[4 + Offset]),
1720 Record.size() <= 7 ? 0 : Record[7],
1721 Record.size() <= 8 ? false : Record[8])),
1722 NextMetadataNo);
1723 NextMetadataNo++;
1724 break;
1725 }
1726
1727 case bitc::METADATA_FILE: {
1728 if (Record.size() != 3 && Record.size() != 5 && Record.size() != 6)
1729 return error("Invalid record");
1730
1731 IsDistinct = Record[0];
1732 std::optional<DIFile::ChecksumInfo<MDString *>> Checksum;
1733 // The BitcodeWriter writes null bytes into Record[3:4] when the Checksum
1734 // is not present. This matches up with the old internal representation,
1735 // and the old encoding for CSK_None in the ChecksumKind. The new
1736 // representation reserves the value 0 in the ChecksumKind to continue to
1737 // encode None in a backwards-compatible way.
1738 if (Record.size() > 4 && Record[3] && Record[4])
1739 Checksum.emplace(static_cast<DIFile::ChecksumKind>(Record[3]),
1740 getMDString(Record[4]));
1741 MetadataList.assignValue(
1743 (Context, getMDString(Record[1]),
1744 getMDString(Record[2]), Checksum,
1745 Record.size() > 5 ? getMDString(Record[5]) : nullptr)),
1746 NextMetadataNo);
1747 NextMetadataNo++;
1748 break;
1749 }
1751 if (Record.size() < 14 || Record.size() > 22)
1752 return error("Invalid record");
1753
1754 // Ignore Record[0], which indicates whether this compile unit is
1755 // distinct. It's always distinct.
1756 IsDistinct = true;
1758 Context, Record[1], getMDOrNull(Record[2]), getMDString(Record[3]),
1759 Record[4], getMDString(Record[5]), Record[6], getMDString(Record[7]),
1760 Record[8], getMDOrNull(Record[9]), getMDOrNull(Record[10]),
1761 getMDOrNull(Record[12]), getMDOrNull(Record[13]),
1762 Record.size() <= 15 ? nullptr : getMDOrNull(Record[15]),
1763 Record.size() <= 14 ? 0 : Record[14],
1764 Record.size() <= 16 ? true : Record[16],
1765 Record.size() <= 17 ? false : Record[17],
1766 Record.size() <= 18 ? 0 : Record[18],
1767 Record.size() <= 19 ? false : Record[19],
1768 Record.size() <= 20 ? nullptr : getMDString(Record[20]),
1769 Record.size() <= 21 ? nullptr : getMDString(Record[21]));
1770
1771 MetadataList.assignValue(CU, NextMetadataNo);
1772 NextMetadataNo++;
1773
1774 // Move the Upgrade the list of subprograms.
1775 if (Metadata *SPs = getMDOrNullWithoutPlaceholders(Record[11]))
1776 CUSubprograms.push_back({CU, SPs});
1777 break;
1778 }
1780 if (Record.size() < 18 || Record.size() > 21)
1781 return error("Invalid record");
1782
1783 bool HasSPFlags = Record[0] & 4;
1784
1787 if (!HasSPFlags)
1788 Flags = static_cast<DINode::DIFlags>(Record[11 + 2]);
1789 else {
1790 Flags = static_cast<DINode::DIFlags>(Record[11]);
1791 SPFlags = static_cast<DISubprogram::DISPFlags>(Record[9]);
1792 }
1793
1794 // Support for old metadata when
1795 // subprogram specific flags are placed in DIFlags.
1796 const unsigned DIFlagMainSubprogram = 1 << 21;
1797 bool HasOldMainSubprogramFlag = Flags & DIFlagMainSubprogram;
1798 if (HasOldMainSubprogramFlag)
1799 // Remove old DIFlagMainSubprogram from DIFlags.
1800 // Note: This assumes that any future use of bit 21 defaults to it
1801 // being 0.
1802 Flags &= ~static_cast<DINode::DIFlags>(DIFlagMainSubprogram);
1803
1804 if (HasOldMainSubprogramFlag && HasSPFlags)
1805 SPFlags |= DISubprogram::SPFlagMainSubprogram;
1806 else if (!HasSPFlags)
1807 SPFlags = DISubprogram::toSPFlags(
1808 /*IsLocalToUnit=*/Record[7], /*IsDefinition=*/Record[8],
1809 /*IsOptimized=*/Record[14], /*Virtuality=*/Record[11],
1810 /*IsMainSubprogram=*/HasOldMainSubprogramFlag);
1811
1812 // All definitions should be distinct.
1813 IsDistinct = (Record[0] & 1) || (SPFlags & DISubprogram::SPFlagDefinition);
1814 // Version 1 has a Function as Record[15].
1815 // Version 2 has removed Record[15].
1816 // Version 3 has the Unit as Record[15].
1817 // Version 4 added thisAdjustment.
1818 // Version 5 repacked flags into DISPFlags, changing many element numbers.
1819 bool HasUnit = Record[0] & 2;
1820 if (!HasSPFlags && HasUnit && Record.size() < 19)
1821 return error("Invalid record");
1822 if (HasSPFlags && !HasUnit)
1823 return error("Invalid record");
1824 // Accommodate older formats.
1825 bool HasFn = false;
1826 bool HasThisAdj = true;
1827 bool HasThrownTypes = true;
1828 bool HasAnnotations = false;
1829 bool HasTargetFuncName = false;
1830 unsigned OffsetA = 0;
1831 unsigned OffsetB = 0;
1832 if (!HasSPFlags) {
1833 OffsetA = 2;
1834 OffsetB = 2;
1835 if (Record.size() >= 19) {
1836 HasFn = !HasUnit;
1837 OffsetB++;
1838 }
1839 HasThisAdj = Record.size() >= 20;
1840 HasThrownTypes = Record.size() >= 21;
1841 } else {
1842 HasAnnotations = Record.size() >= 19;
1843 HasTargetFuncName = Record.size() >= 20;
1844 }
1845 Metadata *CUorFn = getMDOrNull(Record[12 + OffsetB]);
1848 (Context,
1849 getDITypeRefOrNull(Record[1]), // scope
1850 getMDString(Record[2]), // name
1851 getMDString(Record[3]), // linkageName
1852 getMDOrNull(Record[4]), // file
1853 Record[5], // line
1854 getMDOrNull(Record[6]), // type
1855 Record[7 + OffsetA], // scopeLine
1856 getDITypeRefOrNull(Record[8 + OffsetA]), // containingType
1857 Record[10 + OffsetA], // virtualIndex
1858 HasThisAdj ? Record[16 + OffsetB] : 0, // thisAdjustment
1859 Flags, // flags
1860 SPFlags, // SPFlags
1861 HasUnit ? CUorFn : nullptr, // unit
1862 getMDOrNull(Record[13 + OffsetB]), // templateParams
1863 getMDOrNull(Record[14 + OffsetB]), // declaration
1864 getMDOrNull(Record[15 + OffsetB]), // retainedNodes
1865 HasThrownTypes ? getMDOrNull(Record[17 + OffsetB])
1866 : nullptr, // thrownTypes
1867 HasAnnotations ? getMDOrNull(Record[18 + OffsetB])
1868 : nullptr, // annotations
1869 HasTargetFuncName ? getMDString(Record[19 + OffsetB])
1870 : nullptr // targetFuncName
1871 ));
1872 MetadataList.assignValue(SP, NextMetadataNo);
1873 NextMetadataNo++;
1874
1875 // Upgrade sp->function mapping to function->sp mapping.
1876 if (HasFn) {
1877 if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(CUorFn))
1878 if (auto *F = dyn_cast<Function>(CMD->getValue())) {
1879 if (F->isMaterializable())
1880 // Defer until materialized; unmaterialized functions may not have
1881 // metadata.
1882 FunctionsWithSPs[F] = SP;
1883 else if (!F->empty())
1884 F->setSubprogram(SP);
1885 }
1886 }
1887 break;
1888 }
1890 if (Record.size() != 5)
1891 return error("Invalid record");
1892
1893 IsDistinct = Record[0];
1894 MetadataList.assignValue(
1896 (Context, getMDOrNull(Record[1]),
1897 getMDOrNull(Record[2]), Record[3], Record[4])),
1898 NextMetadataNo);
1899 NextMetadataNo++;
1900 break;
1901 }
1903 if (Record.size() != 4)
1904 return error("Invalid record");
1905
1906 IsDistinct = Record[0];
1907 MetadataList.assignValue(
1909 (Context, getMDOrNull(Record[1]),
1910 getMDOrNull(Record[2]), Record[3])),
1911 NextMetadataNo);
1912 NextMetadataNo++;
1913 break;
1914 }
1916 IsDistinct = Record[0] & 1;
1917 MetadataList.assignValue(
1919 (Context, getMDOrNull(Record[1]),
1920 getMDOrNull(Record[2]), getMDString(Record[3]),
1921 getMDOrNull(Record[4]), Record[5])),
1922 NextMetadataNo);
1923 NextMetadataNo++;
1924 break;
1925 }
1927 // Newer versions of DINamespace dropped file and line.
1928 MDString *Name;
1929 if (Record.size() == 3)
1930 Name = getMDString(Record[2]);
1931 else if (Record.size() == 5)
1932 Name = getMDString(Record[3]);
1933 else
1934 return error("Invalid record");
1935
1936 IsDistinct = Record[0] & 1;
1937 bool ExportSymbols = Record[0] & 2;
1938 MetadataList.assignValue(
1940 (Context, getMDOrNull(Record[1]), Name, ExportSymbols)),
1941 NextMetadataNo);
1942 NextMetadataNo++;
1943 break;
1944 }
1945 case bitc::METADATA_MACRO: {
1946 if (Record.size() != 5)
1947 return error("Invalid record");
1948
1949 IsDistinct = Record[0];
1950 MetadataList.assignValue(
1952 (Context, Record[1], Record[2], getMDString(Record[3]),
1953 getMDString(Record[4]))),
1954 NextMetadataNo);
1955 NextMetadataNo++;
1956 break;
1957 }
1959 if (Record.size() != 5)
1960 return error("Invalid record");
1961
1962 IsDistinct = Record[0];
1963 MetadataList.assignValue(
1965 (Context, Record[1], Record[2], getMDOrNull(Record[3]),
1966 getMDOrNull(Record[4]))),
1967 NextMetadataNo);
1968 NextMetadataNo++;
1969 break;
1970 }
1972 if (Record.size() < 3 || Record.size() > 4)
1973 return error("Invalid record");
1974
1975 IsDistinct = Record[0];
1976 MetadataList.assignValue(
1978 (Context, getMDString(Record[1]),
1979 getDITypeRefOrNull(Record[2]),
1980 (Record.size() == 4) ? getMDOrNull(Record[3])
1981 : getMDOrNull(false))),
1982 NextMetadataNo);
1983 NextMetadataNo++;
1984 break;
1985 }
1987 if (Record.size() < 5 || Record.size() > 6)
1988 return error("Invalid record");
1989
1990 IsDistinct = Record[0];
1991
1992 MetadataList.assignValue(
1995 (Context, Record[1], getMDString(Record[2]),
1996 getDITypeRefOrNull(Record[3]),
1997 (Record.size() == 6) ? getMDOrNull(Record[4]) : getMDOrNull(false),
1998 (Record.size() == 6) ? getMDOrNull(Record[5])
1999 : getMDOrNull(Record[4]))),
2000 NextMetadataNo);
2001 NextMetadataNo++;
2002 break;
2003 }
2005 if (Record.size() < 11 || Record.size() > 13)
2006 return error("Invalid record");
2007
2008 IsDistinct = Record[0] & 1;
2009 unsigned Version = Record[0] >> 1;
2010
2011 if (Version == 2) {
2012 Metadata *Annotations = nullptr;
2013 if (Record.size() > 12)
2014 Annotations = getMDOrNull(Record[12]);
2015
2016 MetadataList.assignValue(
2018 (Context, getMDOrNull(Record[1]),
2019 getMDString(Record[2]), getMDString(Record[3]),
2020 getMDOrNull(Record[4]), Record[5],
2021 getDITypeRefOrNull(Record[6]), Record[7], Record[8],
2022 getMDOrNull(Record[9]), getMDOrNull(Record[10]),
2023 Record[11], Annotations)),
2024 NextMetadataNo);
2025
2026 NextMetadataNo++;
2027 } else if (Version == 1) {
2028 // No upgrade necessary. A null field will be introduced to indicate
2029 // that no parameter information is available.
2030 MetadataList.assignValue(
2033 (Context, getMDOrNull(Record[1]), getMDString(Record[2]),
2034 getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
2035 getDITypeRefOrNull(Record[6]), Record[7], Record[8],
2036 getMDOrNull(Record[10]), nullptr, Record[11], nullptr)),
2037 NextMetadataNo);
2038
2039 NextMetadataNo++;
2040 } else if (Version == 0) {
2041 // Upgrade old metadata, which stored a global variable reference or a
2042 // ConstantInt here.
2043 NeedUpgradeToDIGlobalVariableExpression = true;
2044 Metadata *Expr = getMDOrNull(Record[9]);
2045 uint32_t AlignInBits = 0;
2046 if (Record.size() > 11) {
2047 if (Record[11] > (uint64_t)std::numeric_limits<uint32_t>::max())
2048 return error("Alignment value is too large");
2049 AlignInBits = Record[11];
2050 }
2051 GlobalVariable *Attach = nullptr;
2052 if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(Expr)) {
2053 if (auto *GV = dyn_cast<GlobalVariable>(CMD->getValue())) {
2054 Attach = GV;
2055 Expr = nullptr;
2056 } else if (auto *CI = dyn_cast<ConstantInt>(CMD->getValue())) {
2057 Expr = DIExpression::get(Context,
2058 {dwarf::DW_OP_constu, CI->getZExtValue(),
2059 dwarf::DW_OP_stack_value});
2060 } else {
2061 Expr = nullptr;
2062 }
2063 }
2066 (Context, getMDOrNull(Record[1]), getMDString(Record[2]),
2067 getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
2068 getDITypeRefOrNull(Record[6]), Record[7], Record[8],
2069 getMDOrNull(Record[10]), nullptr, AlignInBits, nullptr));
2070
2071 DIGlobalVariableExpression *DGVE = nullptr;
2072 if (Attach || Expr)
2074 Context, DGV, Expr ? Expr : DIExpression::get(Context, {}));
2075 if (Attach)
2076 Attach->addDebugInfo(DGVE);
2077
2078 auto *MDNode = Expr ? cast<Metadata>(DGVE) : cast<Metadata>(DGV);
2079 MetadataList.assignValue(MDNode, NextMetadataNo);
2080 NextMetadataNo++;
2081 } else
2082 return error("Invalid record");
2083
2084 break;
2085 }
2087 if (Record.size() != 1)
2088 return error("Invalid DIAssignID record.");
2089
2090 IsDistinct = Record[0] & 1;
2091 if (!IsDistinct)
2092 return error("Invalid DIAssignID record. Must be distinct");
2093
2094 MetadataList.assignValue(DIAssignID::getDistinct(Context), NextMetadataNo);
2095 NextMetadataNo++;
2096 break;
2097 }
2099 // 10th field is for the obseleted 'inlinedAt:' field.
2100 if (Record.size() < 8 || Record.size() > 10)
2101 return error("Invalid record");
2102
2103 IsDistinct = Record[0] & 1;
2104 bool HasAlignment = Record[0] & 2;
2105 // 2nd field used to be an artificial tag, either DW_TAG_auto_variable or
2106 // DW_TAG_arg_variable, if we have alignment flag encoded it means, that
2107 // this is newer version of record which doesn't have artificial tag.
2108 bool HasTag = !HasAlignment && Record.size() > 8;
2109 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[7 + HasTag]);
2110 uint32_t AlignInBits = 0;
2111 Metadata *Annotations = nullptr;
2112 if (HasAlignment) {
2113 if (Record[8] > (uint64_t)std::numeric_limits<uint32_t>::max())
2114 return error("Alignment value is too large");
2115 AlignInBits = Record[8];
2116 if (Record.size() > 9)
2117 Annotations = getMDOrNull(Record[9]);
2118 }
2119
2120 MetadataList.assignValue(
2122 (Context, getMDOrNull(Record[1 + HasTag]),
2123 getMDString(Record[2 + HasTag]),
2124 getMDOrNull(Record[3 + HasTag]), Record[4 + HasTag],
2125 getDITypeRefOrNull(Record[5 + HasTag]),
2126 Record[6 + HasTag], Flags, AlignInBits, Annotations)),
2127 NextMetadataNo);
2128 NextMetadataNo++;
2129 break;
2130 }
2131 case bitc::METADATA_LABEL: {
2132 if (Record.size() != 5)
2133 return error("Invalid record");
2134
2135 IsDistinct = Record[0] & 1;
2136 MetadataList.assignValue(
2137 GET_OR_DISTINCT(DILabel, (Context, getMDOrNull(Record[1]),
2138 getMDString(Record[2]),
2139 getMDOrNull(Record[3]), Record[4])),
2140 NextMetadataNo);
2141 NextMetadataNo++;
2142 break;
2143 }
2145 if (Record.size() < 1)
2146 return error("Invalid record");
2147
2148 IsDistinct = Record[0] & 1;
2149 uint64_t Version = Record[0] >> 1;
2150 auto Elts = MutableArrayRef<uint64_t>(Record).slice(1);
2151
2153 if (Error Err = upgradeDIExpression(Version, Elts, Buffer))
2154 return Err;
2155
2156 MetadataList.assignValue(GET_OR_DISTINCT(DIExpression, (Context, Elts)),
2157 NextMetadataNo);
2158 NextMetadataNo++;
2159 break;
2160 }
2162 if (Record.size() != 3)
2163 return error("Invalid record");
2164
2165 IsDistinct = Record[0];
2166 Metadata *Expr = getMDOrNull(Record[2]);
2167 if (!Expr)
2168 Expr = DIExpression::get(Context, {});
2169 MetadataList.assignValue(
2171 (Context, getMDOrNull(Record[1]), Expr)),
2172 NextMetadataNo);
2173 NextMetadataNo++;
2174 break;
2175 }
2177 if (Record.size() != 8)
2178 return error("Invalid record");
2179
2180 IsDistinct = Record[0];
2181 MetadataList.assignValue(
2183 (Context, getMDString(Record[1]),
2184 getMDOrNull(Record[2]), Record[3],
2185 getMDString(Record[4]), getMDString(Record[5]),
2186 Record[6], getDITypeRefOrNull(Record[7]))),
2187 NextMetadataNo);
2188 NextMetadataNo++;
2189 break;
2190 }
2192 if (Record.size() < 6 || Record.size() > 8)
2193 return error("Invalid DIImportedEntity record");
2194
2195 IsDistinct = Record[0];
2196 bool HasFile = (Record.size() >= 7);
2197 bool HasElements = (Record.size() >= 8);
2198 MetadataList.assignValue(
2200 (Context, Record[1], getMDOrNull(Record[2]),
2201 getDITypeRefOrNull(Record[3]),
2202 HasFile ? getMDOrNull(Record[6]) : nullptr,
2203 HasFile ? Record[4] : 0, getMDString(Record[5]),
2204 HasElements ? getMDOrNull(Record[7]) : nullptr)),
2205 NextMetadataNo);
2206 NextMetadataNo++;
2207 break;
2208 }
2210 std::string String(Record.begin(), Record.end());
2211
2212 // Test for upgrading !llvm.loop.
2213 HasSeenOldLoopTags |= mayBeOldLoopAttachmentTag(String);
2214 ++NumMDStringLoaded;
2215 Metadata *MD = MDString::get(Context, String);
2216 MetadataList.assignValue(MD, NextMetadataNo);
2217 NextMetadataNo++;
2218 break;
2219 }
2221 auto CreateNextMDString = [&](StringRef Str) {
2222 ++NumMDStringLoaded;
2223 MetadataList.assignValue(MDString::get(Context, Str), NextMetadataNo);
2224 NextMetadataNo++;
2225 };
2226 if (Error Err = parseMetadataStrings(Record, Blob, CreateNextMDString))
2227 return Err;
2228 break;
2229 }
2231 if (Record.size() % 2 == 0)
2232 return error("Invalid record");
2233 unsigned ValueID = Record[0];
2234 if (ValueID >= ValueList.size())
2235 return error("Invalid record");
2236 if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID]))
2237 if (Error Err = parseGlobalObjectAttachment(
2238 *GO, ArrayRef<uint64_t>(Record).slice(1)))
2239 return Err;
2240 break;
2241 }
2242 case bitc::METADATA_KIND: {
2243 // Support older bitcode files that had METADATA_KIND records in a
2244 // block with METADATA_BLOCK_ID.
2245 if (Error Err = parseMetadataKindRecord(Record))
2246 return Err;
2247 break;
2248 }
2251 Elts.reserve(Record.size());
2252 for (uint64_t Elt : Record) {
2253 Metadata *MD = getMD(Elt);
2254 if (isa<MDNode>(MD) && cast<MDNode>(MD)->isTemporary())
2255 return error(
2256 "Invalid record: DIArgList should not contain forward refs");
2257 if (!isa<ValueAsMetadata>(MD))
2258 return error("Invalid record");
2259 Elts.push_back(cast<ValueAsMetadata>(MD));
2260 }
2261
2262 MetadataList.assignValue(DIArgList::get(Context, Elts), NextMetadataNo);
2263 NextMetadataNo++;
2264 break;
2265 }
2266 }
2267 return Error::success();
2268#undef GET_OR_DISTINCT
2269}
2270
2271Error MetadataLoader::MetadataLoaderImpl::parseMetadataStrings(
2273 function_ref<void(StringRef)> CallBack) {
2274 // All the MDStrings in the block are emitted together in a single
2275 // record. The strings are concatenated and stored in a blob along with
2276 // their sizes.
2277 if (Record.size() != 2)
2278 return error("Invalid record: metadata strings layout");
2279
2280 unsigned NumStrings = Record[0];
2281 unsigned StringsOffset = Record[1];
2282 if (!NumStrings)
2283 return error("Invalid record: metadata strings with no strings");
2284 if (StringsOffset > Blob.size())
2285 return error("Invalid record: metadata strings corrupt offset");
2286
2287 StringRef Lengths = Blob.slice(0, StringsOffset);
2288 SimpleBitstreamCursor R(Lengths);
2289
2290 StringRef Strings = Blob.drop_front(StringsOffset);
2291 do {
2292 if (R.AtEndOfStream())
2293 return error("Invalid record: metadata strings bad length");
2294
2295 uint32_t Size;
2296 if (Error E = R.ReadVBR(6).moveInto(Size))
2297 return E;
2298 if (Strings.size() < Size)
2299 return error("Invalid record: metadata strings truncated chars");
2300
2301 CallBack(Strings.slice(0, Size));
2302 Strings = Strings.drop_front(Size);
2303 } while (--NumStrings);
2304
2305 return Error::success();
2306}
2307
2308Error MetadataLoader::MetadataLoaderImpl::parseGlobalObjectAttachment(
2310 assert(Record.size() % 2 == 0);
2311 for (unsigned I = 0, E = Record.size(); I != E; I += 2) {
2312 auto K = MDKindMap.find(Record[I]);
2313 if (K == MDKindMap.end())
2314 return error("Invalid ID");
2315 MDNode *MD =
2316 dyn_cast_or_null<MDNode>(getMetadataFwdRefOrLoad(Record[I + 1]));
2317 if (!MD)
2318 return error("Invalid metadata attachment: expect fwd ref to MDNode");
2319 GO.addMetadata(K->second, *MD);
2320 }
2321 return Error::success();
2322}
2323
2324/// Parse metadata attachments.
2326 Function &F, ArrayRef<Instruction *> InstructionList) {
2327 if (Error Err = Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))
2328 return Err;
2329
2331 PlaceholderQueue Placeholders;
2332
2333 while (true) {
2334 BitstreamEntry Entry;
2335 if (Error E = Stream.advanceSkippingSubblocks().moveInto(Entry))
2336 return E;
2337
2338 switch (Entry.Kind) {
2339 case BitstreamEntry::SubBlock: // Handled for us already.
2341 return error("Malformed block");
2343 resolveForwardRefsAndPlaceholders(Placeholders);
2344 return Error::success();
2346 // The interesting case.
2347 break;
2348 }
2349
2350 // Read a metadata attachment record.
2351 Record.clear();
2352 ++NumMDRecordLoaded;
2353 Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
2354 if (!MaybeRecord)
2355 return MaybeRecord.takeError();
2356 switch (MaybeRecord.get()) {
2357 default: // Default behavior: ignore.
2358 break;
2360 unsigned RecordLength = Record.size();
2361 if (Record.empty())
2362 return error("Invalid record");
2363 if (RecordLength % 2 == 0) {
2364 // A function attachment.
2365 if (Error Err = parseGlobalObjectAttachment(F, Record))
2366 return Err;
2367 continue;
2368 }
2369
2370 // An instruction attachment.
2371 Instruction *Inst = InstructionList[Record[0]];
2372 for (unsigned i = 1; i != RecordLength; i = i + 2) {
2373 unsigned Kind = Record[i];
2374 DenseMap<unsigned, unsigned>::iterator I = MDKindMap.find(Kind);
2375 if (I == MDKindMap.end())
2376 return error("Invalid ID");
2377 if (I->second == LLVMContext::MD_tbaa && StripTBAA)
2378 continue;
2379
2380 auto Idx = Record[i + 1];
2381 if (Idx < (MDStringRef.size() + GlobalMetadataBitPosIndex.size()) &&
2382 !MetadataList.lookup(Idx)) {
2383 // Load the attachment if it is in the lazy-loadable range and hasn't
2384 // been loaded yet.
2385 lazyLoadOneMetadata(Idx, Placeholders);
2386 resolveForwardRefsAndPlaceholders(Placeholders);
2387 }
2388
2389 Metadata *Node = MetadataList.getMetadataFwdRef(Idx);
2390 if (isa<LocalAsMetadata>(Node))
2391 // Drop the attachment. This used to be legal, but there's no
2392 // upgrade path.
2393 break;
2394 MDNode *MD = dyn_cast_or_null<MDNode>(Node);
2395 if (!MD)
2396 return error("Invalid metadata attachment");
2397
2398 if (HasSeenOldLoopTags && I->second == LLVMContext::MD_loop)
2400
2401 if (I->second == LLVMContext::MD_tbaa) {
2402 assert(!MD->isTemporary() && "should load MDs before attachments");
2403 MD = UpgradeTBAANode(*MD);
2404 }
2405 Inst->setMetadata(I->second, MD);
2406 }
2407 break;
2408 }
2409 }
2410 }
2411}
2412
2413/// Parse a single METADATA_KIND record, inserting result in MDKindMap.
2414Error MetadataLoader::MetadataLoaderImpl::parseMetadataKindRecord(
2416 if (Record.size() < 2)
2417 return error("Invalid record");
2418
2419 unsigned Kind = Record[0];
2420 SmallString<8> Name(Record.begin() + 1, Record.end());
2421
2422 unsigned NewKind = TheModule.getMDKindID(Name.str());
2423 if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second)
2424 return error("Conflicting METADATA_KIND records");
2425 return Error::success();
2426}
2427
2428/// Parse the metadata kinds out of the METADATA_KIND_BLOCK.
2430 if (Error Err = Stream.EnterSubBlock(bitc::METADATA_KIND_BLOCK_ID))
2431 return Err;
2432
2434
2435 // Read all the records.
2436 while (true) {
2437 BitstreamEntry Entry;
2438 if (Error E = Stream.advanceSkippingSubblocks().moveInto(Entry))
2439 return E;
2440
2441 switch (Entry.Kind) {
2442 case BitstreamEntry::SubBlock: // Handled for us already.
2444 return error("Malformed block");
2446 return Error::success();
2448 // The interesting case.
2449 break;
2450 }
2451
2452 // Read a record.
2453 Record.clear();
2454 ++NumMDRecordLoaded;
2455 Expected<unsigned> MaybeCode = Stream.readRecord(Entry.ID, Record);
2456 if (!MaybeCode)
2457 return MaybeCode.takeError();
2458 switch (MaybeCode.get()) {
2459 default: // Default behavior: ignore.
2460 break;
2461 case bitc::METADATA_KIND: {
2462 if (Error Err = parseMetadataKindRecord(Record))
2463 return Err;
2464 break;
2465 }
2466 }
2467 }
2468}
2469
2471 Pimpl = std::move(RHS.Pimpl);
2472 return *this;
2473}
2475 : Pimpl(std::move(RHS.Pimpl)) {}
2476
2479 BitcodeReaderValueList &ValueList,
2480 bool IsImporting,
2481 MetadataLoaderCallbacks Callbacks)
2482 : Pimpl(std::make_unique<MetadataLoaderImpl>(
2483 Stream, TheModule, ValueList, std::move(Callbacks), IsImporting)) {}
2484
2485Error MetadataLoader::parseMetadata(bool ModuleLevel) {
2486 return Pimpl->parseMetadata(ModuleLevel);
2487}
2488
2489bool MetadataLoader::hasFwdRefs() const { return Pimpl->hasFwdRefs(); }
2490
2491/// Return the given metadata, creating a replaceable forward reference if
2492/// necessary.
2494 return Pimpl->getMetadataFwdRefOrLoad(Idx);
2495}
2496
2498 return Pimpl->lookupSubprogramForFunction(F);
2499}
2500
2502 Function &F, ArrayRef<Instruction *> InstructionList) {
2503 return Pimpl->parseMetadataAttachment(F, InstructionList);
2504}
2505
2507 return Pimpl->parseMetadataKinds();
2508}
2509
2510void MetadataLoader::setStripTBAA(bool StripTBAA) {
2511 return Pimpl->setStripTBAA(StripTBAA);
2512}
2513
2514bool MetadataLoader::isStrippingTBAA() { return Pimpl->isStrippingTBAA(); }
2515
2516unsigned MetadataLoader::size() const { return Pimpl->size(); }
2517void MetadataLoader::shrinkTo(unsigned N) { return Pimpl->shrinkTo(N); }
2518
2520 return Pimpl->upgradeDebugIntrinsics(F);
2521}
This file implements a class to represent arbitrary precision integral constant values and operations...
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#define LLVM_UNLIKELY(EXPR)
Definition: Compiler.h:241
#define LLVM_LIKELY(EXPR)
Definition: Compiler.h:240
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static void clear(coro::Shape &Shape)
Definition: Coroutines.cpp:145
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
This file defines the DenseMap class.
This file defines the DenseSet and SmallDenseSet classes.
This file contains constants used for implementing Dwarf debug support.
std::string Name
uint64_t Size
bool End
Definition: ELF_riscv.cpp:480
static bool lookup(const GsymReader &GR, DataExtractor &Data, uint64_t &Offset, uint64_t BaseAddr, uint64_t Addr, SourceLocations &SrcLocs, llvm::Error &Err)
A Lookup helper functions.
Definition: InlineInfo.cpp:109
#define GET_OR_DISTINCT(CLASS, ARGS)
Definition: LLParser.cpp:4937
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
static cl::opt< bool > DisableLazyLoading("disable-ondemand-mds-loading", cl::init(false), cl::Hidden, cl::desc("Force disable the lazy-loading on-demand of metadata when " "loading bitcode for importing."))
static Value * getValueFwdRef(BitcodeReaderValueList &ValueList, unsigned Idx, Type *Ty, unsigned TyID)
static cl::opt< bool > ImportFullTypeDefinitions("import-full-type-definitions", cl::init(false), cl::Hidden, cl::desc("Import full type definitions for ThinLTO."))
Flag whether we need to import full type definitions for ThinLTO.
This file contains the declarations for metadata subclasses.
Module.h This file contains the declarations for the Module class.
LLVMContext & Context
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file implements a set that has insertion order iteration characteristics.
This file defines the SmallString class.
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
Definition: Statistic.h:167
#define error(X)
std::pair< llvm::MachO::Target, std::string > UUID
Value * RHS
Metadata * getMetadataFwdRefOrLoad(unsigned ID)
Error parseMetadataAttachment(Function &F, ArrayRef< Instruction * > InstructionList)
Parse metadata attachments.
MetadataLoaderImpl(BitstreamCursor &Stream, Module &TheModule, BitcodeReaderValueList &ValueList, MetadataLoaderCallbacks Callbacks, bool IsImporting)
Error parseMetadataKinds()
Parse the metadata kinds out of the METADATA_KIND_BLOCK.
Error parseMetadata(bool ModuleLevel)
Parse a METADATA_BLOCK.
DISubprogram * lookupSubprogramForFunction(Function *F)
Class for arbitrary precision integers.
Definition: APInt.h:76
Annotations lets you mark points and ranges inside source code, for tests:
Definition: Annotations.h:53
This class represents an incoming formal argument to a Function.
Definition: Argument.h:28
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
Value * getValueFwdRef(unsigned Idx, Type *Ty, unsigned TyID, BasicBlock *ConstExprInsertBB)
Definition: ValueList.cpp:54
unsigned size() const
Definition: ValueList.h:48
This represents a position within a bitcode file, implemented on top of a SimpleBitstreamCursor.
Error JumpToBit(uint64_t BitNo)
Reset the stream to the specified bit number.
uint64_t GetCurrentBitNo() const
Return the bit # of the bit we are reading.
Expected< BitstreamEntry > advanceSkippingSubblocks(unsigned Flags=0)
This is a convenience function for clients that don't expect any subblocks.
@ AF_DontPopBlockAtEnd
If this flag is used, the advance() method does not automatically pop the block scope when the end of...
Expected< unsigned > readRecord(unsigned AbbrevID, SmallVectorImpl< uint64_t > &Vals, StringRef *Blob=nullptr)
Expected< unsigned > skipRecord(unsigned AbbrevID)
Read the current record and discard it, returning the code for the record.
Expected< unsigned > ReadCode()
static DIArgList * get(LLVMContext &Context, ArrayRef< ValueAsMetadata * > Args)
static DIAssignID * getDistinct(LLVMContext &Context)
Basic type, like 'int' or 'float'.
Debug common block.
static DICompositeType * buildODRType(LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name, Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator, Metadata *DataLocation, Metadata *Associated, Metadata *Allocated, Metadata *Rank, Metadata *Annotations)
Build a DICompositeType with the given ODR identifier.
MDString * getRawIdentifier() const
Enumeration value.
DWARF expression.
ChecksumKind
Which algorithm (e.g.
A pair of DIGlobalVariable and DIExpression.
An imported module (C++ using directive or similar).
Debug lexical block.
A scope for locals.
Debug location.
Represents a module in the programming language, for example, a Clang module, or a Fortran module.
Debug lexical block.
DIFlags
Debug info flags.
DIScope * getScope() const
String type, Fortran CHARACTER(n)
Subprogram description.
static DISPFlags toSPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized, unsigned Virtuality=SPFlagNonvirtual, bool IsMainSubprogram=false)
DISPFlags
Debug info subprogram flags.
Array subrange.
Type array for a subprogram.
bool isForwardDecl() const
This class represents an Operation in the Expression.
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:202
Implements a dense probed hash-table based set.
Definition: DenseSet.h:271
Placeholder metadata for operands of distinct MDNodes.
Definition: Metadata.h:1684
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:334
Tagged union holding either a T or a Error.
Definition: Error.h:474
Error takeError()
Take ownership of the stored error.
Definition: Error.h:601
reference get()
Returns a reference to the stored T value.
Definition: Error.h:571
Generic tagged DWARF-like metadata node.
void addMetadata(unsigned KindID, MDNode &MD)
Add a metadata attachment.
Definition: Metadata.cpp:1519
void addDebugInfo(DIGlobalVariableExpression *GV)
Attach a DIGlobalVariableExpression.
Definition: Metadata.cpp:1841
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
Definition: Metadata.cpp:1633
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
static LocalAsMetadata * get(Value *Local)
Definition: Metadata.h:554
Metadata node.
Definition: Metadata.h:1067
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1549
bool isTemporary() const
Definition: Metadata.h:1251
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1553
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1541
A single uniqued string.
Definition: Metadata.h:720
static MDString * get(LLVMContext &Context, StringRef Str)
Definition: Metadata.cpp:597
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1498
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Return a temporary node.
Definition: Metadata.h:1518
Helper class that handles loading Metadatas and keeping them available.
MetadataLoader(BitstreamCursor &Stream, Module &TheModule, BitcodeReaderValueList &ValueList, bool IsImporting, MetadataLoaderCallbacks Callbacks)
Metadata * getMetadataFwdRefOrLoad(unsigned Idx)
Return the given metadata, creating a replaceable forward reference if necessary.
void upgradeDebugIntrinsics(Function &F)
Perform bitcode upgrades on llvm.dbg.* calls.
void shrinkTo(unsigned N)
Error parseMetadataKinds()
Parse a METADATA_KIND block for the current module.
void setStripTBAA(bool StripTBAA=true)
Set the mode to strip TBAA metadata on load.
bool isStrippingTBAA()
Return true if the Loader is stripping TBAA metadata.
Error parseMetadataAttachment(Function &F, ArrayRef< Instruction * > InstructionList)
Parse a METADATA_ATTACHMENT block for a function.
DISubprogram * lookupSubprogramForFunction(Function *F)
Return the DISubprogram metadata for a Function if any, null otherwise.
unsigned size() const
MetadataLoader & operator=(MetadataLoader &&)
Root of the metadata hierarchy.
Definition: Metadata.h:62
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
NamedMDNode * getNamedMetadata(const Twine &Name) const
Return the first NamedMDNode in the module with the specified name.
Definition: Module.cpp:239
iterator_range< global_iterator > globals()
Definition: Module.h:688
NamedMDNode * getOrInsertNamedMetadata(StringRef Name)
Return the named MDNode in the module with the specified name.
Definition: Module.cpp:248
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:307
iterator end() const
Definition: ArrayRef.h:357
iterator begin() const
Definition: ArrayRef.h:356
MutableArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array.
Definition: ArrayRef.h:376
A tuple of MDNodes.
Definition: Metadata.h:1729
void addOperand(MDNode *M)
Definition: Metadata.cpp:1385
A vector that has set insertion semantics.
Definition: SetVector.h:57
bool empty() const
Determine if the SetVector is empty or not.
Definition: SetVector.h:93
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:162
bool contains(const key_type &key) const
Check if the SetVector contains the given key.
Definition: SetVector.h:254
This represents a position within a bitstream.
Implements a dense probed hash-table based set with some number of buckets stored inline.
Definition: DenseSet.h:290
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
bool empty() const
Definition: SmallVector.h:94
size_t size() const
Definition: SmallVector.h:91
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:950
void reserve(size_type N)
Definition: SmallVector.h:676
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:696
void resize(size_type N)
Definition: SmallVector.h:651
void push_back(const T &Elt)
Definition: SmallVector.h:426
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:257
StringRef drop_front(size_t N=1) const
Return a StringRef equal to 'this' but with the first N elements dropped.
Definition: StringRef.h:605
StringRef slice(size_t Start, size_t End) const
Return a reference to the substring from [Start, End).
Definition: StringRef.h:680
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
bool contains(StringRef Other) const
Return true if the given string is a substring of *this, and false otherwise.
Definition: StringRef.h:420
Tracking metadata reference.
Definition: TrackingMDRef.h:25
Metadata * get() const
Definition: TrackingMDRef.h:57
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
TypeID
Definitions of all of the base types for the Type system.
Definition: Type.h:54
bool isVoidTy() const
Return true if this is 'void'.
Definition: Type.h:140
bool isMetadataTy() const
Return true if this is 'metadata'.
Definition: Type.h:222
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1724
static ValueAsMetadata * get(Value *V)
Definition: Metadata.cpp:492
LLVM Value Representation.
Definition: Value.h:74
std::pair< iterator, bool > insert(const ValueT &V)
Definition: DenseSet.h:206
bool contains(const_arg_type_t< ValueT > V) const
Check if the set contains the given element.
Definition: DenseSet.h:185
An efficient, type-erasing, non-owning reference to a callable.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
const uint64_t Version
Definition: InstrProf.h:1042
@ METADATA_NAMESPACE
Definition: LLVMBitCodes.h:348
@ METADATA_COMMON_BLOCK
Definition: LLVMBitCodes.h:368
@ METADATA_STRING_TYPE
Definition: LLVMBitCodes.h:365
@ METADATA_MACRO_FILE
Definition: LLVMBitCodes.h:358
@ METADATA_TEMPLATE_VALUE
Definition: LLVMBitCodes.h:350
@ METADATA_LEXICAL_BLOCK_FILE
Definition: LLVMBitCodes.h:347
@ METADATA_STRING_OLD
Definition: LLVMBitCodes.h:325
@ METADATA_INDEX_OFFSET
Definition: LLVMBitCodes.h:362
@ METADATA_LEXICAL_BLOCK
Definition: LLVMBitCodes.h:346
@ METADATA_SUBPROGRAM
Definition: LLVMBitCodes.h:345
@ METADATA_SUBROUTINE_TYPE
Definition: LLVMBitCodes.h:343
@ METADATA_GLOBAL_DECL_ATTACHMENT
Definition: LLVMBitCodes.h:360
@ METADATA_LOCAL_VAR
Definition: LLVMBitCodes.h:352
@ METADATA_GLOBAL_VAR
Definition: LLVMBitCodes.h:351
@ METADATA_EXPRESSION
Definition: LLVMBitCodes.h:353
@ METADATA_ATTACHMENT
Definition: LLVMBitCodes.h:335
@ METADATA_OBJC_PROPERTY
Definition: LLVMBitCodes.h:354
@ METADATA_NAMED_NODE
Definition: LLVMBitCodes.h:334
@ METADATA_IMPORTED_ENTITY
Definition: LLVMBitCodes.h:355
@ METADATA_GENERIC_SUBRANGE
Definition: LLVMBitCodes.h:369
@ METADATA_ASSIGN_ID
Definition: LLVMBitCodes.h:371
@ METADATA_COMPILE_UNIT
Definition: LLVMBitCodes.h:344
@ METADATA_COMPOSITE_TYPE
Definition: LLVMBitCodes.h:342
@ METADATA_OLD_FN_NODE
Definition: LLVMBitCodes.h:333
@ METADATA_ENUMERATOR
Definition: LLVMBitCodes.h:338
@ METADATA_DERIVED_TYPE
Definition: LLVMBitCodes.h:341
@ METADATA_TEMPLATE_TYPE
Definition: LLVMBitCodes.h:349
@ METADATA_GLOBAL_VAR_EXPR
Definition: LLVMBitCodes.h:361
@ METADATA_BASIC_TYPE
Definition: LLVMBitCodes.h:339
@ METADATA_DISTINCT_NODE
Definition: LLVMBitCodes.h:329
@ METADATA_GENERIC_DEBUG
Definition: LLVMBitCodes.h:336
@ METADATA_KIND_BLOCK_ID
Definition: LLVMBitCodes.h:57
@ METADATA_ATTACHMENT_ID
Definition: LLVMBitCodes.h:46
@ METADATA_BLOCK_ID
Definition: LLVMBitCodes.h:45
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:450
std::optional< const char * > toString(const std::optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract a string value from it.
@ DW_OP_LLVM_fragment
Only used in LLVM metadata.
Definition: Dwarf.h:141
NodeAddr< CodeNode * > Code
Definition: RDFGraph.h:388
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
@ Offset
Definition: DWP.cpp:456
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
Definition: STLExtras.h:1689
std::error_code make_error_code(BitcodeError E)
MDNode * upgradeInstructionLoopAttachment(MDNode &N)
Upgrade the loop attachment metadata node.
bool mayBeOldLoopAttachmentTag(StringRef Name)
Check whether a string looks like an old loop attachment tag.
Definition: AutoUpgrade.h:92
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:156
@ Ref
The access may reference the value stored in memory.
constexpr unsigned BitWidth
Definition: BitmaskEnum.h:191
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1858
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
Definition: Casting.h:565
APInt readWideAPInt(ArrayRef< uint64_t > Vals, unsigned TypeBits)
MDNode * UpgradeTBAANode(MDNode &TBAANode)
If the given TBAA tag uses the scalar TBAA format, create a new node corresponding to the upgrade to ...
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1041
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
#define N
When advancing through a bitstream cursor, each advance can discover a few different kinds of entries...