LLVM 22.0.0git
DebugInfoMetadata.cpp
Go to the documentation of this file.
1//===- DebugInfoMetadata.cpp - Implement debug info metadata --------------===//
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// This file implements the debug info Metadata classes.
10//
11//===----------------------------------------------------------------------===//
12
14#include "LLVMContextImpl.h"
15#include "MetadataImpl.h"
16#include "llvm/ADT/SetVector.h"
20#include "llvm/IR/Function.h"
22#include "llvm/IR/Type.h"
23#include "llvm/IR/Value.h"
26
27#include <numeric>
28#include <optional>
29
30using namespace llvm;
31
32namespace llvm {
33// Use FS-AFDO discriminator.
35 "enable-fs-discriminator", cl::Hidden,
36 cl::desc("Enable adding flow sensitive discriminators"));
37
38// When true, preserves line and column number by picking one of the merged
39// location info in a deterministic manner to assist sample based PGO.
41 "pick-merged-source-locations", cl::init(false), cl::Hidden,
42 cl::desc("Preserve line and column number when merging locations."));
43} // namespace llvm
44
46 return (getTag() == dwarf::DW_TAG_LLVM_ptrauth_type ? 0 : SubclassData32);
47}
48
49const DIExpression::FragmentInfo DebugVariable::DefaultFragment = {
50 std::numeric_limits<uint64_t>::max(), std::numeric_limits<uint64_t>::min()};
51
53 : Variable(DVR->getVariable()),
54 Fragment(DVR->getExpression()->getFragmentInfo()),
55 InlinedAt(DVR->getDebugLoc().getInlinedAt()) {}
56
60
61DILocation::DILocation(LLVMContext &C, StorageType Storage, unsigned Line,
62 unsigned Column, uint64_t AtomGroup, uint8_t AtomRank,
63 ArrayRef<Metadata *> MDs, bool ImplicitCode)
64 : MDNode(C, DILocationKind, Storage, MDs), AtomGroup(AtomGroup),
65 AtomRank(AtomRank) {
66 assert(AtomRank <= 7 && "AtomRank number should fit in 3 bits");
67 if (AtomGroup)
68 C.updateDILocationAtomGroupWaterline(AtomGroup + 1);
69
70 assert((MDs.size() == 1 || MDs.size() == 2) &&
71 "Expected a scope and optional inlined-at");
72 // Set line and column.
73 assert(Column < (1u << 16) && "Expected 16-bit column");
74
75 SubclassData32 = Line;
76 SubclassData16 = Column;
77
78 setImplicitCode(ImplicitCode);
79}
80
81static void adjustColumn(unsigned &Column) {
82 // Set to unknown on overflow. We only have 16 bits to play with here.
83 if (Column >= (1u << 16))
84 Column = 0;
85}
86
87DILocation *DILocation::getImpl(LLVMContext &Context, unsigned Line,
88 unsigned Column, Metadata *Scope,
89 Metadata *InlinedAt, bool ImplicitCode,
90 uint64_t AtomGroup, uint8_t AtomRank,
91 StorageType Storage, bool ShouldCreate) {
92 // Fixup column.
94
95 if (Storage == Uniqued) {
96 if (auto *N = getUniqued(Context.pImpl->DILocations,
97 DILocationInfo::KeyTy(Line, Column, Scope,
99 AtomGroup, AtomRank)))
100 return N;
101 if (!ShouldCreate)
102 return nullptr;
103 } else {
104 assert(ShouldCreate && "Expected non-uniqued nodes to always be created");
105 }
106
108 Ops.push_back(Scope);
109 if (InlinedAt)
110 Ops.push_back(InlinedAt);
111 return storeImpl(new (Ops.size(), Storage)
112 DILocation(Context, Storage, Line, Column, AtomGroup,
113 AtomRank, Ops, ImplicitCode),
114 Storage, Context.pImpl->DILocations);
115}
116
118 if (Locs.empty())
119 return nullptr;
120 if (Locs.size() == 1)
121 return Locs[0];
122 auto *Merged = Locs[0];
123 for (DILocation *L : llvm::drop_begin(Locs)) {
124 Merged = getMergedLocation(Merged, L);
125 if (Merged == nullptr)
126 break;
127 }
128 return Merged;
129}
130
132 DIScope *NewParent) {
133 TempMDNode ClonedScope = LBB->clone();
134 cast<DILexicalBlockBase>(*ClonedScope).replaceScope(NewParent);
136 MDNode::replaceWithUniqued(std::move(ClonedScope)));
137}
138
139using LineColumn = std::pair<unsigned /* Line */, unsigned /* Column */>;
140
141/// Returns the location of DILocalScope, if present, or a default value.
143 assert(isa<DILocalScope>(S) && "Expected DILocalScope.");
144
146 return Default;
147 if (auto *LB = dyn_cast<DILexicalBlock>(S))
148 return {LB->getLine(), LB->getColumn()};
149 if (auto *SP = dyn_cast<DISubprogram>(S))
150 return {SP->getLine(), 0u};
151
152 llvm_unreachable("Unhandled type of DILocalScope.");
153}
154
155// Returns the nearest matching scope inside a subprogram.
156template <typename MatcherT>
157static std::pair<DIScope *, LineColumn>
159 MatcherT Matcher;
160
161 DIScope *S1 = L1->getScope();
162 DIScope *S2 = L2->getScope();
163
164 LineColumn Loc1(L1->getLine(), L1->getColumn());
165 for (; S1; S1 = S1->getScope()) {
166 Loc1 = getLocalScopeLocationOr(S1, Loc1);
167 Matcher.insert(S1, Loc1);
169 break;
170 }
171
172 LineColumn Loc2(L2->getLine(), L2->getColumn());
173 for (; S2; S2 = S2->getScope()) {
174 Loc2 = getLocalScopeLocationOr(S2, Loc2);
175
176 if (DIScope *S = Matcher.match(S2, Loc2))
177 return std::make_pair(S, Loc2);
178
179 if (isa<DISubprogram>(S2))
180 break;
181 }
182 return std::make_pair(nullptr, LineColumn(L2->getLine(), L2->getColumn()));
183}
184
185// Matches equal scopes.
188
189 void insert(DIScope *S, LineColumn Loc) { Scopes.insert(S); }
190
192 return Scopes.contains(S) ? S : nullptr;
193 }
194};
195
196// Matches scopes with the same location.
199 8>
201
203 Scopes[{S->getFile(), Loc}].insert(S);
204 }
205
207 auto ScopesAtLoc = Scopes.find({S->getFile(), Loc});
208 // No scope found with the given location.
209 if (ScopesAtLoc == Scopes.end())
210 return nullptr;
211
212 // Prefer S over other scopes with the same location.
213 if (ScopesAtLoc->second.contains(S))
214 return S;
215
216 if (!ScopesAtLoc->second.empty())
217 return *ScopesAtLoc->second.begin();
218
219 llvm_unreachable("Scopes must not have empty entries.");
220 }
221};
222
223DILocation *DILocation::getMergedLocation(DILocation *LocA, DILocation *LocB) {
224 if (LocA == LocB)
225 return LocA;
226
227 // For some use cases (SamplePGO), it is important to retain distinct source
228 // locations. When this flag is set, we choose arbitrarily between A and B,
229 // rather than computing a merged location using line 0, which is typically
230 // not useful for PGO. If one of them is null, then try to return one which is
231 // valid.
233 if (!LocA || !LocB)
234 return LocA ? LocA : LocB;
235
236 auto A = std::make_tuple(LocA->getLine(), LocA->getColumn(),
237 LocA->getDiscriminator(), LocA->getFilename(),
238 LocA->getDirectory());
239 auto B = std::make_tuple(LocB->getLine(), LocB->getColumn(),
240 LocB->getDiscriminator(), LocB->getFilename(),
241 LocB->getDirectory());
242 return A < B ? LocA : LocB;
243 }
244
245 if (!LocA || !LocB)
246 return nullptr;
247
248 LLVMContext &C = LocA->getContext();
249
250 using LocVec = SmallVector<const DILocation *>;
251 LocVec ALocs;
252 LocVec BLocs;
254 4>
255 ALookup;
256
257 // Walk through LocA and its inlined-at locations, populate them in ALocs and
258 // save the index for the subprogram and inlined-at pair, which we use to find
259 // a matching starting location in LocB's chain.
260 for (auto [L, I] = std::make_pair(LocA, 0U); L; L = L->getInlinedAt(), I++) {
261 ALocs.push_back(L);
262 auto Res = ALookup.try_emplace(
263 {L->getScope()->getSubprogram(), L->getInlinedAt()}, I);
264 assert(Res.second && "Multiple <SP, InlinedAt> pairs in a location chain?");
265 (void)Res;
266 }
267
268 LocVec::reverse_iterator ARIt = ALocs.rend();
269 LocVec::reverse_iterator BRIt = BLocs.rend();
270
271 // Populate BLocs and look for a matching starting location, the first
272 // location with the same subprogram and inlined-at location as in LocA's
273 // chain. Since the two locations have the same inlined-at location we do
274 // not need to look at those parts of the chains.
275 for (auto [L, I] = std::make_pair(LocB, 0U); L; L = L->getInlinedAt(), I++) {
276 BLocs.push_back(L);
277
278 if (ARIt != ALocs.rend())
279 // We have already found a matching starting location.
280 continue;
281
282 auto IT = ALookup.find({L->getScope()->getSubprogram(), L->getInlinedAt()});
283 if (IT == ALookup.end())
284 continue;
285
286 // The + 1 is to account for the &*rev_it = &(it - 1) relationship.
287 ARIt = LocVec::reverse_iterator(ALocs.begin() + IT->second + 1);
288 BRIt = LocVec::reverse_iterator(BLocs.begin() + I + 1);
289
290 // If we have found a matching starting location we do not need to add more
291 // locations to BLocs, since we will only look at location pairs preceding
292 // the matching starting location, and adding more elements to BLocs could
293 // invalidate the iterator that we initialized here.
294 break;
295 }
296
297 // Merge the two locations if possible, using the supplied
298 // inlined-at location for the created location.
299 auto *LocAIA = LocA->getInlinedAt();
300 auto *LocBIA = LocB->getInlinedAt();
301 auto MergeLocPair = [&C, LocAIA,
302 LocBIA](const DILocation *L1, const DILocation *L2,
303 DILocation *InlinedAt) -> DILocation * {
304 if (L1 == L2)
305 return DILocation::get(C, L1->getLine(), L1->getColumn(), L1->getScope(),
306 InlinedAt, L1->isImplicitCode(),
307 L1->getAtomGroup(), L1->getAtomRank());
308
309 // If the locations originate from different subprograms we can't produce
310 // a common location.
311 if (L1->getScope()->getSubprogram() != L2->getScope()->getSubprogram())
312 return nullptr;
313
314 // Find nearest common scope inside subprogram.
316 assert(Scope && "No common scope in the same subprogram?");
317
318 // Try using the nearest scope with common location if files are different.
319 if (Scope->getFile() != L1->getFile() || L1->getFile() != L2->getFile()) {
320 auto [CommonLocScope, CommonLoc] =
322
323 // If CommonLocScope is a DILexicalBlockBase, clone it and locate
324 // a new scope inside the nearest common scope to preserve
325 // lexical blocks structure.
326 if (auto *LBB = dyn_cast<DILexicalBlockBase>(CommonLocScope);
327 LBB && LBB != Scope)
328 CommonLocScope = cloneAndReplaceParentScope(LBB, Scope);
329
330 Scope = CommonLocScope;
331
332 // If files are still different, assume that L1 and L2 were "included"
333 // from CommonLoc. Use it as merged location.
334 if (Scope->getFile() != L1->getFile() || L1->getFile() != L2->getFile())
335 return DILocation::get(C, CommonLoc.first, CommonLoc.second,
336 CommonLocScope, InlinedAt);
337 }
338
339 bool SameLine = L1->getLine() == L2->getLine();
340 bool SameCol = L1->getColumn() == L2->getColumn();
341 unsigned Line = SameLine ? L1->getLine() : 0;
342 unsigned Col = SameLine && SameCol ? L1->getColumn() : 0;
343 bool IsImplicitCode = L1->isImplicitCode() && L2->isImplicitCode();
344
345 // Discard source location atom if the line becomes 0. And there's nothing
346 // further to do if neither location has an atom number.
347 if (!SameLine || !(L1->getAtomGroup() || L2->getAtomGroup()))
348 return DILocation::get(C, Line, Col, Scope, InlinedAt, IsImplicitCode,
349 /*AtomGroup*/ 0, /*AtomRank*/ 0);
350
351 uint64_t Group = 0;
352 uint64_t Rank = 0;
353 // If we're preserving the same matching inlined-at field we can
354 // preserve the atom.
355 if (LocBIA == LocAIA && InlinedAt == LocBIA) {
356 // Deterministically keep the lowest non-zero ranking atom group
357 // number.
358 // FIXME: It would be nice if we could track that an instruction
359 // belongs to two source atoms.
360 bool UseL1Atom = [L1, L2]() {
361 if (L1->getAtomRank() == L2->getAtomRank()) {
362 // Arbitrarily choose the lowest non-zero group number.
363 if (!L1->getAtomGroup() || !L2->getAtomGroup())
364 return !L2->getAtomGroup();
365 return L1->getAtomGroup() < L2->getAtomGroup();
366 }
367 // Choose the lowest non-zero rank.
368 if (!L1->getAtomRank() || !L2->getAtomRank())
369 return !L2->getAtomRank();
370 return L1->getAtomRank() < L2->getAtomRank();
371 }();
372 Group = UseL1Atom ? L1->getAtomGroup() : L2->getAtomGroup();
373 Rank = UseL1Atom ? L1->getAtomRank() : L2->getAtomRank();
374 } else {
375 // If either instruction is part of a source atom, reassign it a new
376 // atom group. This essentially regresses to non-key-instructions
377 // behaviour (now that it's the only instruction in its group it'll
378 // probably get is_stmt applied).
379 Group = C.incNextDILocationAtomGroup();
380 Rank = 1;
381 }
382 return DILocation::get(C, Line, Col, Scope, InlinedAt, IsImplicitCode,
383 Group, Rank);
384 };
385
386 DILocation *Result = ARIt != ALocs.rend() ? (*ARIt)->getInlinedAt() : nullptr;
387
388 // If we have found a common starting location, walk up the inlined-at chains
389 // and try to produce common locations.
390 for (; ARIt != ALocs.rend() && BRIt != BLocs.rend(); ++ARIt, ++BRIt) {
391 DILocation *Tmp = MergeLocPair(*ARIt, *BRIt, Result);
392
393 if (!Tmp)
394 // We have walked up to a point in the chains where the two locations
395 // are irreconsilable. At this point Result contains the nearest common
396 // location in the inlined-at chains of LocA and LocB, so we break here.
397 break;
398
399 Result = Tmp;
400 }
401
402 if (Result)
403 return Result;
404
405 // We ended up with LocA and LocB as irreconsilable locations. Produce a
406 // location at 0:0 with one of the locations' scope. The function has
407 // historically picked A's scope, and a nullptr inlined-at location, so that
408 // behavior is mimicked here but I am not sure if this is always the correct
409 // way to handle this.
410 // Key Instructions: it's fine to drop atom group and rank here, as line 0
411 // is a nonsensical is_stmt location.
412 return DILocation::get(C, 0, 0, LocA->getScope(), nullptr, false,
413 /*AtomGroup*/ 0, /*AtomRank*/ 0);
414}
415
416std::optional<unsigned>
417DILocation::encodeDiscriminator(unsigned BD, unsigned DF, unsigned CI) {
418 std::array<unsigned, 3> Components = {BD, DF, CI};
419 uint64_t RemainingWork = 0U;
420 // We use RemainingWork to figure out if we have no remaining components to
421 // encode. For example: if BD != 0 but DF == 0 && CI == 0, we don't need to
422 // encode anything for the latter 2.
423 // Since any of the input components is at most 32 bits, their sum will be
424 // less than 34 bits, and thus RemainingWork won't overflow.
425 RemainingWork =
426 std::accumulate(Components.begin(), Components.end(), RemainingWork);
427
428 int I = 0;
429 unsigned Ret = 0;
430 unsigned NextBitInsertionIndex = 0;
431 while (RemainingWork > 0) {
432 unsigned C = Components[I++];
433 RemainingWork -= C;
434 unsigned EC = encodeComponent(C);
435 Ret |= (EC << NextBitInsertionIndex);
436 NextBitInsertionIndex += encodingBits(C);
437 }
438
439 // Encoding may be unsuccessful because of overflow. We determine success by
440 // checking equivalence of components before & after encoding. Alternatively,
441 // we could determine Success during encoding, but the current alternative is
442 // simpler.
443 unsigned TBD, TDF, TCI = 0;
444 decodeDiscriminator(Ret, TBD, TDF, TCI);
445 if (TBD == BD && TDF == DF && TCI == CI)
446 return Ret;
447 return std::nullopt;
448}
449
458
460 return StringSwitch<DIFlags>(Flag)
461#define HANDLE_DI_FLAG(ID, NAME) .Case("DIFlag" #NAME, Flag##NAME)
462#include "llvm/IR/DebugInfoFlags.def"
463 .Default(DINode::FlagZero);
464}
465
467 switch (Flag) {
468#define HANDLE_DI_FLAG(ID, NAME) \
469 case Flag##NAME: \
470 return "DIFlag" #NAME;
471#include "llvm/IR/DebugInfoFlags.def"
472 }
473 return "";
474}
475
477 SmallVectorImpl<DIFlags> &SplitFlags) {
478 // Flags that are packed together need to be specially handled, so
479 // that, for example, we emit "DIFlagPublic" and not
480 // "DIFlagPrivate | DIFlagProtected".
481 if (DIFlags A = Flags & FlagAccessibility) {
482 if (A == FlagPrivate)
483 SplitFlags.push_back(FlagPrivate);
484 else if (A == FlagProtected)
485 SplitFlags.push_back(FlagProtected);
486 else
487 SplitFlags.push_back(FlagPublic);
488 Flags &= ~A;
489 }
490 if (DIFlags R = Flags & FlagPtrToMemberRep) {
491 if (R == FlagSingleInheritance)
492 SplitFlags.push_back(FlagSingleInheritance);
493 else if (R == FlagMultipleInheritance)
494 SplitFlags.push_back(FlagMultipleInheritance);
495 else
496 SplitFlags.push_back(FlagVirtualInheritance);
497 Flags &= ~R;
498 }
499 if ((Flags & FlagIndirectVirtualBase) == FlagIndirectVirtualBase) {
500 Flags &= ~FlagIndirectVirtualBase;
501 SplitFlags.push_back(FlagIndirectVirtualBase);
502 }
503
504#define HANDLE_DI_FLAG(ID, NAME) \
505 if (DIFlags Bit = Flags & Flag##NAME) { \
506 SplitFlags.push_back(Bit); \
507 Flags &= ~Bit; \
508 }
509#include "llvm/IR/DebugInfoFlags.def"
510 return Flags;
511}
512
514 if (auto *T = dyn_cast<DIType>(this))
515 return T->getScope();
516
517 if (auto *SP = dyn_cast<DISubprogram>(this))
518 return SP->getScope();
519
520 if (auto *LB = dyn_cast<DILexicalBlockBase>(this))
521 return LB->getScope();
522
523 if (auto *NS = dyn_cast<DINamespace>(this))
524 return NS->getScope();
525
526 if (auto *CB = dyn_cast<DICommonBlock>(this))
527 return CB->getScope();
528
529 if (auto *M = dyn_cast<DIModule>(this))
530 return M->getScope();
531
532 assert((isa<DIFile>(this) || isa<DICompileUnit>(this)) &&
533 "Unhandled type of scope.");
534 return nullptr;
535}
536
538 if (auto *T = dyn_cast<DIType>(this))
539 return T->getName();
540 if (auto *SP = dyn_cast<DISubprogram>(this))
541 return SP->getName();
542 if (auto *NS = dyn_cast<DINamespace>(this))
543 return NS->getName();
544 if (auto *CB = dyn_cast<DICommonBlock>(this))
545 return CB->getName();
546 if (auto *M = dyn_cast<DIModule>(this))
547 return M->getName();
549 isa<DICompileUnit>(this)) &&
550 "Unhandled type of scope.");
551 return "";
552}
553
554#ifndef NDEBUG
555static bool isCanonical(const MDString *S) {
556 return !S || !S->getString().empty();
557}
558#endif
559
561GenericDINode *GenericDINode::getImpl(LLVMContext &Context, unsigned Tag,
562 MDString *Header,
563 ArrayRef<Metadata *> DwarfOps,
564 StorageType Storage, bool ShouldCreate) {
565 unsigned Hash = 0;
566 if (Storage == Uniqued) {
567 GenericDINodeInfo::KeyTy Key(Tag, Header, DwarfOps);
568 if (auto *N = getUniqued(Context.pImpl->GenericDINodes, Key))
569 return N;
570 if (!ShouldCreate)
571 return nullptr;
572 Hash = Key.getHash();
573 } else {
574 assert(ShouldCreate && "Expected non-uniqued nodes to always be created");
575 }
576
577 // Use a nullptr for empty headers.
578 assert(isCanonical(Header) && "Expected canonical MDString");
579 Metadata *PreOps[] = {Header};
580 return storeImpl(new (DwarfOps.size() + 1, Storage) GenericDINode(
581 Context, Storage, Hash, Tag, PreOps, DwarfOps),
582 Storage, Context.pImpl->GenericDINodes);
583}
584
585void GenericDINode::recalculateHash() {
586 setHash(GenericDINodeInfo::KeyTy::calculateHash(this));
587}
588
589#define UNWRAP_ARGS_IMPL(...) __VA_ARGS__
590#define UNWRAP_ARGS(ARGS) UNWRAP_ARGS_IMPL ARGS
591#define DEFINE_GETIMPL_LOOKUP(CLASS, ARGS) \
592 do { \
593 if (Storage == Uniqued) { \
594 if (auto *N = getUniqued(Context.pImpl->CLASS##s, \
595 CLASS##Info::KeyTy(UNWRAP_ARGS(ARGS)))) \
596 return N; \
597 if (!ShouldCreate) \
598 return nullptr; \
599 } else { \
600 assert(ShouldCreate && \
601 "Expected non-uniqued nodes to always be created"); \
602 } \
603 } while (false)
604#define DEFINE_GETIMPL_STORE(CLASS, ARGS, OPS) \
605 return storeImpl(new (std::size(OPS), Storage) \
606 CLASS(Context, Storage, UNWRAP_ARGS(ARGS), OPS), \
607 Storage, Context.pImpl->CLASS##s)
608#define DEFINE_GETIMPL_STORE_NO_OPS(CLASS, ARGS) \
609 return storeImpl(new (0u, Storage) \
610 CLASS(Context, Storage, UNWRAP_ARGS(ARGS)), \
611 Storage, Context.pImpl->CLASS##s)
612#define DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(CLASS, OPS) \
613 return storeImpl(new (std::size(OPS), Storage) CLASS(Context, Storage, OPS), \
614 Storage, Context.pImpl->CLASS##s)
615#define DEFINE_GETIMPL_STORE_N(CLASS, ARGS, OPS, NUM_OPS) \
616 return storeImpl(new (NUM_OPS, Storage) \
617 CLASS(Context, Storage, UNWRAP_ARGS(ARGS), OPS), \
618 Storage, Context.pImpl->CLASS##s)
619
620DISubrange::DISubrange(LLVMContext &C, StorageType Storage,
622 : DINode(C, DISubrangeKind, Storage, dwarf::DW_TAG_subrange_type, Ops) {}
623DISubrange *DISubrange::getImpl(LLVMContext &Context, int64_t Count, int64_t Lo,
624 StorageType Storage, bool ShouldCreate) {
627 auto *LB = ConstantAsMetadata::get(
629 return getImpl(Context, CountNode, LB, nullptr, nullptr, Storage,
630 ShouldCreate);
631}
632
633DISubrange *DISubrange::getImpl(LLVMContext &Context, Metadata *CountNode,
634 int64_t Lo, StorageType Storage,
635 bool ShouldCreate) {
636 auto *LB = ConstantAsMetadata::get(
638 return getImpl(Context, CountNode, LB, nullptr, nullptr, Storage,
639 ShouldCreate);
640}
641
642DISubrange *DISubrange::getImpl(LLVMContext &Context, Metadata *CountNode,
643 Metadata *LB, Metadata *UB, Metadata *Stride,
644 StorageType Storage, bool ShouldCreate) {
645 DEFINE_GETIMPL_LOOKUP(DISubrange, (CountNode, LB, UB, Stride));
646 Metadata *Ops[] = {CountNode, LB, UB, Stride};
648}
649
650DISubrange::BoundType DISubrange::getCount() const {
651 Metadata *CB = getRawCountNode();
652 if (!CB)
653 return BoundType();
654
656 isa<DIExpression>(CB)) &&
657 "Count must be signed constant or DIVariable or DIExpression");
658
659 if (auto *MD = dyn_cast<ConstantAsMetadata>(CB))
660 return BoundType(cast<ConstantInt>(MD->getValue()));
661
662 if (auto *MD = dyn_cast<DIVariable>(CB))
663 return BoundType(MD);
664
665 if (auto *MD = dyn_cast<DIExpression>(CB))
666 return BoundType(MD);
667
668 return BoundType();
669}
670
671DISubrange::BoundType DISubrange::getLowerBound() const {
672 Metadata *LB = getRawLowerBound();
673 if (!LB)
674 return BoundType();
675
677 isa<DIExpression>(LB)) &&
678 "LowerBound must be signed constant or DIVariable or DIExpression");
679
680 if (auto *MD = dyn_cast<ConstantAsMetadata>(LB))
681 return BoundType(cast<ConstantInt>(MD->getValue()));
682
683 if (auto *MD = dyn_cast<DIVariable>(LB))
684 return BoundType(MD);
685
686 if (auto *MD = dyn_cast<DIExpression>(LB))
687 return BoundType(MD);
688
689 return BoundType();
690}
691
692DISubrange::BoundType DISubrange::getUpperBound() const {
693 Metadata *UB = getRawUpperBound();
694 if (!UB)
695 return BoundType();
696
698 isa<DIExpression>(UB)) &&
699 "UpperBound must be signed constant or DIVariable or DIExpression");
700
701 if (auto *MD = dyn_cast<ConstantAsMetadata>(UB))
702 return BoundType(cast<ConstantInt>(MD->getValue()));
703
704 if (auto *MD = dyn_cast<DIVariable>(UB))
705 return BoundType(MD);
706
707 if (auto *MD = dyn_cast<DIExpression>(UB))
708 return BoundType(MD);
709
710 return BoundType();
711}
712
713DISubrange::BoundType DISubrange::getStride() const {
714 Metadata *ST = getRawStride();
715 if (!ST)
716 return BoundType();
717
719 isa<DIExpression>(ST)) &&
720 "Stride must be signed constant or DIVariable or DIExpression");
721
722 if (auto *MD = dyn_cast<ConstantAsMetadata>(ST))
723 return BoundType(cast<ConstantInt>(MD->getValue()));
724
725 if (auto *MD = dyn_cast<DIVariable>(ST))
726 return BoundType(MD);
727
728 if (auto *MD = dyn_cast<DIExpression>(ST))
729 return BoundType(MD);
730
731 return BoundType();
732}
733DIGenericSubrange::DIGenericSubrange(LLVMContext &C, StorageType Storage,
735 : DINode(C, DIGenericSubrangeKind, Storage, dwarf::DW_TAG_generic_subrange,
736 Ops) {}
737
738DIGenericSubrange *DIGenericSubrange::getImpl(LLVMContext &Context,
739 Metadata *CountNode, Metadata *LB,
740 Metadata *UB, Metadata *Stride,
741 StorageType Storage,
742 bool ShouldCreate) {
743 DEFINE_GETIMPL_LOOKUP(DIGenericSubrange, (CountNode, LB, UB, Stride));
744 Metadata *Ops[] = {CountNode, LB, UB, Stride};
746}
747
750 if (!CB)
751 return BoundType();
752
754 "Count must be signed constant or DIVariable or DIExpression");
755
756 if (auto *MD = dyn_cast<DIVariable>(CB))
757 return BoundType(MD);
758
759 if (auto *MD = dyn_cast<DIExpression>(CB))
760 return BoundType(MD);
761
762 return BoundType();
763}
764
767 if (!LB)
768 return BoundType();
769
771 "LowerBound must be signed constant or DIVariable or DIExpression");
772
773 if (auto *MD = dyn_cast<DIVariable>(LB))
774 return BoundType(MD);
775
776 if (auto *MD = dyn_cast<DIExpression>(LB))
777 return BoundType(MD);
778
779 return BoundType();
780}
781
784 if (!UB)
785 return BoundType();
786
788 "UpperBound must be signed constant or DIVariable or DIExpression");
789
790 if (auto *MD = dyn_cast<DIVariable>(UB))
791 return BoundType(MD);
792
793 if (auto *MD = dyn_cast<DIExpression>(UB))
794 return BoundType(MD);
795
796 return BoundType();
797}
798
800 Metadata *ST = getRawStride();
801 if (!ST)
802 return BoundType();
803
805 "Stride must be signed constant or DIVariable or DIExpression");
806
807 if (auto *MD = dyn_cast<DIVariable>(ST))
808 return BoundType(MD);
809
810 if (auto *MD = dyn_cast<DIExpression>(ST))
811 return BoundType(MD);
812
813 return BoundType();
814}
815
816DISubrangeType::DISubrangeType(LLVMContext &C, StorageType Storage,
817 unsigned Line, uint32_t AlignInBits,
818 DIFlags Flags, ArrayRef<Metadata *> Ops)
819 : DIType(C, DISubrangeTypeKind, Storage, dwarf::DW_TAG_subrange_type, Line,
820 AlignInBits, 0, Flags, Ops) {}
821
822DISubrangeType *DISubrangeType::getImpl(
823 LLVMContext &Context, MDString *Name, Metadata *File, unsigned Line,
824 Metadata *Scope, Metadata *SizeInBits, uint32_t AlignInBits, DIFlags Flags,
825 Metadata *BaseType, Metadata *LowerBound, Metadata *UpperBound,
826 Metadata *Stride, Metadata *Bias, StorageType Storage, bool ShouldCreate) {
827 assert(isCanonical(Name) && "Expected canonical MDString");
829 AlignInBits, Flags, BaseType,
831 Metadata *Ops[] = {File, Scope, Name, SizeInBits, nullptr,
833 DEFINE_GETIMPL_STORE(DISubrangeType, (Line, AlignInBits, Flags), Ops);
834}
835
837DISubrangeType::convertRawToBound(Metadata *IN) const {
838 if (!IN)
839 return BoundType();
840
843
844 if (auto *MD = dyn_cast<ConstantAsMetadata>(IN))
845 return BoundType(cast<ConstantInt>(MD->getValue()));
846
847 if (auto *MD = dyn_cast<DIVariable>(IN))
848 return BoundType(MD);
849
850 if (auto *MD = dyn_cast<DIExpression>(IN))
851 return BoundType(MD);
852
853 return BoundType();
854}
855
856DIEnumerator::DIEnumerator(LLVMContext &C, StorageType Storage,
857 const APInt &Value, bool IsUnsigned,
859 : DINode(C, DIEnumeratorKind, Storage, dwarf::DW_TAG_enumerator, Ops),
860 Value(Value) {
861 SubclassData32 = IsUnsigned;
862}
863DIEnumerator *DIEnumerator::getImpl(LLVMContext &Context, const APInt &Value,
864 bool IsUnsigned, MDString *Name,
865 StorageType Storage, bool ShouldCreate) {
866 assert(isCanonical(Name) && "Expected canonical MDString");
867 DEFINE_GETIMPL_LOOKUP(DIEnumerator, (Value, IsUnsigned, Name));
868 Metadata *Ops[] = {Name};
869 DEFINE_GETIMPL_STORE(DIEnumerator, (Value, IsUnsigned), Ops);
870}
871
874 uint32_t AlignInBits, unsigned Encoding,
876 uint32_t DataSizeInBits, DIFlags Flags,
877 StorageType Storage, bool ShouldCreate) {
878 assert(isCanonical(Name) && "Expected canonical MDString");
880 (Tag, Name, SizeInBits, AlignInBits, Encoding,
881 NumExtraInhabitants, DataSizeInBits, Flags));
882 Metadata *Ops[] = {nullptr, nullptr, Name, SizeInBits, nullptr};
885 (Tag, AlignInBits, Encoding, NumExtraInhabitants, DataSizeInBits, Flags),
886 Ops);
887}
888
889std::optional<DIBasicType::Signedness> DIBasicType::getSignedness() const {
890 switch (getEncoding()) {
891 case dwarf::DW_ATE_signed:
892 case dwarf::DW_ATE_signed_char:
893 case dwarf::DW_ATE_signed_fixed:
894 return Signedness::Signed;
895 case dwarf::DW_ATE_unsigned:
896 case dwarf::DW_ATE_unsigned_char:
897 case dwarf::DW_ATE_unsigned_fixed:
899 default:
900 return std::nullopt;
901 }
902}
903
905DIFixedPointType::getImpl(LLVMContext &Context, unsigned Tag, MDString *Name,
906 Metadata *SizeInBits, uint32_t AlignInBits,
907 unsigned Encoding, DIFlags Flags, unsigned Kind,
908 int Factor, APInt Numerator, APInt Denominator,
909 StorageType Storage, bool ShouldCreate) {
912 Kind, Factor, Numerator, Denominator));
913 Metadata *Ops[] = {nullptr, nullptr, Name, SizeInBits, nullptr};
916 (Tag, AlignInBits, Encoding, Flags, Kind, Factor, Numerator, Denominator),
917 Ops);
918}
919
921 return getEncoding() == dwarf::DW_ATE_signed_fixed;
922}
923
924std::optional<DIFixedPointType::FixedPointKind>
927 .Case("Binary", FixedPointBinary)
928 .Case("Decimal", FixedPointDecimal)
929 .Case("Rational", FixedPointRational)
930 .Default(std::nullopt);
931}
932
934 switch (V) {
935 case FixedPointBinary:
936 return "Binary";
938 return "Decimal";
940 return "Rational";
941 }
942 return nullptr;
943}
944
945DIStringType *DIStringType::getImpl(LLVMContext &Context, unsigned Tag,
946 MDString *Name, Metadata *StringLength,
947 Metadata *StringLengthExp,
948 Metadata *StringLocationExp,
949 Metadata *SizeInBits, uint32_t AlignInBits,
950 unsigned Encoding, StorageType Storage,
951 bool ShouldCreate) {
952 assert(isCanonical(Name) && "Expected canonical MDString");
956 Metadata *Ops[] = {nullptr, nullptr, Name,
957 SizeInBits, nullptr, StringLength,
960}
962 assert(getTag() == dwarf::DW_TAG_ptr_to_member_type);
964}
966 assert(getTag() == dwarf::DW_TAG_inheritance);
968 if (auto *CI = dyn_cast_or_null<ConstantInt>(CM->getValue()))
969 return static_cast<uint32_t>(CI->getZExtValue());
970 return 0;
971}
973 assert(getTag() == dwarf::DW_TAG_member && isBitField());
975 return C->getValue();
976 return nullptr;
977}
978
980 assert((getTag() == dwarf::DW_TAG_member ||
981 getTag() == dwarf::DW_TAG_variable) &&
984 return C->getValue();
985 return nullptr;
986}
988 assert(getTag() == dwarf::DW_TAG_member && !isStaticMember());
990 return C->getValue();
991 return nullptr;
992}
993
994DIDerivedType *DIDerivedType::getImpl(
995 LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
996 unsigned Line, Metadata *Scope, Metadata *BaseType, Metadata *SizeInBits,
997 uint32_t AlignInBits, Metadata *OffsetInBits,
998 std::optional<unsigned> DWARFAddressSpace,
999 std::optional<PtrAuthData> PtrAuthData, DIFlags Flags, Metadata *ExtraData,
1000 Metadata *Annotations, StorageType Storage, bool ShouldCreate) {
1001 assert(isCanonical(Name) && "Expected canonical MDString");
1003 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
1005 PtrAuthData, Flags, ExtraData, Annotations));
1006 Metadata *Ops[] = {File, Scope, Name, SizeInBits,
1007 OffsetInBits, BaseType, ExtraData, Annotations};
1010 (Tag, Line, AlignInBits, DWARFAddressSpace, PtrAuthData, Flags), Ops);
1011}
1012
1013std::optional<DIDerivedType::PtrAuthData>
1014DIDerivedType::getPtrAuthData() const {
1015 return getTag() == dwarf::DW_TAG_LLVM_ptrauth_type
1016 ? std::make_optional<PtrAuthData>(SubclassData32)
1017 : std::nullopt;
1018}
1019
1020DICompositeType *DICompositeType::getImpl(
1021 LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
1022 unsigned Line, Metadata *Scope, Metadata *BaseType, Metadata *SizeInBits,
1023 uint32_t AlignInBits, Metadata *OffsetInBits, DIFlags Flags,
1024 Metadata *Elements, unsigned RuntimeLang, std::optional<uint32_t> EnumKind,
1025 Metadata *VTableHolder, Metadata *TemplateParams, MDString *Identifier,
1026 Metadata *Discriminator, Metadata *DataLocation, Metadata *Associated,
1027 Metadata *Allocated, Metadata *Rank, Metadata *Annotations,
1028 Metadata *Specification, uint32_t NumExtraInhabitants, Metadata *BitStride,
1029 StorageType Storage, bool ShouldCreate) {
1030 assert(isCanonical(Name) && "Expected canonical MDString");
1031
1032 // Keep this in sync with buildODRType.
1034 DICompositeType,
1044 DEFINE_GETIMPL_STORE(DICompositeType,
1045 (Tag, Line, RuntimeLang, AlignInBits,
1046 NumExtraInhabitants, EnumKind, Flags),
1047 Ops);
1048}
1049
1051 LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name,
1055 Metadata *Elements, unsigned RuntimeLang, std::optional<uint32_t> EnumKind,
1059 assert(!Identifier.getString().empty() && "Expected valid identifier");
1060 if (!Context.isODRUniquingDebugTypes())
1061 return nullptr;
1062 auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier];
1063 if (!CT)
1064 return CT = DICompositeType::getDistinct(
1065 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
1066 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
1070 if (CT->getTag() != Tag)
1071 return nullptr;
1072
1073 // Only mutate CT if it's a forward declaration and the new operands aren't.
1074 assert(CT->getRawIdentifier() == &Identifier && "Wrong ODR identifier?");
1075 if (!CT->isForwardDecl() || (Flags & DINode::FlagFwdDecl))
1076 return CT;
1077
1078 // Mutate CT in place. Keep this in sync with getImpl.
1079 CT->mutate(Tag, Line, RuntimeLang, AlignInBits, NumExtraInhabitants, EnumKind,
1080 Flags);
1086 assert((std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands() &&
1087 "Mismatched number of operands");
1088 for (unsigned I = 0, E = CT->getNumOperands(); I != E; ++I)
1089 if (Ops[I] != CT->getOperand(I))
1090 CT->setOperand(I, Ops[I]);
1091 return CT;
1092}
1093
1094DICompositeType *DICompositeType::getODRType(
1095 LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name,
1096 Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType,
1097 Metadata *SizeInBits, uint32_t AlignInBits, Metadata *OffsetInBits,
1098 Metadata *Specification, uint32_t NumExtraInhabitants, DIFlags Flags,
1099 Metadata *Elements, unsigned RuntimeLang, std::optional<uint32_t> EnumKind,
1100 Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator,
1101 Metadata *DataLocation, Metadata *Associated, Metadata *Allocated,
1102 Metadata *Rank, Metadata *Annotations, Metadata *BitStride) {
1103 assert(!Identifier.getString().empty() && "Expected valid identifier");
1104 if (!Context.isODRUniquingDebugTypes())
1105 return nullptr;
1106 auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier];
1107 if (!CT) {
1109 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
1114 } else {
1115 if (CT->getTag() != Tag)
1116 return nullptr;
1117 }
1118 return CT;
1119}
1120
1123 assert(!Identifier.getString().empty() && "Expected valid identifier");
1124 if (!Context.isODRUniquingDebugTypes())
1125 return nullptr;
1126 return Context.pImpl->DITypeMap->lookup(&Identifier);
1127}
1128DISubroutineType::DISubroutineType(LLVMContext &C, StorageType Storage,
1129 DIFlags Flags, uint8_t CC,
1131 : DIType(C, DISubroutineTypeKind, Storage, dwarf::DW_TAG_subroutine_type, 0,
1132 0, 0, Flags, Ops),
1133 CC(CC) {}
1134
1135DISubroutineType *DISubroutineType::getImpl(LLVMContext &Context, DIFlags Flags,
1136 uint8_t CC, Metadata *TypeArray,
1137 StorageType Storage,
1138 bool ShouldCreate) {
1140 Metadata *Ops[] = {nullptr, nullptr, nullptr, nullptr, nullptr, TypeArray};
1141 DEFINE_GETIMPL_STORE(DISubroutineType, (Flags, CC), Ops);
1142}
1143
1144DIFile::DIFile(LLVMContext &C, StorageType Storage,
1145 std::optional<ChecksumInfo<MDString *>> CS, MDString *Src,
1147 : DIScope(C, DIFileKind, Storage, dwarf::DW_TAG_file_type, Ops),
1148 Checksum(CS), Source(Src) {}
1149
1150// FIXME: Implement this string-enum correspondence with a .def file and macros,
1151// so that the association is explicit rather than implied.
1152static const char *ChecksumKindName[DIFile::CSK_Last] = {
1153 "CSK_MD5",
1154 "CSK_SHA1",
1155 "CSK_SHA256",
1156};
1157
1158StringRef DIFile::getChecksumKindAsString(ChecksumKind CSKind) {
1159 assert(CSKind <= DIFile::CSK_Last && "Invalid checksum kind");
1160 // The first space was originally the CSK_None variant, which is now
1161 // obsolete, but the space is still reserved in ChecksumKind, so we account
1162 // for it here.
1163 return ChecksumKindName[CSKind - 1];
1164}
1165
1166std::optional<DIFile::ChecksumKind>
1169 .Case("CSK_MD5", DIFile::CSK_MD5)
1170 .Case("CSK_SHA1", DIFile::CSK_SHA1)
1171 .Case("CSK_SHA256", DIFile::CSK_SHA256)
1172 .Default(std::nullopt);
1173}
1174
1175DIFile *DIFile::getImpl(LLVMContext &Context, MDString *Filename,
1176 MDString *Directory,
1177 std::optional<DIFile::ChecksumInfo<MDString *>> CS,
1178 MDString *Source, StorageType Storage,
1179 bool ShouldCreate) {
1180 assert(isCanonical(Filename) && "Expected canonical MDString");
1181 assert(isCanonical(Directory) && "Expected canonical MDString");
1182 assert((!CS || isCanonical(CS->Value)) && "Expected canonical MDString");
1183 // We do *NOT* expect Source to be a canonical MDString because nullptr
1184 // means none, so we need something to represent the empty file.
1186 Metadata *Ops[] = {Filename, Directory, CS ? CS->Value : nullptr, Source};
1188}
1189DICompileUnit::DICompileUnit(LLVMContext &C, StorageType Storage,
1191 bool IsOptimized, unsigned RuntimeVersion,
1192 unsigned EmissionKind, uint64_t DWOId,
1193 bool SplitDebugInlining,
1194 bool DebugInfoForProfiling, unsigned NameTableKind,
1195 bool RangesBaseAddress, ArrayRef<Metadata *> Ops)
1196 : DIScope(C, DICompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops),
1197 SourceLanguage(SourceLanguage), RuntimeVersion(RuntimeVersion),
1199 IsOptimized(IsOptimized), SplitDebugInlining(SplitDebugInlining),
1200 DebugInfoForProfiling(DebugInfoForProfiling),
1201 RangesBaseAddress(RangesBaseAddress) {
1203}
1204
1205DICompileUnit *DICompileUnit::getImpl(
1207 MDString *Producer, bool IsOptimized, MDString *Flags,
1208 unsigned RuntimeVersion, MDString *SplitDebugFilename,
1209 unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
1210 Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata *Macros,
1211 uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
1212 unsigned NameTableKind, bool RangesBaseAddress, MDString *SysRoot,
1213 MDString *SDK, StorageType Storage, bool ShouldCreate) {
1214 assert(Storage != Uniqued && "Cannot unique DICompileUnit");
1215 assert(isCanonical(Producer) && "Expected canonical MDString");
1216 assert(isCanonical(Flags) && "Expected canonical MDString");
1217 assert(isCanonical(SplitDebugFilename) && "Expected canonical MDString");
1218
1219 Metadata *Ops[] = {File,
1220 Producer,
1221 Flags,
1223 EnumTypes,
1227 Macros,
1228 SysRoot,
1229 SDK};
1230 return storeImpl(new (std::size(Ops), Storage) DICompileUnit(
1231 Context, Storage, SourceLanguage, IsOptimized,
1232 RuntimeVersion, EmissionKind, DWOId, SplitDebugInlining,
1233 DebugInfoForProfiling, NameTableKind, RangesBaseAddress,
1234 Ops),
1235 Storage);
1236}
1237
1238std::optional<DICompileUnit::DebugEmissionKind>
1241 .Case("NoDebug", NoDebug)
1242 .Case("FullDebug", FullDebug)
1243 .Case("LineTablesOnly", LineTablesOnly)
1244 .Case("DebugDirectivesOnly", DebugDirectivesOnly)
1245 .Default(std::nullopt);
1246}
1247
1248std::optional<DICompileUnit::DebugNameTableKind>
1257
1259 switch (EK) {
1260 case NoDebug:
1261 return "NoDebug";
1262 case FullDebug:
1263 return "FullDebug";
1264 case LineTablesOnly:
1265 return "LineTablesOnly";
1267 return "DebugDirectivesOnly";
1268 }
1269 return nullptr;
1270}
1271
1273 switch (NTK) {
1275 return nullptr;
1277 return "GNU";
1279 return "Apple";
1281 return "None";
1282 }
1283 return nullptr;
1284}
1285DISubprogram::DISubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
1286 unsigned ScopeLine, unsigned VirtualIndex,
1287 int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags,
1288 bool UsesKeyInstructions, ArrayRef<Metadata *> Ops)
1289 : DILocalScope(C, DISubprogramKind, Storage, dwarf::DW_TAG_subprogram, Ops),
1290 Line(Line), ScopeLine(ScopeLine), VirtualIndex(VirtualIndex),
1291 ThisAdjustment(ThisAdjustment), Flags(Flags), SPFlags(SPFlags) {
1292 static_assert(dwarf::DW_VIRTUALITY_max < 4, "Virtuality out of range");
1293 SubclassData1 = UsesKeyInstructions;
1294}
1296DISubprogram::toSPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized,
1297 unsigned Virtuality, bool IsMainSubprogram) {
1298 // We're assuming virtuality is the low-order field.
1299 static_assert(int(SPFlagVirtual) == int(dwarf::DW_VIRTUALITY_virtual) &&
1300 int(SPFlagPureVirtual) ==
1301 int(dwarf::DW_VIRTUALITY_pure_virtual),
1302 "Virtuality constant mismatch");
1303 return static_cast<DISPFlags>(
1304 (Virtuality & SPFlagVirtuality) |
1305 (IsLocalToUnit ? SPFlagLocalToUnit : SPFlagZero) |
1306 (IsDefinition ? SPFlagDefinition : SPFlagZero) |
1307 (IsOptimized ? SPFlagOptimized : SPFlagZero) |
1308 (IsMainSubprogram ? SPFlagMainSubprogram : SPFlagZero));
1309}
1310
1312 if (auto *Block = dyn_cast<DILexicalBlockBase>(this))
1313 return Block->getScope()->getSubprogram();
1314 return const_cast<DISubprogram *>(cast<DISubprogram>(this));
1315}
1316
1318 if (auto *File = dyn_cast<DILexicalBlockFile>(this))
1319 return File->getScope()->getNonLexicalBlockFileScope();
1320 return const_cast<DILocalScope *>(this);
1321}
1322
1324 DILocalScope &RootScope, DISubprogram &NewSP, LLVMContext &Ctx,
1326 SmallVector<DIScope *> ScopeChain;
1327 DIScope *CachedResult = nullptr;
1328
1329 for (DIScope *Scope = &RootScope; !isa<DISubprogram>(Scope);
1330 Scope = Scope->getScope()) {
1331 if (auto It = Cache.find(Scope); It != Cache.end()) {
1332 CachedResult = cast<DIScope>(It->second);
1333 break;
1334 }
1335 ScopeChain.push_back(Scope);
1336 }
1337
1338 // Recreate the scope chain, bottom-up, starting at the new subprogram (or a
1339 // cached result).
1340 DIScope *UpdatedScope = CachedResult ? CachedResult : &NewSP;
1341 for (DIScope *ScopeToUpdate : reverse(ScopeChain)) {
1342 UpdatedScope = cloneAndReplaceParentScope(
1343 cast<DILexicalBlockBase>(ScopeToUpdate), UpdatedScope);
1344 Cache[ScopeToUpdate] = UpdatedScope;
1345 }
1346
1347 return cast<DILocalScope>(UpdatedScope);
1348}
1349
1351 return StringSwitch<DISPFlags>(Flag)
1352#define HANDLE_DISP_FLAG(ID, NAME) .Case("DISPFlag" #NAME, SPFlag##NAME)
1353#include "llvm/IR/DebugInfoFlags.def"
1354 .Default(SPFlagZero);
1355}
1356
1358 switch (Flag) {
1359 // Appease a warning.
1360 case SPFlagVirtuality:
1361 return "";
1362#define HANDLE_DISP_FLAG(ID, NAME) \
1363 case SPFlag##NAME: \
1364 return "DISPFlag" #NAME;
1365#include "llvm/IR/DebugInfoFlags.def"
1366 }
1367 return "";
1368}
1369
1372 SmallVectorImpl<DISPFlags> &SplitFlags) {
1373 // Multi-bit fields can require special handling. In our case, however, the
1374 // only multi-bit field is virtuality, and all its values happen to be
1375 // single-bit values, so the right behavior just falls out.
1376#define HANDLE_DISP_FLAG(ID, NAME) \
1377 if (DISPFlags Bit = Flags & SPFlag##NAME) { \
1378 SplitFlags.push_back(Bit); \
1379 Flags &= ~Bit; \
1380 }
1381#include "llvm/IR/DebugInfoFlags.def"
1382 return Flags;
1383}
1384
1385DISubprogram *DISubprogram::getImpl(
1386 LLVMContext &Context, Metadata *Scope, MDString *Name,
1387 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
1388 unsigned ScopeLine, Metadata *ContainingType, unsigned VirtualIndex,
1389 int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags, Metadata *Unit,
1390 Metadata *TemplateParams, Metadata *Declaration, Metadata *RetainedNodes,
1391 Metadata *ThrownTypes, Metadata *Annotations, MDString *TargetFuncName,
1392 bool UsesKeyInstructions, StorageType Storage, bool ShouldCreate) {
1393 assert(isCanonical(Name) && "Expected canonical MDString");
1394 assert(isCanonical(LinkageName) && "Expected canonical MDString");
1395 assert(isCanonical(TargetFuncName) && "Expected canonical MDString");
1397 (Scope, Name, LinkageName, File, Line, Type, ScopeLine,
1403 File, Scope, Name, LinkageName,
1407 if (!TargetFuncName) {
1408 Ops.pop_back();
1409 if (!Annotations) {
1410 Ops.pop_back();
1411 if (!ThrownTypes) {
1412 Ops.pop_back();
1413 if (!TemplateParams) {
1414 Ops.pop_back();
1415 if (!ContainingType)
1416 Ops.pop_back();
1417 }
1418 }
1419 }
1420 }
1421 DEFINE_GETIMPL_STORE_N(DISubprogram,
1422 (Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags,
1423 SPFlags, UsesKeyInstructions),
1424 Ops, Ops.size());
1425}
1426
1427bool DISubprogram::describes(const Function *F) const {
1428 assert(F && "Invalid function");
1429 return F->getSubprogram() == this;
1430}
1435
1436DILexicalBlock *DILexicalBlock::getImpl(LLVMContext &Context, Metadata *Scope,
1437 Metadata *File, unsigned Line,
1438 unsigned Column, StorageType Storage,
1439 bool ShouldCreate) {
1440 // Fixup column.
1442
1443 assert(Scope && "Expected scope");
1445 Metadata *Ops[] = {File, Scope};
1447}
1448
1449DILexicalBlockFile *DILexicalBlockFile::getImpl(LLVMContext &Context,
1450 Metadata *Scope, Metadata *File,
1451 unsigned Discriminator,
1452 StorageType Storage,
1453 bool ShouldCreate) {
1454 assert(Scope && "Expected scope");
1455 DEFINE_GETIMPL_LOOKUP(DILexicalBlockFile, (Scope, File, Discriminator));
1456 Metadata *Ops[] = {File, Scope};
1457 DEFINE_GETIMPL_STORE(DILexicalBlockFile, (Discriminator), Ops);
1458}
1459
1460DINamespace::DINamespace(LLVMContext &Context, StorageType Storage,
1461 bool ExportSymbols, ArrayRef<Metadata *> Ops)
1462 : DIScope(Context, DINamespaceKind, Storage, dwarf::DW_TAG_namespace, Ops) {
1463 SubclassData1 = ExportSymbols;
1464}
1465DINamespace *DINamespace::getImpl(LLVMContext &Context, Metadata *Scope,
1466 MDString *Name, bool ExportSymbols,
1467 StorageType Storage, bool ShouldCreate) {
1468 assert(isCanonical(Name) && "Expected canonical MDString");
1470 // The nullptr is for DIScope's File operand. This should be refactored.
1471 Metadata *Ops[] = {nullptr, Scope, Name};
1472 DEFINE_GETIMPL_STORE(DINamespace, (ExportSymbols), Ops);
1473}
1474
1475DICommonBlock::DICommonBlock(LLVMContext &Context, StorageType Storage,
1476 unsigned LineNo, ArrayRef<Metadata *> Ops)
1477 : DIScope(Context, DICommonBlockKind, Storage, dwarf::DW_TAG_common_block,
1478 Ops) {
1479 SubclassData32 = LineNo;
1480}
1481DICommonBlock *DICommonBlock::getImpl(LLVMContext &Context, Metadata *Scope,
1482 Metadata *Decl, MDString *Name,
1483 Metadata *File, unsigned LineNo,
1484 StorageType Storage, bool ShouldCreate) {
1485 assert(isCanonical(Name) && "Expected canonical MDString");
1486 DEFINE_GETIMPL_LOOKUP(DICommonBlock, (Scope, Decl, Name, File, LineNo));
1487 // The nullptr is for DIScope's File operand. This should be refactored.
1488 Metadata *Ops[] = {Scope, Decl, Name, File};
1489 DEFINE_GETIMPL_STORE(DICommonBlock, (LineNo), Ops);
1490}
1491
1492DIModule::DIModule(LLVMContext &Context, StorageType Storage, unsigned LineNo,
1493 bool IsDecl, ArrayRef<Metadata *> Ops)
1494 : DIScope(Context, DIModuleKind, Storage, dwarf::DW_TAG_module, Ops) {
1495 SubclassData1 = IsDecl;
1496 SubclassData32 = LineNo;
1497}
1498DIModule *DIModule::getImpl(LLVMContext &Context, Metadata *File,
1499 Metadata *Scope, MDString *Name,
1500 MDString *ConfigurationMacros,
1501 MDString *IncludePath, MDString *APINotesFile,
1502 unsigned LineNo, bool IsDecl, StorageType Storage,
1503 bool ShouldCreate) {
1504 assert(isCanonical(Name) && "Expected canonical MDString");
1506 IncludePath, APINotesFile, LineNo, IsDecl));
1509 DEFINE_GETIMPL_STORE(DIModule, (LineNo, IsDecl), Ops);
1510}
1511DITemplateTypeParameter::DITemplateTypeParameter(LLVMContext &Context,
1512 StorageType Storage,
1513 bool IsDefault,
1515 : DITemplateParameter(Context, DITemplateTypeParameterKind, Storage,
1516 dwarf::DW_TAG_template_type_parameter, IsDefault,
1517 Ops) {}
1518
1520DITemplateTypeParameter::getImpl(LLVMContext &Context, MDString *Name,
1521 Metadata *Type, bool isDefault,
1522 StorageType Storage, bool ShouldCreate) {
1523 assert(isCanonical(Name) && "Expected canonical MDString");
1524 DEFINE_GETIMPL_LOOKUP(DITemplateTypeParameter, (Name, Type, isDefault));
1525 Metadata *Ops[] = {Name, Type};
1526 DEFINE_GETIMPL_STORE(DITemplateTypeParameter, (isDefault), Ops);
1527}
1528
1529DITemplateValueParameter *DITemplateValueParameter::getImpl(
1530 LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *Type,
1531 bool isDefault, Metadata *Value, StorageType Storage, bool ShouldCreate) {
1532 assert(isCanonical(Name) && "Expected canonical MDString");
1533 DEFINE_GETIMPL_LOOKUP(DITemplateValueParameter,
1534 (Tag, Name, Type, isDefault, Value));
1535 Metadata *Ops[] = {Name, Type, Value};
1536 DEFINE_GETIMPL_STORE(DITemplateValueParameter, (Tag, isDefault), Ops);
1537}
1538
1540DIGlobalVariable::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
1541 MDString *LinkageName, Metadata *File, unsigned Line,
1542 Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
1543 Metadata *StaticDataMemberDeclaration,
1544 Metadata *TemplateParams, uint32_t AlignInBits,
1545 Metadata *Annotations, StorageType Storage,
1546 bool ShouldCreate) {
1547 assert(isCanonical(Name) && "Expected canonical MDString");
1548 assert(isCanonical(LinkageName) && "Expected canonical MDString");
1550 DIGlobalVariable,
1551 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
1553 Metadata *Ops[] = {Scope,
1554 Name,
1555 File,
1556 Type,
1557 Name,
1561 Annotations};
1562 DEFINE_GETIMPL_STORE(DIGlobalVariable,
1563 (Line, IsLocalToUnit, IsDefinition, AlignInBits), Ops);
1564}
1565
1567DILocalVariable::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
1568 Metadata *File, unsigned Line, Metadata *Type,
1569 unsigned Arg, DIFlags Flags, uint32_t AlignInBits,
1570 Metadata *Annotations, StorageType Storage,
1571 bool ShouldCreate) {
1572 // 64K ought to be enough for any frontend.
1573 assert(Arg <= UINT16_MAX && "Expected argument number to fit in 16-bits");
1574
1575 assert(Scope && "Expected scope");
1576 assert(isCanonical(Name) && "Expected canonical MDString");
1577 DEFINE_GETIMPL_LOOKUP(DILocalVariable, (Scope, Name, File, Line, Type, Arg,
1578 Flags, AlignInBits, Annotations));
1580 DEFINE_GETIMPL_STORE(DILocalVariable, (Line, Arg, Flags, AlignInBits), Ops);
1581}
1582
1584 signed Line, ArrayRef<Metadata *> Ops,
1585 uint32_t AlignInBits)
1586 : DINode(C, ID, Storage, dwarf::DW_TAG_variable, Ops), Line(Line) {
1587 SubclassData32 = AlignInBits;
1588}
1589std::optional<uint64_t> DIVariable::getSizeInBits() const {
1590 // This is used by the Verifier so be mindful of broken types.
1591 const Metadata *RawType = getRawType();
1592 while (RawType) {
1593 // Try to get the size directly.
1594 if (auto *T = dyn_cast<DIType>(RawType))
1595 if (uint64_t Size = T->getSizeInBits())
1596 return Size;
1597
1598 if (auto *DT = dyn_cast<DIDerivedType>(RawType)) {
1599 // Look at the base type.
1600 RawType = DT->getRawBaseType();
1601 continue;
1602 }
1603
1604 // Missing type or size.
1605 break;
1606 }
1607
1608 // Fail gracefully.
1609 return std::nullopt;
1610}
1611
1612DILabel::DILabel(LLVMContext &C, StorageType Storage, unsigned Line,
1613 unsigned Column, bool IsArtificial,
1614 std::optional<unsigned> CoroSuspendIdx,
1616 : DINode(C, DILabelKind, Storage, dwarf::DW_TAG_label, Ops) {
1617 this->SubclassData32 = Line;
1618 this->Column = Column;
1619 this->IsArtificial = IsArtificial;
1620 this->CoroSuspendIdx = CoroSuspendIdx;
1621}
1622DILabel *DILabel::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
1623 Metadata *File, unsigned Line, unsigned Column,
1624 bool IsArtificial,
1625 std::optional<unsigned> CoroSuspendIdx,
1626 StorageType Storage, bool ShouldCreate) {
1627 assert(Scope && "Expected scope");
1628 assert(isCanonical(Name) && "Expected canonical MDString");
1630 DILabel, (Scope, Name, File, Line, Column, IsArtificial, CoroSuspendIdx));
1631 Metadata *Ops[] = {Scope, Name, File};
1632 DEFINE_GETIMPL_STORE(DILabel, (Line, Column, IsArtificial, CoroSuspendIdx),
1633 Ops);
1634}
1635
1636DIExpression *DIExpression::getImpl(LLVMContext &Context,
1637 ArrayRef<uint64_t> Elements,
1638 StorageType Storage, bool ShouldCreate) {
1639 DEFINE_GETIMPL_LOOKUP(DIExpression, (Elements));
1640 DEFINE_GETIMPL_STORE_NO_OPS(DIExpression, (Elements));
1641}
1643 if (auto singleLocElts = getSingleLocationExpressionElements()) {
1644 return singleLocElts->size() > 0 &&
1645 (*singleLocElts)[0] == dwarf::DW_OP_LLVM_entry_value;
1646 }
1647 return false;
1648}
1650 if (auto singleLocElts = getSingleLocationExpressionElements())
1651 return singleLocElts->size() > 0 &&
1652 (*singleLocElts)[0] == dwarf::DW_OP_deref;
1653 return false;
1654}
1656 if (auto singleLocElts = getSingleLocationExpressionElements())
1657 return singleLocElts->size() == 1 &&
1658 (*singleLocElts)[0] == dwarf::DW_OP_deref;
1659 return false;
1660}
1661
1662DIAssignID *DIAssignID::getImpl(LLVMContext &Context, StorageType Storage,
1663 bool ShouldCreate) {
1664 // Uniqued DIAssignID are not supported as the instance address *is* the ID.
1665 assert(Storage != StorageType::Uniqued && "uniqued DIAssignID unsupported");
1666 return storeImpl(new (0u, Storage) DIAssignID(Context, Storage), Storage);
1667}
1668
1670 uint64_t Op = getOp();
1671
1672 if (Op >= dwarf::DW_OP_breg0 && Op <= dwarf::DW_OP_breg31)
1673 return 2;
1674
1675 switch (Op) {
1680 case dwarf::DW_OP_bregx:
1681 return 3;
1682 case dwarf::DW_OP_constu:
1683 case dwarf::DW_OP_consts:
1684 case dwarf::DW_OP_deref_size:
1685 case dwarf::DW_OP_plus_uconst:
1689 case dwarf::DW_OP_regx:
1690 return 2;
1691 default:
1692 return 1;
1693 }
1694}
1695
1697 for (auto I = expr_op_begin(), E = expr_op_end(); I != E; ++I) {
1698 // Check that there's space for the operand.
1699 if (I->get() + I->getSize() > E->get())
1700 return false;
1701
1702 uint64_t Op = I->getOp();
1703 if ((Op >= dwarf::DW_OP_reg0 && Op <= dwarf::DW_OP_reg31) ||
1704 (Op >= dwarf::DW_OP_breg0 && Op <= dwarf::DW_OP_breg31))
1705 return true;
1706
1707 // Check that the operand is valid.
1708 switch (Op) {
1709 default:
1710 return false;
1712 // A fragment operator must appear at the end.
1713 return I->get() + I->getSize() == E->get();
1714 case dwarf::DW_OP_stack_value: {
1715 // Must be the last one or followed by a DW_OP_LLVM_fragment.
1716 if (I->get() + I->getSize() == E->get())
1717 break;
1718 auto J = I;
1719 if ((++J)->getOp() != dwarf::DW_OP_LLVM_fragment)
1720 return false;
1721 break;
1722 }
1723 case dwarf::DW_OP_swap: {
1724 // Must be more than one implicit element on the stack.
1725
1726 // FIXME: A better way to implement this would be to add a local variable
1727 // that keeps track of the stack depth and introduce something like a
1728 // DW_LLVM_OP_implicit_location as a placeholder for the location this
1729 // DIExpression is attached to, or else pass the number of implicit stack
1730 // elements into isValid.
1731 if (getNumElements() == 1)
1732 return false;
1733 break;
1734 }
1736 // An entry value operator must appear at the beginning or immediately
1737 // following `DW_OP_LLVM_arg 0`, and the number of operations it cover can
1738 // currently only be 1, because we support only entry values of a simple
1739 // register location. One reason for this is that we currently can't
1740 // calculate the size of the resulting DWARF block for other expressions.
1741 auto FirstOp = expr_op_begin();
1742 if (FirstOp->getOp() == dwarf::DW_OP_LLVM_arg && FirstOp->getArg(0) == 0)
1743 ++FirstOp;
1744 return I->get() == FirstOp->get() && I->getArg(0) == 1;
1745 }
1752 case dwarf::DW_OP_constu:
1753 case dwarf::DW_OP_plus_uconst:
1754 case dwarf::DW_OP_plus:
1755 case dwarf::DW_OP_minus:
1756 case dwarf::DW_OP_mul:
1757 case dwarf::DW_OP_div:
1758 case dwarf::DW_OP_mod:
1759 case dwarf::DW_OP_or:
1760 case dwarf::DW_OP_and:
1761 case dwarf::DW_OP_xor:
1762 case dwarf::DW_OP_shl:
1763 case dwarf::DW_OP_shr:
1764 case dwarf::DW_OP_shra:
1765 case dwarf::DW_OP_deref:
1766 case dwarf::DW_OP_deref_size:
1767 case dwarf::DW_OP_xderef:
1768 case dwarf::DW_OP_lit0:
1769 case dwarf::DW_OP_not:
1770 case dwarf::DW_OP_dup:
1771 case dwarf::DW_OP_regx:
1772 case dwarf::DW_OP_bregx:
1773 case dwarf::DW_OP_push_object_address:
1774 case dwarf::DW_OP_over:
1775 case dwarf::DW_OP_rot:
1776 case dwarf::DW_OP_consts:
1777 case dwarf::DW_OP_eq:
1778 case dwarf::DW_OP_ne:
1779 case dwarf::DW_OP_gt:
1780 case dwarf::DW_OP_ge:
1781 case dwarf::DW_OP_lt:
1782 case dwarf::DW_OP_le:
1783 case dwarf::DW_OP_neg:
1784 case dwarf::DW_OP_abs:
1785 break;
1786 }
1787 }
1788 return true;
1789}
1790
1792 if (!isValid())
1793 return false;
1794
1795 if (getNumElements() == 0)
1796 return false;
1797
1798 for (const auto &It : expr_ops()) {
1799 switch (It.getOp()) {
1800 default:
1801 break;
1802 case dwarf::DW_OP_stack_value:
1803 return true;
1804 }
1805 }
1806
1807 return false;
1808}
1809
1811 if (!isValid())
1812 return false;
1813
1814 if (getNumElements() == 0)
1815 return false;
1816
1817 // If there are any elements other than fragment or tag_offset, then some
1818 // kind of complex computation occurs.
1819 for (const auto &It : expr_ops()) {
1820 switch (It.getOp()) {
1824 continue;
1825 default:
1826 return true;
1827 }
1828 }
1829
1830 return false;
1831}
1832
1834 if (!isValid())
1835 return false;
1836
1837 if (getNumElements() == 0)
1838 return true;
1839
1840 auto ExprOpBegin = expr_ops().begin();
1841 auto ExprOpEnd = expr_ops().end();
1842 if (ExprOpBegin->getOp() == dwarf::DW_OP_LLVM_arg) {
1843 if (ExprOpBegin->getArg(0) != 0)
1844 return false;
1845 ++ExprOpBegin;
1846 }
1847
1848 return !std::any_of(ExprOpBegin, ExprOpEnd, [](auto Op) {
1849 return Op.getOp() == dwarf::DW_OP_LLVM_arg;
1850 });
1851}
1852
1853std::optional<ArrayRef<uint64_t>>
1855 // Check for `isValid` covered by `isSingleLocationExpression`.
1857 return std::nullopt;
1858
1859 // An empty expression is already non-variadic.
1860 if (!getNumElements())
1861 return ArrayRef<uint64_t>();
1862
1863 // If Expr does not have a leading DW_OP_LLVM_arg then we don't need to do
1864 // anything.
1866 return getElements().drop_front(2);
1867 return getElements();
1868}
1869
1870const DIExpression *
1872 SmallVector<uint64_t, 3> UndefOps;
1873 if (auto FragmentInfo = Expr->getFragmentInfo()) {
1874 UndefOps.append({dwarf::DW_OP_LLVM_fragment, FragmentInfo->OffsetInBits,
1875 FragmentInfo->SizeInBits});
1876 }
1877 return DIExpression::get(Expr->getContext(), UndefOps);
1878}
1879
1880const DIExpression *
1882 if (any_of(Expr->expr_ops(), [](auto ExprOp) {
1883 return ExprOp.getOp() == dwarf::DW_OP_LLVM_arg;
1884 }))
1885 return Expr;
1886 SmallVector<uint64_t> NewOps;
1887 NewOps.reserve(Expr->getNumElements() + 2);
1888 NewOps.append({dwarf::DW_OP_LLVM_arg, 0});
1889 NewOps.append(Expr->elements_begin(), Expr->elements_end());
1890 return DIExpression::get(Expr->getContext(), NewOps);
1891}
1892
1893std::optional<const DIExpression *>
1895 if (!Expr)
1896 return std::nullopt;
1897
1898 if (auto Elts = Expr->getSingleLocationExpressionElements())
1899 return DIExpression::get(Expr->getContext(), *Elts);
1900
1901 return std::nullopt;
1902}
1903
1905 const DIExpression *Expr,
1906 bool IsIndirect) {
1907 // If Expr is not already variadic, insert the implied `DW_OP_LLVM_arg 0`
1908 // to the existing expression ops.
1909 if (none_of(Expr->expr_ops(), [](auto ExprOp) {
1910 return ExprOp.getOp() == dwarf::DW_OP_LLVM_arg;
1911 }))
1912 Ops.append({dwarf::DW_OP_LLVM_arg, 0});
1913 // If Expr is not indirect, we only need to insert the expression elements and
1914 // we're done.
1915 if (!IsIndirect) {
1916 Ops.append(Expr->elements_begin(), Expr->elements_end());
1917 return;
1918 }
1919 // If Expr is indirect, insert the implied DW_OP_deref at the end of the
1920 // expression but before DW_OP_{stack_value, LLVM_fragment} if they are
1921 // present.
1922 for (auto Op : Expr->expr_ops()) {
1923 if (Op.getOp() == dwarf::DW_OP_stack_value ||
1924 Op.getOp() == dwarf::DW_OP_LLVM_fragment) {
1925 Ops.push_back(dwarf::DW_OP_deref);
1926 IsIndirect = false;
1927 }
1928 Op.appendToVector(Ops);
1929 }
1930 if (IsIndirect)
1931 Ops.push_back(dwarf::DW_OP_deref);
1932}
1933
1934bool DIExpression::isEqualExpression(const DIExpression *FirstExpr,
1935 bool FirstIndirect,
1936 const DIExpression *SecondExpr,
1937 bool SecondIndirect) {
1938 SmallVector<uint64_t> FirstOps;
1939 DIExpression::canonicalizeExpressionOps(FirstOps, FirstExpr, FirstIndirect);
1940 SmallVector<uint64_t> SecondOps;
1941 DIExpression::canonicalizeExpressionOps(SecondOps, SecondExpr,
1942 SecondIndirect);
1943 return FirstOps == SecondOps;
1944}
1945
1946std::optional<DIExpression::FragmentInfo>
1948 for (auto I = Start; I != End; ++I)
1949 if (I->getOp() == dwarf::DW_OP_LLVM_fragment) {
1950 DIExpression::FragmentInfo Info = {I->getArg(1), I->getArg(0)};
1951 return Info;
1952 }
1953 return std::nullopt;
1954}
1955
1956std::optional<uint64_t> DIExpression::getActiveBits(DIVariable *Var) {
1957 std::optional<uint64_t> InitialActiveBits = Var->getSizeInBits();
1958 std::optional<uint64_t> ActiveBits = InitialActiveBits;
1959 for (auto Op : expr_ops()) {
1960 switch (Op.getOp()) {
1961 default:
1962 // We assume the worst case for anything we don't currently handle and
1963 // revert to the initial active bits.
1964 ActiveBits = InitialActiveBits;
1965 break;
1968 // We can't handle an extract whose sign doesn't match that of the
1969 // variable.
1970 std::optional<DIBasicType::Signedness> VarSign = Var->getSignedness();
1971 bool VarSigned = (VarSign == DIBasicType::Signedness::Signed);
1972 bool OpSigned = (Op.getOp() == dwarf::DW_OP_LLVM_extract_bits_sext);
1973 if (!VarSign || VarSigned != OpSigned) {
1974 ActiveBits = InitialActiveBits;
1975 break;
1976 }
1977 [[fallthrough]];
1978 }
1980 // Extract or fragment narrows the active bits
1981 if (ActiveBits)
1982 ActiveBits = std::min(*ActiveBits, Op.getArg(1));
1983 else
1984 ActiveBits = Op.getArg(1);
1985 break;
1986 }
1987 }
1988 return ActiveBits;
1989}
1990
1992 int64_t Offset) {
1993 if (Offset > 0) {
1994 Ops.push_back(dwarf::DW_OP_plus_uconst);
1995 Ops.push_back(Offset);
1996 } else if (Offset < 0) {
1997 Ops.push_back(dwarf::DW_OP_constu);
1998 // Avoid UB when encountering LLONG_MIN, because in 2's complement
1999 // abs(LLONG_MIN) is LLONG_MAX+1.
2000 uint64_t AbsMinusOne = -(Offset+1);
2001 Ops.push_back(AbsMinusOne + 1);
2002 Ops.push_back(dwarf::DW_OP_minus);
2003 }
2004}
2005
2007 auto SingleLocEltsOpt = getSingleLocationExpressionElements();
2008 if (!SingleLocEltsOpt)
2009 return false;
2010 auto SingleLocElts = *SingleLocEltsOpt;
2011
2012 if (SingleLocElts.size() == 0) {
2013 Offset = 0;
2014 return true;
2015 }
2016
2017 if (SingleLocElts.size() == 2 &&
2018 SingleLocElts[0] == dwarf::DW_OP_plus_uconst) {
2019 Offset = SingleLocElts[1];
2020 return true;
2021 }
2022
2023 if (SingleLocElts.size() == 3 && SingleLocElts[0] == dwarf::DW_OP_constu) {
2024 if (SingleLocElts[2] == dwarf::DW_OP_plus) {
2025 Offset = SingleLocElts[1];
2026 return true;
2027 }
2028 if (SingleLocElts[2] == dwarf::DW_OP_minus) {
2029 Offset = -SingleLocElts[1];
2030 return true;
2031 }
2032 }
2033
2034 return false;
2035}
2036
2038 int64_t &OffsetInBytes, SmallVectorImpl<uint64_t> &RemainingOps) const {
2039 OffsetInBytes = 0;
2040 RemainingOps.clear();
2041
2042 auto SingleLocEltsOpt = getSingleLocationExpressionElements();
2043 if (!SingleLocEltsOpt)
2044 return false;
2045
2046 auto ExprOpEnd = expr_op_iterator(SingleLocEltsOpt->end());
2047 auto ExprOpIt = expr_op_iterator(SingleLocEltsOpt->begin());
2048 while (ExprOpIt != ExprOpEnd) {
2049 uint64_t Op = ExprOpIt->getOp();
2050 if (Op == dwarf::DW_OP_deref || Op == dwarf::DW_OP_deref_size ||
2051 Op == dwarf::DW_OP_deref_type || Op == dwarf::DW_OP_LLVM_fragment ||
2054 break;
2055 } else if (Op == dwarf::DW_OP_plus_uconst) {
2056 OffsetInBytes += ExprOpIt->getArg(0);
2057 } else if (Op == dwarf::DW_OP_constu) {
2058 uint64_t Value = ExprOpIt->getArg(0);
2059 ++ExprOpIt;
2060 if (ExprOpIt->getOp() == dwarf::DW_OP_plus)
2061 OffsetInBytes += Value;
2062 else if (ExprOpIt->getOp() == dwarf::DW_OP_minus)
2063 OffsetInBytes -= Value;
2064 else
2065 return false;
2066 } else {
2067 // Not a const plus/minus operation or deref.
2068 return false;
2069 }
2070 ++ExprOpIt;
2071 }
2072 RemainingOps.append(ExprOpIt.getBase(), ExprOpEnd.getBase());
2073 return true;
2074}
2075
2078 for (auto ExprOp : expr_ops())
2079 if (ExprOp.getOp() == dwarf::DW_OP_LLVM_arg)
2080 SeenOps.insert(ExprOp.getArg(0));
2081 for (uint64_t Idx = 0; Idx < N; ++Idx)
2082 if (!SeenOps.contains(Idx))
2083 return false;
2084 return true;
2085}
2086
2087const DIExpression *DIExpression::extractAddressClass(const DIExpression *Expr,
2088 unsigned &AddrClass) {
2089 // FIXME: This seems fragile. Nothing that verifies that these elements
2090 // actually map to ops and not operands.
2091 auto SingleLocEltsOpt = Expr->getSingleLocationExpressionElements();
2092 if (!SingleLocEltsOpt)
2093 return nullptr;
2094 auto SingleLocElts = *SingleLocEltsOpt;
2095
2096 const unsigned PatternSize = 4;
2097 if (SingleLocElts.size() >= PatternSize &&
2098 SingleLocElts[PatternSize - 4] == dwarf::DW_OP_constu &&
2099 SingleLocElts[PatternSize - 2] == dwarf::DW_OP_swap &&
2100 SingleLocElts[PatternSize - 1] == dwarf::DW_OP_xderef) {
2101 AddrClass = SingleLocElts[PatternSize - 3];
2102
2103 if (SingleLocElts.size() == PatternSize)
2104 return nullptr;
2105 return DIExpression::get(
2106 Expr->getContext(),
2107 ArrayRef(&*SingleLocElts.begin(), SingleLocElts.size() - PatternSize));
2108 }
2109 return Expr;
2110}
2111
2112DIExpression *DIExpression::prepend(const DIExpression *Expr, uint8_t Flags,
2113 int64_t Offset) {
2115 if (Flags & DIExpression::DerefBefore)
2116 Ops.push_back(dwarf::DW_OP_deref);
2117
2119 if (Flags & DIExpression::DerefAfter)
2120 Ops.push_back(dwarf::DW_OP_deref);
2121
2122 bool StackValue = Flags & DIExpression::StackValue;
2123 bool EntryValue = Flags & DIExpression::EntryValue;
2124
2125 return prependOpcodes(Expr, Ops, StackValue, EntryValue);
2126}
2127
2128DIExpression *DIExpression::appendOpsToArg(const DIExpression *Expr,
2130 unsigned ArgNo, bool StackValue) {
2131 assert(Expr && "Can't add ops to this expression");
2132
2133 // Handle non-variadic intrinsics by prepending the opcodes.
2134 if (!any_of(Expr->expr_ops(),
2135 [](auto Op) { return Op.getOp() == dwarf::DW_OP_LLVM_arg; })) {
2136 assert(ArgNo == 0 &&
2137 "Location Index must be 0 for a non-variadic expression.");
2139 return DIExpression::prependOpcodes(Expr, NewOps, StackValue);
2140 }
2141
2143 for (auto Op : Expr->expr_ops()) {
2144 // A DW_OP_stack_value comes at the end, but before a DW_OP_LLVM_fragment.
2145 if (StackValue) {
2146 if (Op.getOp() == dwarf::DW_OP_stack_value)
2147 StackValue = false;
2148 else if (Op.getOp() == dwarf::DW_OP_LLVM_fragment) {
2149 NewOps.push_back(dwarf::DW_OP_stack_value);
2150 StackValue = false;
2151 }
2152 }
2153 Op.appendToVector(NewOps);
2154 if (Op.getOp() == dwarf::DW_OP_LLVM_arg && Op.getArg(0) == ArgNo)
2155 llvm::append_range(NewOps, Ops);
2156 }
2157 if (StackValue)
2158 NewOps.push_back(dwarf::DW_OP_stack_value);
2159
2160 return DIExpression::get(Expr->getContext(), NewOps);
2161}
2162
2163DIExpression *DIExpression::replaceArg(const DIExpression *Expr,
2164 uint64_t OldArg, uint64_t NewArg) {
2165 assert(Expr && "Can't replace args in this expression");
2166
2168
2169 for (auto Op : Expr->expr_ops()) {
2170 if (Op.getOp() != dwarf::DW_OP_LLVM_arg || Op.getArg(0) < OldArg) {
2171 Op.appendToVector(NewOps);
2172 continue;
2173 }
2175 uint64_t Arg = Op.getArg(0) == OldArg ? NewArg : Op.getArg(0);
2176 // OldArg has been deleted from the Op list, so decrement all indices
2177 // greater than it.
2178 if (Arg > OldArg)
2179 --Arg;
2180 NewOps.push_back(Arg);
2181 }
2182 return DIExpression::get(Expr->getContext(), NewOps);
2183}
2184
2185DIExpression *DIExpression::prependOpcodes(const DIExpression *Expr,
2187 bool StackValue, bool EntryValue) {
2188 assert(Expr && "Can't prepend ops to this expression");
2189
2190 if (EntryValue) {
2192 // Use a block size of 1 for the target register operand. The
2193 // DWARF backend currently cannot emit entry values with a block
2194 // size > 1.
2195 Ops.push_back(1);
2196 }
2197
2198 // If there are no ops to prepend, do not even add the DW_OP_stack_value.
2199 if (Ops.empty())
2200 StackValue = false;
2201 for (auto Op : Expr->expr_ops()) {
2202 // A DW_OP_stack_value comes at the end, but before a DW_OP_LLVM_fragment.
2203 if (StackValue) {
2204 if (Op.getOp() == dwarf::DW_OP_stack_value)
2205 StackValue = false;
2206 else if (Op.getOp() == dwarf::DW_OP_LLVM_fragment) {
2207 Ops.push_back(dwarf::DW_OP_stack_value);
2208 StackValue = false;
2209 }
2210 }
2211 Op.appendToVector(Ops);
2212 }
2213 if (StackValue)
2214 Ops.push_back(dwarf::DW_OP_stack_value);
2215 return DIExpression::get(Expr->getContext(), Ops);
2216}
2217
2218DIExpression *DIExpression::append(const DIExpression *Expr,
2220 assert(Expr && !Ops.empty() && "Can't append ops to this expression");
2221
2222 // Copy Expr's current op list.
2224 for (auto Op : Expr->expr_ops()) {
2225 // Append new opcodes before DW_OP_{stack_value, LLVM_fragment}.
2226 if (Op.getOp() == dwarf::DW_OP_stack_value ||
2227 Op.getOp() == dwarf::DW_OP_LLVM_fragment) {
2228 NewOps.append(Ops.begin(), Ops.end());
2229
2230 // Ensure that the new opcodes are only appended once.
2231 Ops = {};
2232 }
2233 Op.appendToVector(NewOps);
2234 }
2235 NewOps.append(Ops.begin(), Ops.end());
2236 auto *result =
2237 DIExpression::get(Expr->getContext(), NewOps)->foldConstantMath();
2238 assert(result->isValid() && "concatenated expression is not valid");
2239 return result;
2240}
2241
2242DIExpression *DIExpression::appendToStack(const DIExpression *Expr,
2244 assert(Expr && !Ops.empty() && "Can't append ops to this expression");
2245 assert(std::none_of(expr_op_iterator(Ops.begin()),
2246 expr_op_iterator(Ops.end()),
2247 [](auto Op) {
2248 return Op.getOp() == dwarf::DW_OP_stack_value ||
2249 Op.getOp() == dwarf::DW_OP_LLVM_fragment;
2250 }) &&
2251 "Can't append this op");
2252
2253 // Append a DW_OP_deref after Expr's current op list if it's non-empty and
2254 // has no DW_OP_stack_value.
2255 //
2256 // Match .* DW_OP_stack_value (DW_OP_LLVM_fragment A B)?.
2257 std::optional<FragmentInfo> FI = Expr->getFragmentInfo();
2258 unsigned DropUntilStackValue = FI ? 3 : 0;
2259 ArrayRef<uint64_t> ExprOpsBeforeFragment =
2260 Expr->getElements().drop_back(DropUntilStackValue);
2261 bool NeedsDeref = (Expr->getNumElements() > DropUntilStackValue) &&
2262 (ExprOpsBeforeFragment.back() != dwarf::DW_OP_stack_value);
2263 bool NeedsStackValue = NeedsDeref || ExprOpsBeforeFragment.empty();
2264
2265 // Append a DW_OP_deref after Expr's current op list if needed, then append
2266 // the new ops, and finally ensure that a single DW_OP_stack_value is present.
2268 if (NeedsDeref)
2269 NewOps.push_back(dwarf::DW_OP_deref);
2270 NewOps.append(Ops.begin(), Ops.end());
2271 if (NeedsStackValue)
2272 NewOps.push_back(dwarf::DW_OP_stack_value);
2273 return DIExpression::append(Expr, NewOps);
2274}
2275
2276std::optional<DIExpression *> DIExpression::createFragmentExpression(
2277 const DIExpression *Expr, unsigned OffsetInBits, unsigned SizeInBits) {
2279 // Track whether it's safe to split the value at the top of the DWARF stack,
2280 // assuming that it'll be used as an implicit location value.
2281 bool CanSplitValue = true;
2282 // Track whether we need to add a fragment expression to the end of Expr.
2283 bool EmitFragment = true;
2284 // Copy over the expression, but leave off any trailing DW_OP_LLVM_fragment.
2285 if (Expr) {
2286 for (auto Op : Expr->expr_ops()) {
2287 switch (Op.getOp()) {
2288 default:
2289 break;
2290 case dwarf::DW_OP_shr:
2291 case dwarf::DW_OP_shra:
2292 case dwarf::DW_OP_shl:
2293 case dwarf::DW_OP_plus:
2294 case dwarf::DW_OP_plus_uconst:
2295 case dwarf::DW_OP_minus:
2296 // We can't safely split arithmetic or shift operations into multiple
2297 // fragments because we can't express carry-over between fragments.
2298 //
2299 // FIXME: We *could* preserve the lowest fragment of a constant offset
2300 // operation if the offset fits into SizeInBits.
2301 CanSplitValue = false;
2302 break;
2303 case dwarf::DW_OP_deref:
2304 case dwarf::DW_OP_deref_size:
2305 case dwarf::DW_OP_deref_type:
2306 case dwarf::DW_OP_xderef:
2307 case dwarf::DW_OP_xderef_size:
2308 case dwarf::DW_OP_xderef_type:
2309 // Preceeding arithmetic operations have been applied to compute an
2310 // address. It's okay to split the value loaded from that address.
2311 CanSplitValue = true;
2312 break;
2313 case dwarf::DW_OP_stack_value:
2314 // Bail if this expression computes a value that cannot be split.
2315 if (!CanSplitValue)
2316 return std::nullopt;
2317 break;
2319 // If we've decided we don't need a fragment then give up if we see that
2320 // there's already a fragment expression.
2321 // FIXME: We could probably do better here
2322 if (!EmitFragment)
2323 return std::nullopt;
2324 // Make the new offset point into the existing fragment.
2325 uint64_t FragmentOffsetInBits = Op.getArg(0);
2326 uint64_t FragmentSizeInBits = Op.getArg(1);
2327 (void)FragmentSizeInBits;
2328 assert((OffsetInBits + SizeInBits <= FragmentSizeInBits) &&
2329 "new fragment outside of original fragment");
2330 OffsetInBits += FragmentOffsetInBits;
2331 continue;
2332 }
2335 // If we're extracting bits from inside of the fragment that we're
2336 // creating then we don't have a fragment after all, and just need to
2337 // adjust the offset that we're extracting from.
2338 uint64_t ExtractOffsetInBits = Op.getArg(0);
2339 uint64_t ExtractSizeInBits = Op.getArg(1);
2340 if (ExtractOffsetInBits >= OffsetInBits &&
2341 ExtractOffsetInBits + ExtractSizeInBits <=
2342 OffsetInBits + SizeInBits) {
2343 Ops.push_back(Op.getOp());
2344 Ops.push_back(ExtractOffsetInBits - OffsetInBits);
2345 Ops.push_back(ExtractSizeInBits);
2346 EmitFragment = false;
2347 continue;
2348 }
2349 // If the extracted bits aren't fully contained within the fragment then
2350 // give up.
2351 // FIXME: We could probably do better here
2352 return std::nullopt;
2353 }
2354 }
2355 Op.appendToVector(Ops);
2356 }
2357 }
2358 assert((!Expr->isImplicit() || CanSplitValue) && "Expr can't be split");
2359 assert(Expr && "Unknown DIExpression");
2360 if (EmitFragment) {
2362 Ops.push_back(OffsetInBits);
2363 Ops.push_back(SizeInBits);
2364 }
2365 return DIExpression::get(Expr->getContext(), Ops);
2366}
2367
2368/// See declaration for more info.
2370 const DataLayout &DL, const Value *SliceStart, uint64_t SliceOffsetInBits,
2371 uint64_t SliceSizeInBits, const Value *DbgPtr, int64_t DbgPtrOffsetInBits,
2372 int64_t DbgExtractOffsetInBits, DIExpression::FragmentInfo VarFrag,
2373 std::optional<DIExpression::FragmentInfo> &Result,
2374 int64_t &OffsetFromLocationInBits) {
2375
2376 if (VarFrag.SizeInBits == 0)
2377 return false; // Variable size is unknown.
2378
2379 // Difference between mem slice start and the dbg location start.
2380 // 0 4 8 12 16 ...
2381 // | |
2382 // dbg location start
2383 // |
2384 // mem slice start
2385 // Here MemStartRelToDbgStartInBits is 8. Note this can be negative.
2386 int64_t MemStartRelToDbgStartInBits;
2387 {
2388 auto MemOffsetFromDbgInBytes = SliceStart->getPointerOffsetFrom(DbgPtr, DL);
2389 if (!MemOffsetFromDbgInBytes)
2390 return false; // Can't calculate difference in addresses.
2391 // Difference between the pointers.
2392 MemStartRelToDbgStartInBits = *MemOffsetFromDbgInBytes * 8;
2393 // Add the difference of the offsets.
2394 MemStartRelToDbgStartInBits +=
2395 SliceOffsetInBits - (DbgPtrOffsetInBits + DbgExtractOffsetInBits);
2396 }
2397
2398 // Out-param. Invert offset to get offset from debug location.
2399 OffsetFromLocationInBits = -MemStartRelToDbgStartInBits;
2400
2401 // Check if the variable fragment sits outside (before) this memory slice.
2402 int64_t MemEndRelToDbgStart = MemStartRelToDbgStartInBits + SliceSizeInBits;
2403 if (MemEndRelToDbgStart < 0) {
2404 Result = {0, 0}; // Out-param.
2405 return true;
2406 }
2407
2408 // Work towards creating SliceOfVariable which is the bits of the variable
2409 // that the memory region covers.
2410 // 0 4 8 12 16 ...
2411 // | |
2412 // dbg location start with VarFrag offset=32
2413 // |
2414 // mem slice start: SliceOfVariable offset=40
2415 int64_t MemStartRelToVarInBits =
2416 MemStartRelToDbgStartInBits + VarFrag.OffsetInBits;
2417 int64_t MemEndRelToVarInBits = MemStartRelToVarInBits + SliceSizeInBits;
2418 // If the memory region starts before the debug location the fragment
2419 // offset would be negative, which we can't encode. Limit those to 0. This
2420 // is fine because those bits necessarily don't overlap with the existing
2421 // variable fragment.
2422 int64_t MemFragStart = std::max<int64_t>(0, MemStartRelToVarInBits);
2423 int64_t MemFragSize =
2424 std::max<int64_t>(0, MemEndRelToVarInBits - MemFragStart);
2425 DIExpression::FragmentInfo SliceOfVariable(MemFragSize, MemFragStart);
2426
2427 // Intersect the memory region fragment with the variable location fragment.
2428 DIExpression::FragmentInfo TrimmedSliceOfVariable =
2429 DIExpression::FragmentInfo::intersect(SliceOfVariable, VarFrag);
2430 if (TrimmedSliceOfVariable == VarFrag)
2431 Result = std::nullopt; // Out-param.
2432 else
2433 Result = TrimmedSliceOfVariable; // Out-param.
2434 return true;
2435}
2436
2437std::pair<DIExpression *, const ConstantInt *>
2439 // Copy the APInt so we can modify it.
2440 APInt NewInt = CI->getValue();
2442
2443 // Fold operators only at the beginning of the expression.
2444 bool First = true;
2445 bool Changed = false;
2446 for (auto Op : expr_ops()) {
2447 switch (Op.getOp()) {
2448 default:
2449 // We fold only the leading part of the expression; if we get to a part
2450 // that we're going to copy unchanged, and haven't done any folding,
2451 // then the entire expression is unchanged and we can return early.
2452 if (!Changed)
2453 return {this, CI};
2454 First = false;
2455 break;
2457 if (!First)
2458 break;
2459 Changed = true;
2460 if (Op.getArg(1) == dwarf::DW_ATE_signed)
2461 NewInt = NewInt.sextOrTrunc(Op.getArg(0));
2462 else {
2463 assert(Op.getArg(1) == dwarf::DW_ATE_unsigned && "Unexpected operand");
2464 NewInt = NewInt.zextOrTrunc(Op.getArg(0));
2465 }
2466 continue;
2467 }
2468 Op.appendToVector(Ops);
2469 }
2470 if (!Changed)
2471 return {this, CI};
2472 return {DIExpression::get(getContext(), Ops),
2473 ConstantInt::get(getContext(), NewInt)};
2474}
2475
2477 uint64_t Result = 0;
2478 for (auto ExprOp : expr_ops())
2479 if (ExprOp.getOp() == dwarf::DW_OP_LLVM_arg)
2480 Result = std::max(Result, ExprOp.getArg(0) + 1);
2481 assert(hasAllLocationOps(Result) &&
2482 "Expression is missing one or more location operands.");
2483 return Result;
2484}
2485
2486std::optional<DIExpression::SignedOrUnsignedConstant>
2488
2489 // Recognize signed and unsigned constants.
2490 // An signed constants can be represented as DW_OP_consts C DW_OP_stack_value
2491 // (DW_OP_LLVM_fragment of Len).
2492 // An unsigned constant can be represented as
2493 // DW_OP_constu C DW_OP_stack_value (DW_OP_LLVM_fragment of Len).
2494
2495 if ((getNumElements() != 2 && getNumElements() != 3 &&
2496 getNumElements() != 6) ||
2497 (getElement(0) != dwarf::DW_OP_consts &&
2498 getElement(0) != dwarf::DW_OP_constu))
2499 return std::nullopt;
2500
2501 if (getNumElements() == 2 && getElement(0) == dwarf::DW_OP_consts)
2503
2504 if ((getNumElements() == 3 && getElement(2) != dwarf::DW_OP_stack_value) ||
2505 (getNumElements() == 6 && (getElement(2) != dwarf::DW_OP_stack_value ||
2507 return std::nullopt;
2508 return getElement(0) == dwarf::DW_OP_constu
2511}
2512
2513DIExpression::ExtOps DIExpression::getExtOps(unsigned FromSize, unsigned ToSize,
2514 bool Signed) {
2515 dwarf::TypeKind TK = Signed ? dwarf::DW_ATE_signed : dwarf::DW_ATE_unsigned;
2517 dwarf::DW_OP_LLVM_convert, ToSize, TK}};
2518 return Ops;
2519}
2520
2521DIExpression *DIExpression::appendExt(const DIExpression *Expr,
2522 unsigned FromSize, unsigned ToSize,
2523 bool Signed) {
2524 return appendToStack(Expr, getExtOps(FromSize, ToSize, Signed));
2525}
2526
2528DIGlobalVariableExpression::getImpl(LLVMContext &Context, Metadata *Variable,
2530 bool ShouldCreate) {
2532 Metadata *Ops[] = {Variable, Expression};
2534}
2535DIObjCProperty::DIObjCProperty(LLVMContext &C, StorageType Storage,
2536 unsigned Line, unsigned Attributes,
2538 : DINode(C, DIObjCPropertyKind, Storage, dwarf::DW_TAG_APPLE_property, Ops),
2540
2541DIObjCProperty *DIObjCProperty::getImpl(
2542 LLVMContext &Context, MDString *Name, Metadata *File, unsigned Line,
2543 MDString *GetterName, MDString *SetterName, unsigned Attributes,
2544 Metadata *Type, StorageType Storage, bool ShouldCreate) {
2545 assert(isCanonical(Name) && "Expected canonical MDString");
2546 assert(isCanonical(GetterName) && "Expected canonical MDString");
2547 assert(isCanonical(SetterName) && "Expected canonical MDString");
2548 DEFINE_GETIMPL_LOOKUP(DIObjCProperty, (Name, File, Line, GetterName,
2549 SetterName, Attributes, Type));
2551 DEFINE_GETIMPL_STORE(DIObjCProperty, (Line, Attributes), Ops);
2552}
2553
2554DIImportedEntity *DIImportedEntity::getImpl(LLVMContext &Context, unsigned Tag,
2555 Metadata *Scope, Metadata *Entity,
2556 Metadata *File, unsigned Line,
2557 MDString *Name, Metadata *Elements,
2558 StorageType Storage,
2559 bool ShouldCreate) {
2560 assert(isCanonical(Name) && "Expected canonical MDString");
2561 DEFINE_GETIMPL_LOOKUP(DIImportedEntity,
2562 (Tag, Scope, Entity, File, Line, Name, Elements));
2564 DEFINE_GETIMPL_STORE(DIImportedEntity, (Tag, Line), Ops);
2565}
2566
2567DIMacro *DIMacro::getImpl(LLVMContext &Context, unsigned MIType, unsigned Line,
2568 MDString *Name, MDString *Value, StorageType Storage,
2569 bool ShouldCreate) {
2570 assert(isCanonical(Name) && "Expected canonical MDString");
2572 Metadata *Ops[] = {Name, Value};
2573 DEFINE_GETIMPL_STORE(DIMacro, (MIType, Line), Ops);
2574}
2575
2576DIMacroFile *DIMacroFile::getImpl(LLVMContext &Context, unsigned MIType,
2577 unsigned Line, Metadata *File,
2578 Metadata *Elements, StorageType Storage,
2579 bool ShouldCreate) {
2580 DEFINE_GETIMPL_LOOKUP(DIMacroFile, (MIType, Line, File, Elements));
2581 Metadata *Ops[] = {File, Elements};
2582 DEFINE_GETIMPL_STORE(DIMacroFile, (MIType, Line), Ops);
2583}
2584
2585DIArgList *DIArgList::get(LLVMContext &Context,
2587 auto ExistingIt = Context.pImpl->DIArgLists.find_as(DIArgListKeyInfo(Args));
2588 if (ExistingIt != Context.pImpl->DIArgLists.end())
2589 return *ExistingIt;
2590 DIArgList *NewArgList = new DIArgList(Context, Args);
2591 Context.pImpl->DIArgLists.insert(NewArgList);
2592 return NewArgList;
2593}
2594
2596 ValueAsMetadata **OldVMPtr = static_cast<ValueAsMetadata **>(Ref);
2597 assert((!New || isa<ValueAsMetadata>(New)) &&
2598 "DIArgList must be passed a ValueAsMetadata");
2599 untrack();
2600 // We need to update the set storage once the Args are updated since they
2601 // form the key to the DIArgLists store.
2602 getContext().pImpl->DIArgLists.erase(this);
2604 for (ValueAsMetadata *&VM : Args) {
2605 if (&VM == OldVMPtr) {
2606 if (NewVM)
2607 VM = NewVM;
2608 else
2609 VM = ValueAsMetadata::get(PoisonValue::get(VM->getValue()->getType()));
2610 }
2611 }
2612 // We've changed the contents of this DIArgList, and the set storage may
2613 // already contain a DIArgList with our new set of args; if it does, then we
2614 // must RAUW this with the existing DIArgList, otherwise we simply insert this
2615 // back into the set storage.
2616 DIArgList *ExistingArgList = getUniqued(getContext().pImpl->DIArgLists, this);
2617 if (ExistingArgList) {
2618 replaceAllUsesWith(ExistingArgList);
2619 // Clear this here so we don't try to untrack in the destructor.
2620 Args.clear();
2621 delete this;
2622 return;
2623 }
2624 getContext().pImpl->DIArgLists.insert(this);
2625 track();
2626}
2627void DIArgList::track() {
2628 for (ValueAsMetadata *&VAM : Args)
2629 if (VAM)
2630 MetadataTracking::track(&VAM, *VAM, *this);
2631}
2632void DIArgList::untrack() {
2633 for (ValueAsMetadata *&VAM : Args)
2634 if (VAM)
2635 MetadataTracking::untrack(&VAM, *VAM);
2636}
2637void DIArgList::dropAllReferences(bool Untrack) {
2638 if (Untrack)
2639 untrack();
2640 Args.clear();
2641 ReplaceableMetadataImpl::resolveAllUses(/* ResolveUsers */ false);
2642}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
constexpr LLT S1
AMDGPU Kernel Attributes
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static cl::opt< ITMode > IT(cl::desc("IT block support"), cl::Hidden, cl::init(DefaultIT), cl::values(clEnumValN(DefaultIT, "arm-default-it", "Generate any type of IT block"), clEnumValN(RestrictedIT, "arm-restrict-it", "Disallow complex IT blocks")))
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
#define LLVM_ABI
Definition Compiler.h:213
static const char * ChecksumKindName[DIFile::CSK_Last]
#define DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(CLASS, OPS)
static void adjustColumn(unsigned &Column)
#define DEFINE_GETIMPL_STORE_N(CLASS, ARGS, OPS, NUM_OPS)
static std::pair< DIScope *, LineColumn > getNearestMatchingScope(const DILocation *L1, const DILocation *L2)
static LineColumn getLocalScopeLocationOr(DIScope *S, LineColumn Default)
Returns the location of DILocalScope, if present, or a default value.
std::pair< unsigned, unsigned > LineColumn
static bool isCanonical(const MDString *S)
#define DEFINE_GETIMPL_STORE(CLASS, ARGS, OPS)
#define DEFINE_GETIMPL_LOOKUP(CLASS, ARGS)
#define DEFINE_GETIMPL_STORE_NO_OPS(CLASS, ARGS)
static DILexicalBlockBase * cloneAndReplaceParentScope(DILexicalBlockBase *LBB, DIScope *NewParent)
static RegisterPass< DebugifyFunctionPass > DF("debugify-function", "Attach debug info to a function")
static unsigned encodingBits(unsigned C)
static unsigned encodeComponent(unsigned C)
static unsigned getNextComponentInDiscriminator(unsigned D)
Returns the next component stored in discriminator.
static unsigned getUnsignedFromPrefixEncoding(unsigned U)
Reverse transformation as getPrefixEncodingFromUnsigned.
@ Default
This file contains constants used for implementing Dwarf debug support.
const AbstractManglingParser< Derived, Alloc >::OperatorInfo AbstractManglingParser< Derived, Alloc >::Ops[]
#define F(x, y, z)
Definition MD5.cpp:55
#define I(x, y, z)
Definition MD5.cpp:58
static DebugLoc getDebugLoc(MachineBasicBlock::instr_iterator FirstMI, MachineBasicBlock::instr_iterator LastMI)
Return the first found DebugLoc that has a DILocation, given a range of instructions.
#define T
BaseType
A given derived pointer can have multiple base pointers through phi/selects.
This file implements a set that has insertion order iteration characteristics.
This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...
Class for arbitrary precision integers.
Definition APInt.h:78
LLVM_ABI APInt zextOrTrunc(unsigned width) const
Zero extend or truncate to width.
Definition APInt.cpp:1033
LLVM_ABI APInt sextOrTrunc(unsigned width) const
Sign extend or truncate to width.
Definition APInt.cpp:1041
Annotations lets you mark points and ranges inside source code, for tests:
Definition Annotations.h:53
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition ArrayRef.h:41
const T & back() const
back - Get the last element.
Definition ArrayRef.h:156
ArrayRef< T > drop_front(size_t N=1) const
Drop the first N elements of the array.
Definition ArrayRef.h:200
size_t size() const
size - Get the array size.
Definition ArrayRef.h:147
ArrayRef< T > drop_back(size_t N=1) const
Drop the last N elements of the array.
Definition ArrayRef.h:206
bool empty() const
empty - Check if the array is empty.
Definition ArrayRef.h:142
static ConstantAsMetadata * get(Constant *C)
Definition Metadata.h:536
This is the shared class of boolean and integer constants.
Definition Constants.h:87
static ConstantInt * getSigned(IntegerType *Ty, int64_t V)
Return a ConstantInt with the specified value for the specified type.
Definition Constants.h:131
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition Constants.h:154
This is an important base class in LLVM.
Definition Constant.h:43
LLVM_ABI void handleChangedOperand(void *Ref, Metadata *New)
static LLVM_ABI DIArgList * get(LLVMContext &Context, ArrayRef< ValueAsMetadata * > Args)
static DIBasicType * getImpl(LLVMContext &Context, unsigned Tag, StringRef Name, uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding, uint32_t NumExtraInhabitants, uint32_t DataSizeInBits, DIFlags Flags, StorageType Storage, bool ShouldCreate=true)
unsigned StringRef uint64_t FlagZero unsigned StringRef uint64_t uint32_t unsigned DIFlags Flags
DIBasicType(LLVMContext &C, StorageType Storage, unsigned Tag, uint32_t AlignInBits, unsigned Encoding, uint32_t NumExtraInhabitants, uint32_t DataSizeInBits, DIFlags Flags, ArrayRef< Metadata * > Ops)
unsigned StringRef uint64_t SizeInBits
LLVM_ABI std::optional< Signedness > getSignedness() const
Return the signedness of this type, or std::nullopt if this type is neither signed nor unsigned.
unsigned getEncoding() const
unsigned StringRef uint64_t FlagZero unsigned StringRef uint64_t uint32_t unsigned DIFlags Flags unsigned StringRef uint64_t uint32_t unsigned uint32_t NumExtraInhabitants
unsigned StringRef Name
unsigned StringRef uint64_t FlagZero unsigned StringRef uint64_t uint32_t AlignInBits
Debug common block.
Metadata Metadata * Decl
Metadata Metadata MDString Metadata unsigned LineNo
Metadata Metadata MDString * Name
Metadata Metadata MDString Metadata * File
static LLVM_ABI const char * nameTableKindString(DebugNameTableKind PK)
static LLVM_ABI const char * emissionKindString(DebugEmissionKind EK)
DISourceLanguageName Metadata MDString bool MDString unsigned MDString unsigned Metadata Metadata Metadata Metadata Metadata uint64_t bool bool unsigned bool MDString * SysRoot
DISourceLanguageName Metadata MDString bool MDString * Flags
DISourceLanguageName Metadata MDString bool MDString unsigned MDString unsigned Metadata Metadata Metadata Metadata Metadata uint64_t bool bool unsigned bool MDString MDString * SDK
DISourceLanguageName Metadata MDString bool MDString unsigned MDString unsigned Metadata Metadata Metadata * GlobalVariables
DebugEmissionKind getEmissionKind() const
DISourceLanguageName Metadata MDString bool MDString unsigned MDString unsigned Metadata * EnumTypes
DISourceLanguageName Metadata MDString * Producer
DISourceLanguageName Metadata MDString bool MDString unsigned MDString unsigned Metadata Metadata * RetainedTypes
DISourceLanguageName Metadata MDString bool MDString unsigned MDString * SplitDebugFilename
DISourceLanguageName Metadata MDString bool MDString unsigned MDString unsigned Metadata Metadata Metadata Metadata * ImportedEntities
DISourceLanguageName Metadata MDString bool MDString unsigned MDString unsigned Metadata Metadata Metadata Metadata Metadata * Macros
DebugNameTableKind getNameTableKind() const
DISourceLanguageName Metadata * File
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t AlignInBits
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned std::optional< uint32_t > EnumKind
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned std::optional< uint32_t > Metadata Metadata MDString Metadata Metadata * DataLocation
static LLVM_ABI DICompositeType * buildODRType(LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name, Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, Metadata *SizeInBits, uint32_t AlignInBits, Metadata *OffsetInBits, Metadata *Specification, uint32_t NumExtraInhabitants, DIFlags Flags, Metadata *Elements, unsigned RuntimeLang, std::optional< uint32_t > EnumKind, Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator, Metadata *DataLocation, Metadata *Associated, Metadata *Allocated, Metadata *Rank, Metadata *Annotations, Metadata *BitStride)
Build a DICompositeType with the given ODR identifier.
unsigned MDString Metadata unsigned Line
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata * Elements
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned RuntimeLang
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned std::optional< uint32_t > Metadata Metadata MDString Metadata Metadata Metadata Metadata Metadata Metadata * Annotations
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned std::optional< uint32_t > Metadata Metadata MDString * Identifier
static LLVM_ABI DICompositeType * getODRTypeIfExists(LLVMContext &Context, MDString &Identifier)
unsigned MDString * Name
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned std::optional< uint32_t > Metadata Metadata MDString Metadata * Discriminator
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned std::optional< uint32_t > Metadata Metadata * TemplateParams
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t OffsetInBits
unsigned MDString Metadata unsigned Metadata * Scope
unsigned MDString Metadata * File
unsigned MDString Metadata unsigned Metadata Metadata * BaseType
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Flags
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned std::optional< uint32_t > Metadata Metadata MDString Metadata Metadata Metadata Metadata * Allocated
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned std::optional< uint32_t > Metadata Metadata MDString Metadata Metadata Metadata Metadata Metadata Metadata Metadata * Specification
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned std::optional< uint32_t > Metadata * VTableHolder
unsigned MDString Metadata unsigned Metadata Metadata uint64_t SizeInBits
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned std::optional< uint32_t > Metadata Metadata MDString Metadata Metadata Metadata * Associated
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned std::optional< uint32_t > Metadata Metadata MDString Metadata Metadata Metadata Metadata Metadata Metadata Metadata uint32_t NumExtraInhabitants
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned std::optional< uint32_t > Metadata Metadata MDString Metadata Metadata Metadata Metadata Metadata * Rank
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned std::optional< uint32_t > Metadata Metadata MDString Metadata Metadata Metadata Metadata Metadata Metadata Metadata uint32_t Metadata * BitStride
unsigned StringRef DIFile unsigned DIScope DIType Metadata uint32_t Metadata * OffsetInBits
unsigned StringRef DIFile unsigned DIScope DIType Metadata uint32_t AlignInBits
unsigned StringRef DIFile unsigned DIScope DIType Metadata uint32_t Metadata std::optional< unsigned > std::optional< PtrAuthData > PtrAuthData
Metadata * getExtraData() const
Get extra data associated with this derived type.
unsigned StringRef DIFile * File
unsigned StringRef DIFile unsigned DIScope DIType Metadata uint32_t Metadata std::optional< unsigned > DWARFAddressSpace
LLVM_ABI DIType * getClassType() const
Get casted version of extra data.
LLVM_ABI Constant * getConstant() const
unsigned StringRef DIFile unsigned DIScope DIType Metadata * SizeInBits
LLVM_ABI Constant * getStorageOffsetInBits() const
LLVM_ABI Constant * getDiscriminantValue() const
unsigned StringRef Name
LLVM_ABI uint32_t getVBPtrOffset() const
Enumeration value.
int64_t bool MDString * Name
LLVM_ABI unsigned getSize() const
Return the size of the operand.
uint64_t getOp() const
Get the operand code.
An iterator for expression operands.
DWARF expression.
element_iterator elements_end() const
LLVM_ABI bool isEntryValue() const
Check if the expression consists of exactly one entry value operand.
iterator_range< expr_op_iterator > expr_ops() const
static LLVM_ABI DIExpression * append(const DIExpression *Expr, ArrayRef< uint64_t > Ops)
Append the opcodes Ops to DIExpr.
std::array< uint64_t, 6 > ExtOps
unsigned getNumElements() const
static LLVM_ABI ExtOps getExtOps(unsigned FromSize, unsigned ToSize, bool Signed)
Returns the ops for a zero- or sign-extension in a DIExpression.
expr_op_iterator expr_op_begin() const
Visit the elements via ExprOperand wrappers.
LLVM_ABI bool extractIfOffset(int64_t &Offset) const
If this is a constant offset, extract it.
static LLVM_ABI void appendOffset(SmallVectorImpl< uint64_t > &Ops, int64_t Offset)
Append Ops with operations to apply the Offset.
DbgVariableFragmentInfo FragmentInfo
LLVM_ABI bool startsWithDeref() const
Return whether the first element a DW_OP_deref.
static LLVM_ABI bool isEqualExpression(const DIExpression *FirstExpr, bool FirstIndirect, const DIExpression *SecondExpr, bool SecondIndirect)
Determines whether two debug values should produce equivalent DWARF expressions, using their DIExpres...
expr_op_iterator expr_op_end() const
LLVM_ABI bool isImplicit() const
Return whether this is an implicit location description.
static LLVM_ABI bool calculateFragmentIntersect(const DataLayout &DL, const Value *SliceStart, uint64_t SliceOffsetInBits, uint64_t SliceSizeInBits, const Value *DbgPtr, int64_t DbgPtrOffsetInBits, int64_t DbgExtractOffsetInBits, DIExpression::FragmentInfo VarFrag, std::optional< DIExpression::FragmentInfo > &Result, int64_t &OffsetFromLocationInBits)
Computes a fragment, bit-extract operation if needed, and new constant offset to describe a part of a...
element_iterator elements_begin() const
LLVM_ABI bool hasAllLocationOps(unsigned N) const
Returns true iff this DIExpression contains at least one instance of DW_OP_LLVM_arg,...
std::optional< FragmentInfo > getFragmentInfo() const
Retrieve the details of this fragment expression.
static LLVM_ABI DIExpression * appendOpsToArg(const DIExpression *Expr, ArrayRef< uint64_t > Ops, unsigned ArgNo, bool StackValue=false)
Create a copy of Expr by appending the given list of Ops to each instance of the operand DW_OP_LLVM_a...
LLVM_ABI bool isComplex() const
Return whether the location is computed on the expression stack, meaning it cannot be a simple regist...
static LLVM_ABI std::optional< FragmentInfo > getFragmentInfo(expr_op_iterator Start, expr_op_iterator End)
Retrieve the details of this fragment expression.
static LLVM_ABI std::optional< const DIExpression * > convertToNonVariadicExpression(const DIExpression *Expr)
If Expr is a valid single-location expression, i.e.
LLVM_ABI std::pair< DIExpression *, const ConstantInt * > constantFold(const ConstantInt *CI)
Try to shorten an expression with an initial constant operand.
LLVM_ABI bool isDeref() const
Return whether there is exactly one operator and it is a DW_OP_deref;.
static LLVM_ABI const DIExpression * convertToVariadicExpression(const DIExpression *Expr)
If Expr is a non-variadic expression (i.e.
LLVM_ABI uint64_t getNumLocationOperands() const
Return the number of unique location operands referred to (via DW_OP_LLVM_arg) in this expression; th...
ArrayRef< uint64_t > getElements() const
static LLVM_ABI DIExpression * replaceArg(const DIExpression *Expr, uint64_t OldArg, uint64_t NewArg)
Create a copy of Expr with each instance of DW_OP_LLVM_arg, \p OldArg replaced with DW_OP_LLVM_arg,...
LLVM_ABI std::optional< uint64_t > getActiveBits(DIVariable *Var)
Return the number of bits that have an active value, i.e.
static LLVM_ABI void canonicalizeExpressionOps(SmallVectorImpl< uint64_t > &Ops, const DIExpression *Expr, bool IsIndirect)
Inserts the elements of Expr into Ops modified to a canonical form, which uses DW_OP_LLVM_arg (i....
uint64_t getElement(unsigned I) const
static LLVM_ABI std::optional< DIExpression * > createFragmentExpression(const DIExpression *Expr, unsigned OffsetInBits, unsigned SizeInBits)
Create a DIExpression to describe one part of an aggregate variable that is fragmented across multipl...
static LLVM_ABI const DIExpression * convertToUndefExpression(const DIExpression *Expr)
Removes all elements from Expr that do not apply to an undef debug value, which includes every operat...
static LLVM_ABI DIExpression * prepend(const DIExpression *Expr, uint8_t Flags, int64_t Offset=0)
Prepend DIExpr with a deref and offset operation and optionally turn it into a stack value or/and an ...
static LLVM_ABI DIExpression * appendToStack(const DIExpression *Expr, ArrayRef< uint64_t > Ops)
Convert DIExpr into a stack value if it isn't one already by appending DW_OP_deref if needed,...
static LLVM_ABI DIExpression * appendExt(const DIExpression *Expr, unsigned FromSize, unsigned ToSize, bool Signed)
Append a zero- or sign-extension to Expr.
LLVM_ABI std::optional< ArrayRef< uint64_t > > getSingleLocationExpressionElements() const
Returns a reference to the elements contained in this expression, skipping past the leading DW_OP_LLV...
LLVM_ABI bool isSingleLocationExpression() const
Return whether the evaluated expression makes use of a single location at the start of the expression...
LLVM_ABI bool extractLeadingOffset(int64_t &OffsetInBytes, SmallVectorImpl< uint64_t > &RemainingOps) const
Assuming that the expression operates on an address, extract a constant offset and the successive ops...
LLVM_ABI std::optional< SignedOrUnsignedConstant > isConstant() const
Determine whether this represents a constant value, if so.
LLVM_ABI bool isValid() const
static LLVM_ABI const DIExpression * extractAddressClass(const DIExpression *Expr, unsigned &AddrClass)
Checks if the last 4 elements of the expression are DW_OP_constu <DWARFAddress Space> DW_OP_swap DW_O...
static LLVM_ABI DIExpression * prependOpcodes(const DIExpression *Expr, SmallVectorImpl< uint64_t > &Ops, bool StackValue=false, bool EntryValue=false)
Prepend DIExpr with the given opcodes and optionally turn it into a stack value.
MDString MDString * Directory
MDString MDString std::optional< ChecksumInfo< MDString * > > MDString * Source
MDString * Filename
static LLVM_ABI std::optional< ChecksumKind > getChecksumKind(StringRef CSKindStr)
MDString MDString std::optional< ChecksumInfo< MDString * > > CS
unsigned StringRef uint64_t uint32_t unsigned DIFlags unsigned int Factor
static LLVM_ABI std::optional< FixedPointKind > getFixedPointKind(StringRef Str)
static LLVM_ABI const char * fixedPointKindString(FixedPointKind)
unsigned StringRef uint64_t uint32_t unsigned Encoding
unsigned StringRef uint64_t uint32_t AlignInBits
LLVM_ABI bool isSigned() const
@ FixedPointBinary
Scale factor 2^Factor.
@ FixedPointDecimal
Scale factor 10^Factor.
@ FixedPointRational
Arbitrary rational scale factor.
unsigned StringRef uint64_t uint32_t unsigned DIFlags unsigned int APInt Numerator
unsigned StringRef uint64_t uint32_t unsigned DIFlags unsigned int APInt APInt Denominator
unsigned StringRef uint64_t SizeInBits
Metadata * getRawLowerBound() const
Metadata * getRawCountNode() const
Metadata * getRawStride() const
LLVM_ABI BoundType getLowerBound() const
Metadata * getRawUpperBound() const
LLVM_ABI BoundType getCount() const
LLVM_ABI BoundType getUpperBound() const
PointerUnion< DIVariable *, DIExpression * > BoundType
LLVM_ABI BoundType getStride() const
A pair of DIGlobalVariable and DIExpression.
Metadata MDString MDString Metadata unsigned Metadata bool bool Metadata Metadata * TemplateParams
Metadata MDString MDString Metadata unsigned Line
Metadata MDString MDString Metadata unsigned Metadata * Type
Metadata MDString MDString Metadata unsigned Metadata bool bool Metadata Metadata uint32_t Metadata * Annotations
Metadata MDString * Name
Metadata MDString MDString Metadata unsigned Metadata bool bool Metadata * StaticDataMemberDeclaration
Metadata MDString MDString * LinkageName
Metadata MDString MDString Metadata * File
Metadata MDString MDString Metadata unsigned Metadata bool bool Metadata Metadata uint32_t AlignInBits
An imported module (C++ using directive or similar).
unsigned Metadata Metadata * Entity
unsigned Metadata Metadata Metadata unsigned Line
unsigned Metadata Metadata Metadata unsigned MDString * Name
unsigned Metadata Metadata Metadata * File
unsigned Metadata * Scope
Metadata MDString Metadata unsigned unsigned bool std::optional< unsigned > CoroSuspendIdx
Metadata MDString Metadata unsigned unsigned Column
Metadata MDString Metadata unsigned unsigned bool IsArtificial
Metadata MDString Metadata unsigned Line
Metadata MDString * Name
Metadata MDString Metadata * File
LLVM_ABI DILexicalBlockBase(LLVMContext &C, unsigned ID, StorageType Storage, ArrayRef< Metadata * > Ops)
Metadata Metadata unsigned Discriminator
Debug lexical block.
Metadata Metadata unsigned unsigned Column
Metadata Metadata * File
A scope for locals.
LLVM_ABI DISubprogram * getSubprogram() const
Get the subprogram for this scope.
LLVM_ABI DILocalScope * getNonLexicalBlockFileScope() const
Get the first non DILexicalBlockFile scope of this scope.
DILocalScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag, ArrayRef< Metadata * > Ops)
static LLVM_ABI DILocalScope * cloneScopeForSubprogram(DILocalScope &RootScope, DISubprogram &NewSP, LLVMContext &Ctx, DenseMap< const MDNode *, MDNode * > &Cache)
Traverses the scope chain rooted at RootScope until it hits a Subprogram, recreating the chain with "...
Metadata MDString Metadata unsigned Metadata * Type
Metadata MDString Metadata * File
Metadata MDString * Name
Metadata MDString Metadata unsigned Line
Metadata MDString Metadata unsigned Metadata unsigned DIFlags uint32_t Metadata * Annotations
Metadata MDString Metadata unsigned Metadata unsigned DIFlags uint32_t AlignInBits
unsigned unsigned DILocalScope * Scope
static LLVM_ABI DILocation * getMergedLocations(ArrayRef< DILocation * > Locs)
Try to combine the vector of locations passed as input in a single one.
static LLVM_ABI std::optional< unsigned > encodeDiscriminator(unsigned BD, unsigned DF, unsigned CI)
Raw encoding of the discriminator.
unsigned unsigned DILocalScope DILocation bool ImplicitCode
static LLVM_ABI void decodeDiscriminator(unsigned D, unsigned &BD, unsigned &DF, unsigned &CI)
Raw decoder for values in an encoded discriminator D.
static LLVM_ABI DILocation * getMergedLocation(DILocation *LocA, DILocation *LocB)
Attempts to merge LocA and LocB into a single location; see DebugLoc::getMergedLocation for more deta...
unsigned unsigned Column
unsigned unsigned DILocalScope DILocation * InlinedAt
unsigned unsigned Metadata * File
unsigned unsigned Line
unsigned unsigned Metadata Metadata * Elements
unsigned unsigned MDString MDString * Value
unsigned unsigned MDString * Name
unsigned unsigned Line
Represents a module in the programming language, for example, a Clang module, or a Fortran module.
Metadata Metadata * Scope
Metadata Metadata MDString * Name
Metadata Metadata MDString MDString MDString MDString * APINotesFile
Metadata Metadata MDString MDString MDString * IncludePath
Metadata Metadata MDString MDString * ConfigurationMacros
Metadata Metadata MDString MDString MDString MDString unsigned LineNo
Debug lexical block.
Metadata MDString bool ExportSymbols
Metadata MDString * Name
Tagged DWARF-like metadata node.
LLVM_ABI dwarf::Tag getTag() const
static LLVM_ABI DIFlags getFlag(StringRef Flag)
static LLVM_ABI DIFlags splitFlags(DIFlags Flags, SmallVectorImpl< DIFlags > &SplitFlags)
Split up a flags bitfield.
DINode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag, ArrayRef< Metadata * > Ops1, ArrayRef< Metadata * > Ops2={})
static LLVM_ABI StringRef getFlagString(DIFlags Flag)
DIFlags
Debug info flags.
MDString Metadata * File
MDString Metadata unsigned MDString MDString unsigned Metadata * Type
MDString Metadata unsigned MDString * GetterName
MDString Metadata unsigned MDString MDString * SetterName
Base class for scope-like contexts.
LLVM_ABI StringRef getName() const
DIFile * getFile() const
LLVM_ABI DIScope * getScope() const
DIScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag, ArrayRef< Metadata * > Ops)
Wrapper structure that holds a language name and its version.
String type, Fortran CHARACTER(n)
unsigned MDString * Name
unsigned MDString Metadata Metadata Metadata uint64_t SizeInBits
unsigned MDString Metadata Metadata Metadata uint64_t uint32_t AlignInBits
unsigned MDString Metadata Metadata Metadata * StringLocationExp
unsigned MDString Metadata Metadata * StringLengthExp
unsigned MDString Metadata Metadata Metadata uint64_t uint32_t unsigned Encoding
unsigned MDString Metadata * StringLength
Subprogram description. Uses SubclassData1.
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata Metadata Metadata Metadata Metadata Metadata MDString bool UsesKeyInstructions
Metadata MDString MDString Metadata unsigned Metadata unsigned ScopeLine
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags SPFlags
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata * ContainingType
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata Metadata * TemplateParams
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata Metadata Metadata * Declaration
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata Metadata Metadata Metadata Metadata Metadata MDString * TargetFuncName
static LLVM_ABI DISPFlags toSPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized, unsigned Virtuality=SPFlagNonvirtual, bool IsMainSubprogram=false)
Metadata MDString * Name
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata Metadata Metadata Metadata Metadata * ThrownTypes
static LLVM_ABI DISPFlags getFlag(StringRef Flag)
Metadata MDString MDString Metadata * File
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned VirtualIndex
static LLVM_ABI DISPFlags splitFlags(DISPFlags Flags, SmallVectorImpl< DISPFlags > &SplitFlags)
Split up a flags bitfield for easier printing.
static LLVM_ABI StringRef getFlagString(DISPFlags Flag)
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata Metadata Metadata Metadata * RetainedNodes
DISPFlags
Debug info subprogram flags.
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int ThisAdjustment
StringRef DIFile unsigned Line
StringRef DIFile unsigned DIScope uint64_t uint32_t DIFlags DIType Metadata Metadata * UpperBound
PointerUnion< ConstantInt *, DIVariable *, DIExpression * > BoundType
StringRef DIFile unsigned DIScope uint64_t uint32_t DIFlags DIType Metadata Metadata Metadata Metadata * Bias
StringRef DIFile unsigned DIScope uint64_t uint32_t DIFlags DIType Metadata Metadata Metadata * Stride
StringRef DIFile unsigned DIScope uint64_t SizeInBits
StringRef DIFile * File
StringRef DIFile unsigned DIScope uint64_t uint32_t AlignInBits
StringRef DIFile unsigned DIScope uint64_t uint32_t DIFlags DIType Metadata * LowerBound
StringRef DIFile unsigned DIScope uint64_t uint32_t DIFlags Flags
Array subrange.
LLVM_ABI BoundType getUpperBound() const
LLVM_ABI BoundType getStride() const
LLVM_ABI BoundType getLowerBound() const
LLVM_ABI BoundType getCount() const
Type array for a subprogram.
DIFlags uint8_t Metadata * TypeArray
Base class for template parameters.
unsigned MDString Metadata * Type
unsigned MDString Metadata bool Metadata * Value
Base class for types.
bool isBitField() const
bool isStaticMember() const
DIType(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag, unsigned Line, uint32_t AlignInBits, uint32_t NumExtraInhabitants, DIFlags Flags, ArrayRef< Metadata * > Ops)
LLVM_ABI uint32_t getAlignInBits() const
Base class for variables.
std::optional< DIBasicType::Signedness > getSignedness() const
Return the signedness of this variable's type, or std::nullopt if this type is neither signed nor uns...
LLVM_ABI std::optional< uint64_t > getSizeInBits() const
Determines the size of the variable's type.
Metadata * getRawType() const
LLVM_ABI DIVariable(LLVMContext &C, unsigned ID, StorageType Storage, signed Line, ArrayRef< Metadata * > Ops, uint32_t AlignInBits=0)
A parsed version of the target data layout string in and methods for querying it.
Definition DataLayout.h:63
Record of a variable value-assignment, aka a non instruction representation of the dbg....
LLVM_ABI DebugVariableAggregate(const DbgVariableRecord *DVR)
const DILocation * getInlinedAt() const
const DILocalVariable * getVariable() const
LLVM_ABI DebugVariable(const DbgVariableRecord *DVR)
iterator find(const_arg_type_t< KeyT > Val)
Definition DenseMap.h:178
std::pair< iterator, bool > try_emplace(KeyT &&Key, Ts &&...Args)
Definition DenseMap.h:248
iterator end()
Definition DenseMap.h:81
Class representing an expression and its matching format.
Generic tagged DWARF-like metadata node.
LLVM_ABI dwarf::Tag getTag() const
unsigned MDString * Header
unsigned MDString ArrayRef< Metadata * > DwarfOps
DenseSet< DIArgList *, DIArgListInfo > DIArgLists
This is an important class for using LLVM in a threaded context.
Definition LLVMContext.h:68
LLVMContextImpl *const pImpl
Definition LLVMContext.h:70
Metadata node.
Definition Metadata.h:1078
friend class DIAssignID
Definition Metadata.h:1081
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition Metadata.h:1577
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition Metadata.h:1569
LLVM_ABI TempMDNode clone() const
Create a (temporary) clone of this.
Definition Metadata.cpp:669
static T * storeImpl(T *N, StorageType Storage, StoreT &Store)
LLVMContext & getContext() const
Definition Metadata.h:1242
static std::enable_if_t< std::is_base_of< MDNode, T >::value, T * > replaceWithUniqued(std::unique_ptr< T, TempMDNodeDeleter > N)
Replace a temporary node with a uniqued one.
Definition Metadata.h:1317
A single uniqued string.
Definition Metadata.h:721
LLVM_ABI StringRef getString() const
Definition Metadata.cpp:618
static void untrack(Metadata *&MD)
Stop tracking a reference to metadata.
Definition Metadata.h:357
static bool track(Metadata *&MD)
Track the reference to metadata.
Definition Metadata.h:323
Root of the metadata hierarchy.
Definition Metadata.h:64
StorageType
Active type of storage.
Definition Metadata.h:72
unsigned short SubclassData16
Definition Metadata.h:78
unsigned SubclassData32
Definition Metadata.h:79
unsigned char Storage
Storage flag for non-uniqued, otherwise unowned, metadata.
Definition Metadata.h:75
unsigned char SubclassData1
Definition Metadata.h:77
Metadata(unsigned ID, StorageType Storage)
Definition Metadata.h:88
static LLVM_ABI PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
LLVM_ABI void replaceAllUsesWith(Metadata *MD)
Replace all uses of this with MD.
Definition Metadata.cpp:369
LLVMContext & getContext() const
Definition Metadata.h:408
LLVM_ABI void resolveAllUses(bool ResolveUsers=true)
Resolve all uses of this.
Definition Metadata.cpp:422
Implements a dense probed hash-table based set with some number of buckets stored inline.
Definition DenseSet.h:291
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
A SetVector that performs no allocations if smaller than a certain size.
Definition SetVector.h:338
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void reserve(size_type N)
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
Definition StringRef.h:55
constexpr bool empty() const
empty - Check if the string is empty.
Definition StringRef.h:143
A switch()-like statement whose cases are string literals.
StringSwitch & Case(StringLiteral S, T Value)
The instances of the Type class are immutable: once they are created, they are never changed.
Definition Type.h:45
static LLVM_ABI IntegerType * getInt64Ty(LLVMContext &C)
Definition Type.cpp:298
Value wrapper in the Metadata hierarchy.
Definition Metadata.h:458
static LLVM_ABI ValueAsMetadata * get(Value *V)
Definition Metadata.cpp:503
LLVM Value Representation.
Definition Value.h:75
LLVM_ABI std::optional< int64_t > getPointerOffsetFrom(const Value *Other, const DataLayout &DL) const
If this ptr is provably equal to Other plus a constant offset, return that offset in bytes.
Definition Value.cpp:1052
std::pair< iterator, bool > insert(const ValueT &V)
Definition DenseSet.h:202
bool contains(const_arg_type_t< ValueT > V) const
Check if the set contains the given element.
Definition DenseSet.h:175
Changed
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
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
initializer< Ty > init(const Ty &Val)
Calculates the starting offsets for various sections within the .debug_names section.
Definition Dwarf.h:35
@ DW_OP_LLVM_entry_value
Only used in LLVM metadata.
Definition Dwarf.h:147
@ DW_OP_LLVM_implicit_pointer
Only used in LLVM metadata.
Definition Dwarf.h:148
@ DW_OP_LLVM_extract_bits_zext
Only used in LLVM metadata.
Definition Dwarf.h:151
@ DW_OP_LLVM_tag_offset
Only used in LLVM metadata.
Definition Dwarf.h:146
@ DW_OP_LLVM_fragment
Only used in LLVM metadata.
Definition Dwarf.h:144
@ DW_OP_LLVM_arg
Only used in LLVM metadata.
Definition Dwarf.h:149
@ DW_OP_LLVM_convert
Only used in LLVM metadata.
Definition Dwarf.h:145
@ DW_OP_LLVM_extract_bits_sext
Only used in LLVM metadata.
Definition Dwarf.h:150
@ DW_VIRTUALITY_max
Definition Dwarf.h:200
@ NameTableKind
Definition LLToken.h:504
This is an optimization pass for GlobalISel generic memory operations.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
Definition STLExtras.h:316
@ Offset
Definition DWP.cpp:477
static T * getUniqued(DenseSet< T *, InfoT > &Store, const typename InfoT::KeyTy &Key)
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:643
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
Definition STLExtras.h:2136
auto cast_or_null(const Y &Val)
Definition Casting.h:714
auto dyn_cast_or_null(const Y &Val)
Definition Casting.h:753
LLVM_ABI cl::opt< bool > EnableFSDiscriminator
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
Definition STLExtras.h:1732
auto reverse(ContainerTy &&C)
Definition STLExtras.h:406
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
Definition STLExtras.h:1739
FunctionAddr VTableAddr Count
Definition InstrProf.h:139
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
Definition Casting.h:547
LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key
@ Ref
The access may reference the value stored in memory.
Definition ModRef.h:32
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
Definition ModRef.h:71
DWARFExpression::Operation Op
ArrayRef(const T &OneElt) -> ArrayRef< T >
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:559
LLVM_ABI cl::opt< bool > PickMergedSourceLocations("pick-merged-source-locations", cl::init(false), cl::Hidden, cl::desc("Preserve line and column number when merging locations."))
Implement std::hash so that hash_code can be used in STL containers.
Definition BitVector.h:867
#define N
SmallPtrSet< DIScope *, 8 > Scopes
void insert(DIScope *S, LineColumn Loc)
DIScope * match(DIScope *S, LineColumn Loc)
void insert(DIScope *S, LineColumn Loc)
DIScope * match(DIScope *S, LineColumn Loc)
SmallMapVector< std::pair< DIFile *, LineColumn >, SmallSetVector< DIScope *, 8 >, 8 > Scopes
A single checksum, represented by a Kind and a Value (a string).
static DbgVariableFragmentInfo intersect(DbgVariableFragmentInfo A, DbgVariableFragmentInfo B)
Returns a zero-sized fragment if A and B don't intersect.
A MapVector that performs no allocations if smaller than a certain size.
Definition MapVector.h:257