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 | |
13 | #include "llvm/IR/DebugInfoMetadata.h" |
14 | #include "LLVMContextImpl.h" |
15 | #include "MetadataImpl.h" |
16 | #include "llvm/ADT/SmallPtrSet.h" |
17 | #include "llvm/ADT/StringSwitch.h" |
18 | #include "llvm/BinaryFormat/Dwarf.h" |
19 | #include "llvm/IR/DebugProgramInstruction.h" |
20 | #include "llvm/IR/Function.h" |
21 | #include "llvm/IR/IntrinsicInst.h" |
22 | #include "llvm/IR/Type.h" |
23 | #include "llvm/IR/Value.h" |
24 | |
25 | #include <numeric> |
26 | #include <optional> |
27 | |
28 | using namespace llvm; |
29 | |
30 | namespace llvm { |
31 | // Use FS-AFDO discriminator. |
32 | cl::opt<bool> EnableFSDiscriminator( |
33 | "enable-fs-discriminator" , cl::Hidden, |
34 | cl::desc("Enable adding flow sensitive discriminators" )); |
35 | } // namespace llvm |
36 | |
37 | uint32_t DIType::getAlignInBits() const { |
38 | return (getTag() == dwarf::DW_TAG_LLVM_ptrauth_type ? 0 : SubclassData32); |
39 | } |
40 | |
41 | const DIExpression::FragmentInfo DebugVariable::DefaultFragment = { |
42 | std::numeric_limits<uint64_t>::max(), std::numeric_limits<uint64_t>::min()}; |
43 | |
44 | DebugVariable::DebugVariable(const DbgVariableIntrinsic *DII) |
45 | : Variable(DII->getVariable()), |
46 | Fragment(DII->getExpression()->getFragmentInfo()), |
47 | InlinedAt(DII->getDebugLoc().getInlinedAt()) {} |
48 | |
49 | DebugVariable::DebugVariable(const DbgVariableRecord *DVR) |
50 | : Variable(DVR->getVariable()), |
51 | Fragment(DVR->getExpression()->getFragmentInfo()), |
52 | InlinedAt(DVR->getDebugLoc().getInlinedAt()) {} |
53 | |
54 | DebugVariableAggregate::DebugVariableAggregate(const DbgVariableIntrinsic *DVI) |
55 | : DebugVariable(DVI->getVariable(), std::nullopt, |
56 | DVI->getDebugLoc()->getInlinedAt()) {} |
57 | |
58 | DILocation::DILocation(LLVMContext &C, StorageType Storage, unsigned Line, |
59 | unsigned Column, ArrayRef<Metadata *> MDs, |
60 | bool ImplicitCode) |
61 | : MDNode(C, DILocationKind, Storage, MDs) { |
62 | assert((MDs.size() == 1 || MDs.size() == 2) && |
63 | "Expected a scope and optional inlined-at" ); |
64 | |
65 | // Set line and column. |
66 | assert(Column < (1u << 16) && "Expected 16-bit column" ); |
67 | |
68 | SubclassData32 = Line; |
69 | SubclassData16 = Column; |
70 | |
71 | setImplicitCode(ImplicitCode); |
72 | } |
73 | |
74 | static void adjustColumn(unsigned &Column) { |
75 | // Set to unknown on overflow. We only have 16 bits to play with here. |
76 | if (Column >= (1u << 16)) |
77 | Column = 0; |
78 | } |
79 | |
80 | DILocation *DILocation::getImpl(LLVMContext &Context, unsigned Line, |
81 | unsigned Column, Metadata *Scope, |
82 | Metadata *InlinedAt, bool ImplicitCode, |
83 | StorageType Storage, bool ShouldCreate) { |
84 | // Fixup column. |
85 | adjustColumn(Column); |
86 | |
87 | if (Storage == Uniqued) { |
88 | if (auto *N = getUniqued(Store&: Context.pImpl->DILocations, |
89 | Key: DILocationInfo::KeyTy(Line, Column, Scope, |
90 | InlinedAt, ImplicitCode))) |
91 | return N; |
92 | if (!ShouldCreate) |
93 | return nullptr; |
94 | } else { |
95 | assert(ShouldCreate && "Expected non-uniqued nodes to always be created" ); |
96 | } |
97 | |
98 | SmallVector<Metadata *, 2> Ops; |
99 | Ops.push_back(Elt: Scope); |
100 | if (InlinedAt) |
101 | Ops.push_back(Elt: InlinedAt); |
102 | return storeImpl(N: new (Ops.size(), Storage) DILocation( |
103 | Context, Storage, Line, Column, Ops, ImplicitCode), |
104 | Storage, Store&: Context.pImpl->DILocations); |
105 | } |
106 | |
107 | DILocation *DILocation::getMergedLocations(ArrayRef<DILocation *> Locs) { |
108 | if (Locs.empty()) |
109 | return nullptr; |
110 | if (Locs.size() == 1) |
111 | return Locs[0]; |
112 | auto *Merged = Locs[0]; |
113 | for (DILocation *L : llvm::drop_begin(RangeOrContainer&: Locs)) { |
114 | Merged = getMergedLocation(LocA: Merged, LocB: L); |
115 | if (Merged == nullptr) |
116 | break; |
117 | } |
118 | return Merged; |
119 | } |
120 | |
121 | DILocation *DILocation::getMergedLocation(DILocation *LocA, DILocation *LocB) { |
122 | if (!LocA || !LocB) |
123 | return nullptr; |
124 | |
125 | if (LocA == LocB) |
126 | return LocA; |
127 | |
128 | LLVMContext &C = LocA->getContext(); |
129 | |
130 | using LocVec = SmallVector<const DILocation *>; |
131 | LocVec ALocs; |
132 | LocVec BLocs; |
133 | SmallDenseMap<std::pair<const DISubprogram *, const DILocation *>, unsigned, |
134 | 4> |
135 | ALookup; |
136 | |
137 | // Walk through LocA and its inlined-at locations, populate them in ALocs and |
138 | // save the index for the subprogram and inlined-at pair, which we use to find |
139 | // a matching starting location in LocB's chain. |
140 | for (auto [L, I] = std::make_pair(x&: LocA, y: 0U); L; L = L->getInlinedAt(), I++) { |
141 | ALocs.push_back(Elt: L); |
142 | auto Res = ALookup.try_emplace( |
143 | Key: {L->getScope()->getSubprogram(), L->getInlinedAt()}, Args&: I); |
144 | assert(Res.second && "Multiple <SP, InlinedAt> pairs in a location chain?" ); |
145 | (void)Res; |
146 | } |
147 | |
148 | LocVec::reverse_iterator ARIt = ALocs.rend(); |
149 | LocVec::reverse_iterator BRIt = BLocs.rend(); |
150 | |
151 | // Populate BLocs and look for a matching starting location, the first |
152 | // location with the same subprogram and inlined-at location as in LocA's |
153 | // chain. Since the two locations have the same inlined-at location we do |
154 | // not need to look at those parts of the chains. |
155 | for (auto [L, I] = std::make_pair(x&: LocB, y: 0U); L; L = L->getInlinedAt(), I++) { |
156 | BLocs.push_back(Elt: L); |
157 | |
158 | if (ARIt != ALocs.rend()) |
159 | // We have already found a matching starting location. |
160 | continue; |
161 | |
162 | auto IT = ALookup.find(Val: {L->getScope()->getSubprogram(), L->getInlinedAt()}); |
163 | if (IT == ALookup.end()) |
164 | continue; |
165 | |
166 | // The + 1 is to account for the &*rev_it = &(it - 1) relationship. |
167 | ARIt = LocVec::reverse_iterator(ALocs.begin() + IT->second + 1); |
168 | BRIt = LocVec::reverse_iterator(BLocs.begin() + I + 1); |
169 | |
170 | // If we have found a matching starting location we do not need to add more |
171 | // locations to BLocs, since we will only look at location pairs preceding |
172 | // the matching starting location, and adding more elements to BLocs could |
173 | // invalidate the iterator that we initialized here. |
174 | break; |
175 | } |
176 | |
177 | // Merge the two locations if possible, using the supplied |
178 | // inlined-at location for the created location. |
179 | auto MergeLocPair = [&C](const DILocation *L1, const DILocation *L2, |
180 | DILocation *InlinedAt) -> DILocation * { |
181 | if (L1 == L2) |
182 | return DILocation::get(Context&: C, Line: L1->getLine(), Column: L1->getColumn(), Scope: L1->getScope(), |
183 | InlinedAt); |
184 | |
185 | // If the locations originate from different subprograms we can't produce |
186 | // a common location. |
187 | if (L1->getScope()->getSubprogram() != L2->getScope()->getSubprogram()) |
188 | return nullptr; |
189 | |
190 | // Return the nearest common scope inside a subprogram. |
191 | auto GetNearestCommonScope = [](DIScope *S1, DIScope *S2) -> DIScope * { |
192 | SmallPtrSet<DIScope *, 8> Scopes; |
193 | for (; S1; S1 = S1->getScope()) { |
194 | Scopes.insert(Ptr: S1); |
195 | if (isa<DISubprogram>(Val: S1)) |
196 | break; |
197 | } |
198 | |
199 | for (; S2; S2 = S2->getScope()) { |
200 | if (Scopes.count(Ptr: S2)) |
201 | return S2; |
202 | if (isa<DISubprogram>(Val: S2)) |
203 | break; |
204 | } |
205 | |
206 | return nullptr; |
207 | }; |
208 | |
209 | auto Scope = GetNearestCommonScope(L1->getScope(), L2->getScope()); |
210 | assert(Scope && "No common scope in the same subprogram?" ); |
211 | |
212 | bool SameLine = L1->getLine() == L2->getLine(); |
213 | bool SameCol = L1->getColumn() == L2->getColumn(); |
214 | unsigned Line = SameLine ? L1->getLine() : 0; |
215 | unsigned Col = SameLine && SameCol ? L1->getColumn() : 0; |
216 | |
217 | return DILocation::get(Context&: C, Line, Column: Col, Scope, InlinedAt); |
218 | }; |
219 | |
220 | DILocation *Result = ARIt != ALocs.rend() ? (*ARIt)->getInlinedAt() : nullptr; |
221 | |
222 | // If we have found a common starting location, walk up the inlined-at chains |
223 | // and try to produce common locations. |
224 | for (; ARIt != ALocs.rend() && BRIt != BLocs.rend(); ++ARIt, ++BRIt) { |
225 | DILocation *Tmp = MergeLocPair(*ARIt, *BRIt, Result); |
226 | |
227 | if (!Tmp) |
228 | // We have walked up to a point in the chains where the two locations |
229 | // are irreconsilable. At this point Result contains the nearest common |
230 | // location in the inlined-at chains of LocA and LocB, so we break here. |
231 | break; |
232 | |
233 | Result = Tmp; |
234 | } |
235 | |
236 | if (Result) |
237 | return Result; |
238 | |
239 | // We ended up with LocA and LocB as irreconsilable locations. Produce a |
240 | // location at 0:0 with one of the locations' scope. The function has |
241 | // historically picked A's scope, and a nullptr inlined-at location, so that |
242 | // behavior is mimicked here but I am not sure if this is always the correct |
243 | // way to handle this. |
244 | return DILocation::get(Context&: C, Line: 0, Column: 0, Scope: LocA->getScope(), InlinedAt: nullptr); |
245 | } |
246 | |
247 | std::optional<unsigned> |
248 | DILocation::encodeDiscriminator(unsigned BD, unsigned DF, unsigned CI) { |
249 | std::array<unsigned, 3> Components = {BD, DF, CI}; |
250 | uint64_t RemainingWork = 0U; |
251 | // We use RemainingWork to figure out if we have no remaining components to |
252 | // encode. For example: if BD != 0 but DF == 0 && CI == 0, we don't need to |
253 | // encode anything for the latter 2. |
254 | // Since any of the input components is at most 32 bits, their sum will be |
255 | // less than 34 bits, and thus RemainingWork won't overflow. |
256 | RemainingWork = |
257 | std::accumulate(first: Components.begin(), last: Components.end(), init: RemainingWork); |
258 | |
259 | int I = 0; |
260 | unsigned Ret = 0; |
261 | unsigned NextBitInsertionIndex = 0; |
262 | while (RemainingWork > 0) { |
263 | unsigned C = Components[I++]; |
264 | RemainingWork -= C; |
265 | unsigned EC = encodeComponent(C); |
266 | Ret |= (EC << NextBitInsertionIndex); |
267 | NextBitInsertionIndex += encodingBits(C); |
268 | } |
269 | |
270 | // Encoding may be unsuccessful because of overflow. We determine success by |
271 | // checking equivalence of components before & after encoding. Alternatively, |
272 | // we could determine Success during encoding, but the current alternative is |
273 | // simpler. |
274 | unsigned TBD, TDF, TCI = 0; |
275 | decodeDiscriminator(D: Ret, BD&: TBD, DF&: TDF, CI&: TCI); |
276 | if (TBD == BD && TDF == DF && TCI == CI) |
277 | return Ret; |
278 | return std::nullopt; |
279 | } |
280 | |
281 | void DILocation::decodeDiscriminator(unsigned D, unsigned &BD, unsigned &DF, |
282 | unsigned &CI) { |
283 | BD = getUnsignedFromPrefixEncoding(U: D); |
284 | DF = getUnsignedFromPrefixEncoding(U: getNextComponentInDiscriminator(D)); |
285 | CI = getUnsignedFromPrefixEncoding( |
286 | U: getNextComponentInDiscriminator(D: getNextComponentInDiscriminator(D))); |
287 | } |
288 | dwarf::Tag DINode::getTag() const { return (dwarf::Tag)SubclassData16; } |
289 | |
290 | DINode::DIFlags DINode::getFlag(StringRef Flag) { |
291 | return StringSwitch<DIFlags>(Flag) |
292 | #define HANDLE_DI_FLAG(ID, NAME) .Case("DIFlag" #NAME, Flag##NAME) |
293 | #include "llvm/IR/DebugInfoFlags.def" |
294 | .Default(Value: DINode::FlagZero); |
295 | } |
296 | |
297 | StringRef DINode::getFlagString(DIFlags Flag) { |
298 | switch (Flag) { |
299 | #define HANDLE_DI_FLAG(ID, NAME) \ |
300 | case Flag##NAME: \ |
301 | return "DIFlag" #NAME; |
302 | #include "llvm/IR/DebugInfoFlags.def" |
303 | } |
304 | return "" ; |
305 | } |
306 | |
307 | DINode::DIFlags DINode::splitFlags(DIFlags Flags, |
308 | SmallVectorImpl<DIFlags> &SplitFlags) { |
309 | // Flags that are packed together need to be specially handled, so |
310 | // that, for example, we emit "DIFlagPublic" and not |
311 | // "DIFlagPrivate | DIFlagProtected". |
312 | if (DIFlags A = Flags & FlagAccessibility) { |
313 | if (A == FlagPrivate) |
314 | SplitFlags.push_back(Elt: FlagPrivate); |
315 | else if (A == FlagProtected) |
316 | SplitFlags.push_back(Elt: FlagProtected); |
317 | else |
318 | SplitFlags.push_back(Elt: FlagPublic); |
319 | Flags &= ~A; |
320 | } |
321 | if (DIFlags R = Flags & FlagPtrToMemberRep) { |
322 | if (R == FlagSingleInheritance) |
323 | SplitFlags.push_back(Elt: FlagSingleInheritance); |
324 | else if (R == FlagMultipleInheritance) |
325 | SplitFlags.push_back(Elt: FlagMultipleInheritance); |
326 | else |
327 | SplitFlags.push_back(Elt: FlagVirtualInheritance); |
328 | Flags &= ~R; |
329 | } |
330 | if ((Flags & FlagIndirectVirtualBase) == FlagIndirectVirtualBase) { |
331 | Flags &= ~FlagIndirectVirtualBase; |
332 | SplitFlags.push_back(Elt: FlagIndirectVirtualBase); |
333 | } |
334 | |
335 | #define HANDLE_DI_FLAG(ID, NAME) \ |
336 | if (DIFlags Bit = Flags & Flag##NAME) { \ |
337 | SplitFlags.push_back(Bit); \ |
338 | Flags &= ~Bit; \ |
339 | } |
340 | #include "llvm/IR/DebugInfoFlags.def" |
341 | return Flags; |
342 | } |
343 | |
344 | DIScope *DIScope::getScope() const { |
345 | if (auto *T = dyn_cast<DIType>(Val: this)) |
346 | return T->getScope(); |
347 | |
348 | if (auto *SP = dyn_cast<DISubprogram>(Val: this)) |
349 | return SP->getScope(); |
350 | |
351 | if (auto *LB = dyn_cast<DILexicalBlockBase>(Val: this)) |
352 | return LB->getScope(); |
353 | |
354 | if (auto *NS = dyn_cast<DINamespace>(Val: this)) |
355 | return NS->getScope(); |
356 | |
357 | if (auto *CB = dyn_cast<DICommonBlock>(Val: this)) |
358 | return CB->getScope(); |
359 | |
360 | if (auto *M = dyn_cast<DIModule>(Val: this)) |
361 | return M->getScope(); |
362 | |
363 | assert((isa<DIFile>(this) || isa<DICompileUnit>(this)) && |
364 | "Unhandled type of scope." ); |
365 | return nullptr; |
366 | } |
367 | |
368 | StringRef DIScope::getName() const { |
369 | if (auto *T = dyn_cast<DIType>(Val: this)) |
370 | return T->getName(); |
371 | if (auto *SP = dyn_cast<DISubprogram>(Val: this)) |
372 | return SP->getName(); |
373 | if (auto *NS = dyn_cast<DINamespace>(Val: this)) |
374 | return NS->getName(); |
375 | if (auto *CB = dyn_cast<DICommonBlock>(Val: this)) |
376 | return CB->getName(); |
377 | if (auto *M = dyn_cast<DIModule>(Val: this)) |
378 | return M->getName(); |
379 | assert((isa<DILexicalBlockBase>(this) || isa<DIFile>(this) || |
380 | isa<DICompileUnit>(this)) && |
381 | "Unhandled type of scope." ); |
382 | return "" ; |
383 | } |
384 | |
385 | #ifndef NDEBUG |
386 | static bool isCanonical(const MDString *S) { |
387 | return !S || !S->getString().empty(); |
388 | } |
389 | #endif |
390 | |
391 | dwarf::Tag GenericDINode::getTag() const { return (dwarf::Tag)SubclassData16; } |
392 | GenericDINode *GenericDINode::getImpl(LLVMContext &Context, unsigned Tag, |
393 | MDString *, |
394 | ArrayRef<Metadata *> DwarfOps, |
395 | StorageType Storage, bool ShouldCreate) { |
396 | unsigned Hash = 0; |
397 | if (Storage == Uniqued) { |
398 | GenericDINodeInfo::KeyTy Key(Tag, Header, DwarfOps); |
399 | if (auto *N = getUniqued(Store&: Context.pImpl->GenericDINodes, Key)) |
400 | return N; |
401 | if (!ShouldCreate) |
402 | return nullptr; |
403 | Hash = Key.getHash(); |
404 | } else { |
405 | assert(ShouldCreate && "Expected non-uniqued nodes to always be created" ); |
406 | } |
407 | |
408 | // Use a nullptr for empty headers. |
409 | assert(isCanonical(Header) && "Expected canonical MDString" ); |
410 | Metadata *PreOps[] = {Header}; |
411 | return storeImpl(N: new (DwarfOps.size() + 1, Storage) GenericDINode( |
412 | Context, Storage, Hash, Tag, PreOps, DwarfOps), |
413 | Storage, Store&: Context.pImpl->GenericDINodes); |
414 | } |
415 | |
416 | void GenericDINode::recalculateHash() { |
417 | setHash(GenericDINodeInfo::KeyTy::calculateHash(N: this)); |
418 | } |
419 | |
420 | #define UNWRAP_ARGS_IMPL(...) __VA_ARGS__ |
421 | #define UNWRAP_ARGS(ARGS) UNWRAP_ARGS_IMPL ARGS |
422 | #define DEFINE_GETIMPL_LOOKUP(CLASS, ARGS) \ |
423 | do { \ |
424 | if (Storage == Uniqued) { \ |
425 | if (auto *N = getUniqued(Context.pImpl->CLASS##s, \ |
426 | CLASS##Info::KeyTy(UNWRAP_ARGS(ARGS)))) \ |
427 | return N; \ |
428 | if (!ShouldCreate) \ |
429 | return nullptr; \ |
430 | } else { \ |
431 | assert(ShouldCreate && \ |
432 | "Expected non-uniqued nodes to always be created"); \ |
433 | } \ |
434 | } while (false) |
435 | #define DEFINE_GETIMPL_STORE(CLASS, ARGS, OPS) \ |
436 | return storeImpl(new (std::size(OPS), Storage) \ |
437 | CLASS(Context, Storage, UNWRAP_ARGS(ARGS), OPS), \ |
438 | Storage, Context.pImpl->CLASS##s) |
439 | #define DEFINE_GETIMPL_STORE_NO_OPS(CLASS, ARGS) \ |
440 | return storeImpl(new (0u, Storage) \ |
441 | CLASS(Context, Storage, UNWRAP_ARGS(ARGS)), \ |
442 | Storage, Context.pImpl->CLASS##s) |
443 | #define DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(CLASS, OPS) \ |
444 | return storeImpl(new (std::size(OPS), Storage) CLASS(Context, Storage, OPS), \ |
445 | Storage, Context.pImpl->CLASS##s) |
446 | #define DEFINE_GETIMPL_STORE_N(CLASS, ARGS, OPS, NUM_OPS) \ |
447 | return storeImpl(new (NUM_OPS, Storage) \ |
448 | CLASS(Context, Storage, UNWRAP_ARGS(ARGS), OPS), \ |
449 | Storage, Context.pImpl->CLASS##s) |
450 | |
451 | DISubrange::DISubrange(LLVMContext &C, StorageType Storage, |
452 | ArrayRef<Metadata *> Ops) |
453 | : DINode(C, DISubrangeKind, Storage, dwarf::DW_TAG_subrange_type, Ops) {} |
454 | DISubrange *DISubrange::getImpl(LLVMContext &Context, int64_t Count, int64_t Lo, |
455 | StorageType Storage, bool ShouldCreate) { |
456 | auto *CountNode = ConstantAsMetadata::get( |
457 | C: ConstantInt::getSigned(Ty: Type::getInt64Ty(C&: Context), V: Count)); |
458 | auto *LB = ConstantAsMetadata::get( |
459 | C: ConstantInt::getSigned(Ty: Type::getInt64Ty(C&: Context), V: Lo)); |
460 | return getImpl(Context, CountNode, LowerBound: LB, UpperBound: nullptr, Stride: nullptr, Storage, |
461 | ShouldCreate); |
462 | } |
463 | |
464 | DISubrange *DISubrange::getImpl(LLVMContext &Context, Metadata *CountNode, |
465 | int64_t Lo, StorageType Storage, |
466 | bool ShouldCreate) { |
467 | auto *LB = ConstantAsMetadata::get( |
468 | C: ConstantInt::getSigned(Ty: Type::getInt64Ty(C&: Context), V: Lo)); |
469 | return getImpl(Context, CountNode, LowerBound: LB, UpperBound: nullptr, Stride: nullptr, Storage, |
470 | ShouldCreate); |
471 | } |
472 | |
473 | DISubrange *DISubrange::getImpl(LLVMContext &Context, Metadata *CountNode, |
474 | Metadata *LB, Metadata *UB, Metadata *Stride, |
475 | StorageType Storage, bool ShouldCreate) { |
476 | DEFINE_GETIMPL_LOOKUP(DISubrange, (CountNode, LB, UB, Stride)); |
477 | Metadata *Ops[] = {CountNode, LB, UB, Stride}; |
478 | DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DISubrange, Ops); |
479 | } |
480 | |
481 | DISubrange::BoundType DISubrange::getCount() const { |
482 | Metadata *CB = getRawCountNode(); |
483 | if (!CB) |
484 | return BoundType(); |
485 | |
486 | assert((isa<ConstantAsMetadata>(CB) || isa<DIVariable>(CB) || |
487 | isa<DIExpression>(CB)) && |
488 | "Count must be signed constant or DIVariable or DIExpression" ); |
489 | |
490 | if (auto *MD = dyn_cast<ConstantAsMetadata>(Val: CB)) |
491 | return BoundType(cast<ConstantInt>(Val: MD->getValue())); |
492 | |
493 | if (auto *MD = dyn_cast<DIVariable>(Val: CB)) |
494 | return BoundType(MD); |
495 | |
496 | if (auto *MD = dyn_cast<DIExpression>(Val: CB)) |
497 | return BoundType(MD); |
498 | |
499 | return BoundType(); |
500 | } |
501 | |
502 | DISubrange::BoundType DISubrange::getLowerBound() const { |
503 | Metadata *LB = getRawLowerBound(); |
504 | if (!LB) |
505 | return BoundType(); |
506 | |
507 | assert((isa<ConstantAsMetadata>(LB) || isa<DIVariable>(LB) || |
508 | isa<DIExpression>(LB)) && |
509 | "LowerBound must be signed constant or DIVariable or DIExpression" ); |
510 | |
511 | if (auto *MD = dyn_cast<ConstantAsMetadata>(Val: LB)) |
512 | return BoundType(cast<ConstantInt>(Val: MD->getValue())); |
513 | |
514 | if (auto *MD = dyn_cast<DIVariable>(Val: LB)) |
515 | return BoundType(MD); |
516 | |
517 | if (auto *MD = dyn_cast<DIExpression>(Val: LB)) |
518 | return BoundType(MD); |
519 | |
520 | return BoundType(); |
521 | } |
522 | |
523 | DISubrange::BoundType DISubrange::getUpperBound() const { |
524 | Metadata *UB = getRawUpperBound(); |
525 | if (!UB) |
526 | return BoundType(); |
527 | |
528 | assert((isa<ConstantAsMetadata>(UB) || isa<DIVariable>(UB) || |
529 | isa<DIExpression>(UB)) && |
530 | "UpperBound must be signed constant or DIVariable or DIExpression" ); |
531 | |
532 | if (auto *MD = dyn_cast<ConstantAsMetadata>(Val: UB)) |
533 | return BoundType(cast<ConstantInt>(Val: MD->getValue())); |
534 | |
535 | if (auto *MD = dyn_cast<DIVariable>(Val: UB)) |
536 | return BoundType(MD); |
537 | |
538 | if (auto *MD = dyn_cast<DIExpression>(Val: UB)) |
539 | return BoundType(MD); |
540 | |
541 | return BoundType(); |
542 | } |
543 | |
544 | DISubrange::BoundType DISubrange::getStride() const { |
545 | Metadata *ST = getRawStride(); |
546 | if (!ST) |
547 | return BoundType(); |
548 | |
549 | assert((isa<ConstantAsMetadata>(ST) || isa<DIVariable>(ST) || |
550 | isa<DIExpression>(ST)) && |
551 | "Stride must be signed constant or DIVariable or DIExpression" ); |
552 | |
553 | if (auto *MD = dyn_cast<ConstantAsMetadata>(Val: ST)) |
554 | return BoundType(cast<ConstantInt>(Val: MD->getValue())); |
555 | |
556 | if (auto *MD = dyn_cast<DIVariable>(Val: ST)) |
557 | return BoundType(MD); |
558 | |
559 | if (auto *MD = dyn_cast<DIExpression>(Val: ST)) |
560 | return BoundType(MD); |
561 | |
562 | return BoundType(); |
563 | } |
564 | DIGenericSubrange::DIGenericSubrange(LLVMContext &C, StorageType Storage, |
565 | ArrayRef<Metadata *> Ops) |
566 | : DINode(C, DIGenericSubrangeKind, Storage, dwarf::DW_TAG_generic_subrange, |
567 | Ops) {} |
568 | |
569 | DIGenericSubrange *DIGenericSubrange::getImpl(LLVMContext &Context, |
570 | Metadata *CountNode, Metadata *LB, |
571 | Metadata *UB, Metadata *Stride, |
572 | StorageType Storage, |
573 | bool ShouldCreate) { |
574 | DEFINE_GETIMPL_LOOKUP(DIGenericSubrange, (CountNode, LB, UB, Stride)); |
575 | Metadata *Ops[] = {CountNode, LB, UB, Stride}; |
576 | DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIGenericSubrange, Ops); |
577 | } |
578 | |
579 | DIGenericSubrange::BoundType DIGenericSubrange::getCount() const { |
580 | Metadata *CB = getRawCountNode(); |
581 | if (!CB) |
582 | return BoundType(); |
583 | |
584 | assert((isa<DIVariable>(CB) || isa<DIExpression>(CB)) && |
585 | "Count must be signed constant or DIVariable or DIExpression" ); |
586 | |
587 | if (auto *MD = dyn_cast<DIVariable>(Val: CB)) |
588 | return BoundType(MD); |
589 | |
590 | if (auto *MD = dyn_cast<DIExpression>(Val: CB)) |
591 | return BoundType(MD); |
592 | |
593 | return BoundType(); |
594 | } |
595 | |
596 | DIGenericSubrange::BoundType DIGenericSubrange::getLowerBound() const { |
597 | Metadata *LB = getRawLowerBound(); |
598 | if (!LB) |
599 | return BoundType(); |
600 | |
601 | assert((isa<DIVariable>(LB) || isa<DIExpression>(LB)) && |
602 | "LowerBound must be signed constant or DIVariable or DIExpression" ); |
603 | |
604 | if (auto *MD = dyn_cast<DIVariable>(Val: LB)) |
605 | return BoundType(MD); |
606 | |
607 | if (auto *MD = dyn_cast<DIExpression>(Val: LB)) |
608 | return BoundType(MD); |
609 | |
610 | return BoundType(); |
611 | } |
612 | |
613 | DIGenericSubrange::BoundType DIGenericSubrange::getUpperBound() const { |
614 | Metadata *UB = getRawUpperBound(); |
615 | if (!UB) |
616 | return BoundType(); |
617 | |
618 | assert((isa<DIVariable>(UB) || isa<DIExpression>(UB)) && |
619 | "UpperBound must be signed constant or DIVariable or DIExpression" ); |
620 | |
621 | if (auto *MD = dyn_cast<DIVariable>(Val: UB)) |
622 | return BoundType(MD); |
623 | |
624 | if (auto *MD = dyn_cast<DIExpression>(Val: UB)) |
625 | return BoundType(MD); |
626 | |
627 | return BoundType(); |
628 | } |
629 | |
630 | DIGenericSubrange::BoundType DIGenericSubrange::getStride() const { |
631 | Metadata *ST = getRawStride(); |
632 | if (!ST) |
633 | return BoundType(); |
634 | |
635 | assert((isa<DIVariable>(ST) || isa<DIExpression>(ST)) && |
636 | "Stride must be signed constant or DIVariable or DIExpression" ); |
637 | |
638 | if (auto *MD = dyn_cast<DIVariable>(Val: ST)) |
639 | return BoundType(MD); |
640 | |
641 | if (auto *MD = dyn_cast<DIExpression>(Val: ST)) |
642 | return BoundType(MD); |
643 | |
644 | return BoundType(); |
645 | } |
646 | |
647 | DIEnumerator::DIEnumerator(LLVMContext &C, StorageType Storage, |
648 | const APInt &Value, bool IsUnsigned, |
649 | ArrayRef<Metadata *> Ops) |
650 | : DINode(C, DIEnumeratorKind, Storage, dwarf::DW_TAG_enumerator, Ops), |
651 | Value(Value) { |
652 | SubclassData32 = IsUnsigned; |
653 | } |
654 | DIEnumerator *DIEnumerator::getImpl(LLVMContext &Context, const APInt &Value, |
655 | bool IsUnsigned, MDString *Name, |
656 | StorageType Storage, bool ShouldCreate) { |
657 | assert(isCanonical(Name) && "Expected canonical MDString" ); |
658 | DEFINE_GETIMPL_LOOKUP(DIEnumerator, (Value, IsUnsigned, Name)); |
659 | Metadata *Ops[] = {Name}; |
660 | DEFINE_GETIMPL_STORE(DIEnumerator, (Value, IsUnsigned), Ops); |
661 | } |
662 | |
663 | DIBasicType *DIBasicType::getImpl(LLVMContext &Context, unsigned Tag, |
664 | MDString *Name, uint64_t SizeInBits, |
665 | uint32_t AlignInBits, unsigned Encoding, |
666 | DIFlags Flags, StorageType Storage, |
667 | bool ShouldCreate) { |
668 | assert(isCanonical(Name) && "Expected canonical MDString" ); |
669 | DEFINE_GETIMPL_LOOKUP(DIBasicType, |
670 | (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags)); |
671 | Metadata *Ops[] = {nullptr, nullptr, Name}; |
672 | DEFINE_GETIMPL_STORE(DIBasicType, |
673 | (Tag, SizeInBits, AlignInBits, Encoding, Flags), Ops); |
674 | } |
675 | |
676 | std::optional<DIBasicType::Signedness> DIBasicType::getSignedness() const { |
677 | switch (getEncoding()) { |
678 | case dwarf::DW_ATE_signed: |
679 | case dwarf::DW_ATE_signed_char: |
680 | return Signedness::Signed; |
681 | case dwarf::DW_ATE_unsigned: |
682 | case dwarf::DW_ATE_unsigned_char: |
683 | return Signedness::Unsigned; |
684 | default: |
685 | return std::nullopt; |
686 | } |
687 | } |
688 | |
689 | DIStringType *DIStringType::getImpl(LLVMContext &Context, unsigned Tag, |
690 | MDString *Name, Metadata *StringLength, |
691 | Metadata *StringLengthExp, |
692 | Metadata *StringLocationExp, |
693 | uint64_t SizeInBits, uint32_t AlignInBits, |
694 | unsigned Encoding, StorageType Storage, |
695 | bool ShouldCreate) { |
696 | assert(isCanonical(Name) && "Expected canonical MDString" ); |
697 | DEFINE_GETIMPL_LOOKUP(DIStringType, |
698 | (Tag, Name, StringLength, StringLengthExp, |
699 | StringLocationExp, SizeInBits, AlignInBits, Encoding)); |
700 | Metadata *Ops[] = {nullptr, nullptr, Name, |
701 | StringLength, StringLengthExp, StringLocationExp}; |
702 | DEFINE_GETIMPL_STORE(DIStringType, (Tag, SizeInBits, AlignInBits, Encoding), |
703 | Ops); |
704 | } |
705 | DIType *DIDerivedType::getClassType() const { |
706 | assert(getTag() == dwarf::DW_TAG_ptr_to_member_type); |
707 | return cast_or_null<DIType>(Val: getExtraData()); |
708 | } |
709 | uint32_t DIDerivedType::getVBPtrOffset() const { |
710 | assert(getTag() == dwarf::DW_TAG_inheritance); |
711 | if (auto *CM = cast_or_null<ConstantAsMetadata>(Val: getExtraData())) |
712 | if (auto *CI = dyn_cast_or_null<ConstantInt>(Val: CM->getValue())) |
713 | return static_cast<uint32_t>(CI->getZExtValue()); |
714 | return 0; |
715 | } |
716 | Constant *DIDerivedType::getStorageOffsetInBits() const { |
717 | assert(getTag() == dwarf::DW_TAG_member && isBitField()); |
718 | if (auto *C = cast_or_null<ConstantAsMetadata>(Val: getExtraData())) |
719 | return C->getValue(); |
720 | return nullptr; |
721 | } |
722 | |
723 | Constant *DIDerivedType::getConstant() const { |
724 | assert((getTag() == dwarf::DW_TAG_member || |
725 | getTag() == dwarf::DW_TAG_variable) && |
726 | isStaticMember()); |
727 | if (auto *C = cast_or_null<ConstantAsMetadata>(Val: getExtraData())) |
728 | return C->getValue(); |
729 | return nullptr; |
730 | } |
731 | Constant *DIDerivedType::getDiscriminantValue() const { |
732 | assert(getTag() == dwarf::DW_TAG_member && !isStaticMember()); |
733 | if (auto *C = cast_or_null<ConstantAsMetadata>(Val: getExtraData())) |
734 | return C->getValue(); |
735 | return nullptr; |
736 | } |
737 | |
738 | DIDerivedType *DIDerivedType::getImpl( |
739 | LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File, |
740 | unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits, |
741 | uint32_t AlignInBits, uint64_t OffsetInBits, |
742 | std::optional<unsigned> DWARFAddressSpace, |
743 | std::optional<PtrAuthData> PtrAuthData, DIFlags Flags, Metadata *, |
744 | Metadata *Annotations, StorageType Storage, bool ShouldCreate) { |
745 | assert(isCanonical(Name) && "Expected canonical MDString" ); |
746 | DEFINE_GETIMPL_LOOKUP(DIDerivedType, |
747 | (Tag, Name, File, Line, Scope, BaseType, SizeInBits, |
748 | AlignInBits, OffsetInBits, DWARFAddressSpace, |
749 | PtrAuthData, Flags, ExtraData, Annotations)); |
750 | Metadata *Ops[] = {File, Scope, Name, BaseType, ExtraData, Annotations}; |
751 | DEFINE_GETIMPL_STORE(DIDerivedType, |
752 | (Tag, Line, SizeInBits, AlignInBits, OffsetInBits, |
753 | DWARFAddressSpace, PtrAuthData, Flags), |
754 | Ops); |
755 | } |
756 | |
757 | std::optional<DIDerivedType::PtrAuthData> |
758 | DIDerivedType::getPtrAuthData() const { |
759 | return getTag() == dwarf::DW_TAG_LLVM_ptrauth_type |
760 | ? std::optional<PtrAuthData>(PtrAuthData(SubclassData32)) |
761 | : std::nullopt; |
762 | } |
763 | |
764 | DICompositeType *DICompositeType::getImpl( |
765 | LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File, |
766 | unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits, |
767 | uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags, |
768 | Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder, |
769 | Metadata *TemplateParams, MDString *Identifier, Metadata *Discriminator, |
770 | Metadata *DataLocation, Metadata *Associated, Metadata *Allocated, |
771 | Metadata *Rank, Metadata *Annotations, StorageType Storage, |
772 | bool ShouldCreate) { |
773 | assert(isCanonical(Name) && "Expected canonical MDString" ); |
774 | |
775 | // Keep this in sync with buildODRType. |
776 | DEFINE_GETIMPL_LOOKUP(DICompositeType, |
777 | (Tag, Name, File, Line, Scope, BaseType, SizeInBits, |
778 | AlignInBits, OffsetInBits, Flags, Elements, |
779 | RuntimeLang, VTableHolder, TemplateParams, Identifier, |
780 | Discriminator, DataLocation, Associated, Allocated, |
781 | Rank, Annotations)); |
782 | Metadata *Ops[] = {File, Scope, Name, BaseType, |
783 | Elements, VTableHolder, TemplateParams, Identifier, |
784 | Discriminator, DataLocation, Associated, Allocated, |
785 | Rank, Annotations}; |
786 | DEFINE_GETIMPL_STORE( |
787 | DICompositeType, |
788 | (Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits, Flags), |
789 | Ops); |
790 | } |
791 | |
792 | DICompositeType *DICompositeType::buildODRType( |
793 | LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name, |
794 | Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, |
795 | uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, |
796 | DIFlags Flags, Metadata *Elements, unsigned RuntimeLang, |
797 | Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator, |
798 | Metadata *DataLocation, Metadata *Associated, Metadata *Allocated, |
799 | Metadata *Rank, Metadata *Annotations) { |
800 | assert(!Identifier.getString().empty() && "Expected valid identifier" ); |
801 | if (!Context.isODRUniquingDebugTypes()) |
802 | return nullptr; |
803 | auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier]; |
804 | if (!CT) |
805 | return CT = DICompositeType::getDistinct( |
806 | Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, |
807 | AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, |
808 | VTableHolder, TemplateParams, Identifier: &Identifier, Discriminator, |
809 | DataLocation, Associated, Allocated, Rank, Annotations); |
810 | |
811 | if (CT->getTag() != Tag) |
812 | return nullptr; |
813 | |
814 | // Only mutate CT if it's a forward declaration and the new operands aren't. |
815 | assert(CT->getRawIdentifier() == &Identifier && "Wrong ODR identifier?" ); |
816 | if (!CT->isForwardDecl() || (Flags & DINode::FlagFwdDecl)) |
817 | return CT; |
818 | |
819 | // Mutate CT in place. Keep this in sync with getImpl. |
820 | CT->mutate(Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits, |
821 | Flags); |
822 | Metadata *Ops[] = {File, Scope, Name, BaseType, |
823 | Elements, VTableHolder, TemplateParams, &Identifier, |
824 | Discriminator, DataLocation, Associated, Allocated, |
825 | Rank, Annotations}; |
826 | assert((std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands() && |
827 | "Mismatched number of operands" ); |
828 | for (unsigned I = 0, E = CT->getNumOperands(); I != E; ++I) |
829 | if (Ops[I] != CT->getOperand(I)) |
830 | CT->setOperand(I, New: Ops[I]); |
831 | return CT; |
832 | } |
833 | |
834 | DICompositeType *DICompositeType::getODRType( |
835 | LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name, |
836 | Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, |
837 | uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, |
838 | DIFlags Flags, Metadata *Elements, unsigned RuntimeLang, |
839 | Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator, |
840 | Metadata *DataLocation, Metadata *Associated, Metadata *Allocated, |
841 | Metadata *Rank, Metadata *Annotations) { |
842 | assert(!Identifier.getString().empty() && "Expected valid identifier" ); |
843 | if (!Context.isODRUniquingDebugTypes()) |
844 | return nullptr; |
845 | auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier]; |
846 | if (!CT) { |
847 | CT = DICompositeType::getDistinct( |
848 | Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, |
849 | AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, VTableHolder, |
850 | TemplateParams, Identifier: &Identifier, Discriminator, DataLocation, Associated, |
851 | Allocated, Rank, Annotations); |
852 | } else { |
853 | if (CT->getTag() != Tag) |
854 | return nullptr; |
855 | } |
856 | return CT; |
857 | } |
858 | |
859 | DICompositeType *DICompositeType::getODRTypeIfExists(LLVMContext &Context, |
860 | MDString &Identifier) { |
861 | assert(!Identifier.getString().empty() && "Expected valid identifier" ); |
862 | if (!Context.isODRUniquingDebugTypes()) |
863 | return nullptr; |
864 | return Context.pImpl->DITypeMap->lookup(Val: &Identifier); |
865 | } |
866 | DISubroutineType::DISubroutineType(LLVMContext &C, StorageType Storage, |
867 | DIFlags Flags, uint8_t CC, |
868 | ArrayRef<Metadata *> Ops) |
869 | : DIType(C, DISubroutineTypeKind, Storage, dwarf::DW_TAG_subroutine_type, 0, |
870 | 0, 0, 0, Flags, Ops), |
871 | CC(CC) {} |
872 | |
873 | DISubroutineType *DISubroutineType::getImpl(LLVMContext &Context, DIFlags Flags, |
874 | uint8_t CC, Metadata *TypeArray, |
875 | StorageType Storage, |
876 | bool ShouldCreate) { |
877 | DEFINE_GETIMPL_LOOKUP(DISubroutineType, (Flags, CC, TypeArray)); |
878 | Metadata *Ops[] = {nullptr, nullptr, nullptr, TypeArray}; |
879 | DEFINE_GETIMPL_STORE(DISubroutineType, (Flags, CC), Ops); |
880 | } |
881 | |
882 | DIFile::DIFile(LLVMContext &C, StorageType Storage, |
883 | std::optional<ChecksumInfo<MDString *>> CS, MDString *Src, |
884 | ArrayRef<Metadata *> Ops) |
885 | : DIScope(C, DIFileKind, Storage, dwarf::DW_TAG_file_type, Ops), |
886 | Checksum(CS), Source(Src) {} |
887 | |
888 | // FIXME: Implement this string-enum correspondence with a .def file and macros, |
889 | // so that the association is explicit rather than implied. |
890 | static const char *ChecksumKindName[DIFile::CSK_Last] = { |
891 | "CSK_MD5" , |
892 | "CSK_SHA1" , |
893 | "CSK_SHA256" , |
894 | }; |
895 | |
896 | StringRef DIFile::getChecksumKindAsString(ChecksumKind CSKind) { |
897 | assert(CSKind <= DIFile::CSK_Last && "Invalid checksum kind" ); |
898 | // The first space was originally the CSK_None variant, which is now |
899 | // obsolete, but the space is still reserved in ChecksumKind, so we account |
900 | // for it here. |
901 | return ChecksumKindName[CSKind - 1]; |
902 | } |
903 | |
904 | std::optional<DIFile::ChecksumKind> |
905 | DIFile::getChecksumKind(StringRef CSKindStr) { |
906 | return StringSwitch<std::optional<DIFile::ChecksumKind>>(CSKindStr) |
907 | .Case(S: "CSK_MD5" , Value: DIFile::CSK_MD5) |
908 | .Case(S: "CSK_SHA1" , Value: DIFile::CSK_SHA1) |
909 | .Case(S: "CSK_SHA256" , Value: DIFile::CSK_SHA256) |
910 | .Default(Value: std::nullopt); |
911 | } |
912 | |
913 | DIFile *DIFile::getImpl(LLVMContext &Context, MDString *Filename, |
914 | MDString *Directory, |
915 | std::optional<DIFile::ChecksumInfo<MDString *>> CS, |
916 | MDString *Source, StorageType Storage, |
917 | bool ShouldCreate) { |
918 | assert(isCanonical(Filename) && "Expected canonical MDString" ); |
919 | assert(isCanonical(Directory) && "Expected canonical MDString" ); |
920 | assert((!CS || isCanonical(CS->Value)) && "Expected canonical MDString" ); |
921 | // We do *NOT* expect Source to be a canonical MDString because nullptr |
922 | // means none, so we need something to represent the empty file. |
923 | DEFINE_GETIMPL_LOOKUP(DIFile, (Filename, Directory, CS, Source)); |
924 | Metadata *Ops[] = {Filename, Directory, CS ? CS->Value : nullptr, Source}; |
925 | DEFINE_GETIMPL_STORE(DIFile, (CS, Source), Ops); |
926 | } |
927 | DICompileUnit::DICompileUnit(LLVMContext &C, StorageType Storage, |
928 | unsigned SourceLanguage, bool IsOptimized, |
929 | unsigned RuntimeVersion, unsigned EmissionKind, |
930 | uint64_t DWOId, bool SplitDebugInlining, |
931 | bool DebugInfoForProfiling, unsigned NameTableKind, |
932 | bool RangesBaseAddress, ArrayRef<Metadata *> Ops) |
933 | : DIScope(C, DICompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops), |
934 | SourceLanguage(SourceLanguage), RuntimeVersion(RuntimeVersion), |
935 | DWOId(DWOId), EmissionKind(EmissionKind), NameTableKind(NameTableKind), |
936 | IsOptimized(IsOptimized), SplitDebugInlining(SplitDebugInlining), |
937 | DebugInfoForProfiling(DebugInfoForProfiling), |
938 | RangesBaseAddress(RangesBaseAddress) { |
939 | assert(Storage != Uniqued); |
940 | } |
941 | |
942 | DICompileUnit *DICompileUnit::getImpl( |
943 | LLVMContext &Context, unsigned SourceLanguage, Metadata *File, |
944 | MDString *Producer, bool IsOptimized, MDString *Flags, |
945 | unsigned RuntimeVersion, MDString *SplitDebugFilename, |
946 | unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes, |
947 | Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata *Macros, |
948 | uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling, |
949 | unsigned NameTableKind, bool RangesBaseAddress, MDString *SysRoot, |
950 | MDString *SDK, StorageType Storage, bool ShouldCreate) { |
951 | assert(Storage != Uniqued && "Cannot unique DICompileUnit" ); |
952 | assert(isCanonical(Producer) && "Expected canonical MDString" ); |
953 | assert(isCanonical(Flags) && "Expected canonical MDString" ); |
954 | assert(isCanonical(SplitDebugFilename) && "Expected canonical MDString" ); |
955 | |
956 | Metadata *Ops[] = {File, |
957 | Producer, |
958 | Flags, |
959 | SplitDebugFilename, |
960 | EnumTypes, |
961 | RetainedTypes, |
962 | GlobalVariables, |
963 | ImportedEntities, |
964 | Macros, |
965 | SysRoot, |
966 | SDK}; |
967 | return storeImpl(N: new (std::size(Ops), Storage) DICompileUnit( |
968 | Context, Storage, SourceLanguage, IsOptimized, |
969 | RuntimeVersion, EmissionKind, DWOId, SplitDebugInlining, |
970 | DebugInfoForProfiling, NameTableKind, RangesBaseAddress, |
971 | Ops), |
972 | Storage); |
973 | } |
974 | |
975 | std::optional<DICompileUnit::DebugEmissionKind> |
976 | DICompileUnit::getEmissionKind(StringRef Str) { |
977 | return StringSwitch<std::optional<DebugEmissionKind>>(Str) |
978 | .Case(S: "NoDebug" , Value: NoDebug) |
979 | .Case(S: "FullDebug" , Value: FullDebug) |
980 | .Case(S: "LineTablesOnly" , Value: LineTablesOnly) |
981 | .Case(S: "DebugDirectivesOnly" , Value: DebugDirectivesOnly) |
982 | .Default(Value: std::nullopt); |
983 | } |
984 | |
985 | std::optional<DICompileUnit::DebugNameTableKind> |
986 | DICompileUnit::getNameTableKind(StringRef Str) { |
987 | return StringSwitch<std::optional<DebugNameTableKind>>(Str) |
988 | .Case(S: "Default" , Value: DebugNameTableKind::Default) |
989 | .Case(S: "GNU" , Value: DebugNameTableKind::GNU) |
990 | .Case(S: "Apple" , Value: DebugNameTableKind::Apple) |
991 | .Case(S: "None" , Value: DebugNameTableKind::None) |
992 | .Default(Value: std::nullopt); |
993 | } |
994 | |
995 | const char *DICompileUnit::emissionKindString(DebugEmissionKind EK) { |
996 | switch (EK) { |
997 | case NoDebug: |
998 | return "NoDebug" ; |
999 | case FullDebug: |
1000 | return "FullDebug" ; |
1001 | case LineTablesOnly: |
1002 | return "LineTablesOnly" ; |
1003 | case DebugDirectivesOnly: |
1004 | return "DebugDirectivesOnly" ; |
1005 | } |
1006 | return nullptr; |
1007 | } |
1008 | |
1009 | const char *DICompileUnit::nameTableKindString(DebugNameTableKind NTK) { |
1010 | switch (NTK) { |
1011 | case DebugNameTableKind::Default: |
1012 | return nullptr; |
1013 | case DebugNameTableKind::GNU: |
1014 | return "GNU" ; |
1015 | case DebugNameTableKind::Apple: |
1016 | return "Apple" ; |
1017 | case DebugNameTableKind::None: |
1018 | return "None" ; |
1019 | } |
1020 | return nullptr; |
1021 | } |
1022 | DISubprogram::DISubprogram(LLVMContext &C, StorageType Storage, unsigned Line, |
1023 | unsigned ScopeLine, unsigned VirtualIndex, |
1024 | int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags, |
1025 | ArrayRef<Metadata *> Ops) |
1026 | : DILocalScope(C, DISubprogramKind, Storage, dwarf::DW_TAG_subprogram, Ops), |
1027 | Line(Line), ScopeLine(ScopeLine), VirtualIndex(VirtualIndex), |
1028 | ThisAdjustment(ThisAdjustment), Flags(Flags), SPFlags(SPFlags) { |
1029 | static_assert(dwarf::DW_VIRTUALITY_max < 4, "Virtuality out of range" ); |
1030 | } |
1031 | DISubprogram::DISPFlags |
1032 | DISubprogram::toSPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized, |
1033 | unsigned Virtuality, bool IsMainSubprogram) { |
1034 | // We're assuming virtuality is the low-order field. |
1035 | static_assert(int(SPFlagVirtual) == int(dwarf::DW_VIRTUALITY_virtual) && |
1036 | int(SPFlagPureVirtual) == |
1037 | int(dwarf::DW_VIRTUALITY_pure_virtual), |
1038 | "Virtuality constant mismatch" ); |
1039 | return static_cast<DISPFlags>( |
1040 | (Virtuality & SPFlagVirtuality) | |
1041 | (IsLocalToUnit ? SPFlagLocalToUnit : SPFlagZero) | |
1042 | (IsDefinition ? SPFlagDefinition : SPFlagZero) | |
1043 | (IsOptimized ? SPFlagOptimized : SPFlagZero) | |
1044 | (IsMainSubprogram ? SPFlagMainSubprogram : SPFlagZero)); |
1045 | } |
1046 | |
1047 | DISubprogram *DILocalScope::getSubprogram() const { |
1048 | if (auto *Block = dyn_cast<DILexicalBlockBase>(Val: this)) |
1049 | return Block->getScope()->getSubprogram(); |
1050 | return const_cast<DISubprogram *>(cast<DISubprogram>(Val: this)); |
1051 | } |
1052 | |
1053 | DILocalScope *DILocalScope::getNonLexicalBlockFileScope() const { |
1054 | if (auto *File = dyn_cast<DILexicalBlockFile>(Val: this)) |
1055 | return File->getScope()->getNonLexicalBlockFileScope(); |
1056 | return const_cast<DILocalScope *>(this); |
1057 | } |
1058 | |
1059 | DILocalScope *DILocalScope::cloneScopeForSubprogram( |
1060 | DILocalScope &RootScope, DISubprogram &NewSP, LLVMContext &Ctx, |
1061 | DenseMap<const MDNode *, MDNode *> &Cache) { |
1062 | SmallVector<DIScope *> ScopeChain; |
1063 | DIScope *CachedResult = nullptr; |
1064 | |
1065 | for (DIScope *Scope = &RootScope; !isa<DISubprogram>(Val: Scope); |
1066 | Scope = Scope->getScope()) { |
1067 | if (auto It = Cache.find(Val: Scope); It != Cache.end()) { |
1068 | CachedResult = cast<DIScope>(Val: It->second); |
1069 | break; |
1070 | } |
1071 | ScopeChain.push_back(Elt: Scope); |
1072 | } |
1073 | |
1074 | // Recreate the scope chain, bottom-up, starting at the new subprogram (or a |
1075 | // cached result). |
1076 | DIScope *UpdatedScope = CachedResult ? CachedResult : &NewSP; |
1077 | for (DIScope *ScopeToUpdate : reverse(C&: ScopeChain)) { |
1078 | TempMDNode ClonedScope = ScopeToUpdate->clone(); |
1079 | cast<DILexicalBlockBase>(Val&: *ClonedScope).replaceScope(Scope: UpdatedScope); |
1080 | UpdatedScope = |
1081 | cast<DIScope>(Val: MDNode::replaceWithUniqued(N: std::move(ClonedScope))); |
1082 | Cache[ScopeToUpdate] = UpdatedScope; |
1083 | } |
1084 | |
1085 | return cast<DILocalScope>(Val: UpdatedScope); |
1086 | } |
1087 | |
1088 | DISubprogram::DISPFlags DISubprogram::getFlag(StringRef Flag) { |
1089 | return StringSwitch<DISPFlags>(Flag) |
1090 | #define HANDLE_DISP_FLAG(ID, NAME) .Case("DISPFlag" #NAME, SPFlag##NAME) |
1091 | #include "llvm/IR/DebugInfoFlags.def" |
1092 | .Default(Value: SPFlagZero); |
1093 | } |
1094 | |
1095 | StringRef DISubprogram::getFlagString(DISPFlags Flag) { |
1096 | switch (Flag) { |
1097 | // Appease a warning. |
1098 | case SPFlagVirtuality: |
1099 | return "" ; |
1100 | #define HANDLE_DISP_FLAG(ID, NAME) \ |
1101 | case SPFlag##NAME: \ |
1102 | return "DISPFlag" #NAME; |
1103 | #include "llvm/IR/DebugInfoFlags.def" |
1104 | } |
1105 | return "" ; |
1106 | } |
1107 | |
1108 | DISubprogram::DISPFlags |
1109 | DISubprogram::splitFlags(DISPFlags Flags, |
1110 | SmallVectorImpl<DISPFlags> &SplitFlags) { |
1111 | // Multi-bit fields can require special handling. In our case, however, the |
1112 | // only multi-bit field is virtuality, and all its values happen to be |
1113 | // single-bit values, so the right behavior just falls out. |
1114 | #define HANDLE_DISP_FLAG(ID, NAME) \ |
1115 | if (DISPFlags Bit = Flags & SPFlag##NAME) { \ |
1116 | SplitFlags.push_back(Bit); \ |
1117 | Flags &= ~Bit; \ |
1118 | } |
1119 | #include "llvm/IR/DebugInfoFlags.def" |
1120 | return Flags; |
1121 | } |
1122 | |
1123 | DISubprogram *DISubprogram::getImpl( |
1124 | LLVMContext &Context, Metadata *Scope, MDString *Name, |
1125 | MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type, |
1126 | unsigned ScopeLine, Metadata *ContainingType, unsigned VirtualIndex, |
1127 | int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags, Metadata *Unit, |
1128 | Metadata *TemplateParams, Metadata *Declaration, Metadata *RetainedNodes, |
1129 | Metadata *ThrownTypes, Metadata *Annotations, MDString *TargetFuncName, |
1130 | StorageType Storage, bool ShouldCreate) { |
1131 | assert(isCanonical(Name) && "Expected canonical MDString" ); |
1132 | assert(isCanonical(LinkageName) && "Expected canonical MDString" ); |
1133 | assert(isCanonical(TargetFuncName) && "Expected canonical MDString" ); |
1134 | DEFINE_GETIMPL_LOOKUP(DISubprogram, |
1135 | (Scope, Name, LinkageName, File, Line, Type, ScopeLine, |
1136 | ContainingType, VirtualIndex, ThisAdjustment, Flags, |
1137 | SPFlags, Unit, TemplateParams, Declaration, |
1138 | RetainedNodes, ThrownTypes, Annotations, |
1139 | TargetFuncName)); |
1140 | SmallVector<Metadata *, 13> Ops = { |
1141 | File, Scope, Name, LinkageName, |
1142 | Type, Unit, Declaration, RetainedNodes, |
1143 | ContainingType, TemplateParams, ThrownTypes, Annotations, |
1144 | TargetFuncName}; |
1145 | if (!TargetFuncName) { |
1146 | Ops.pop_back(); |
1147 | if (!Annotations) { |
1148 | Ops.pop_back(); |
1149 | if (!ThrownTypes) { |
1150 | Ops.pop_back(); |
1151 | if (!TemplateParams) { |
1152 | Ops.pop_back(); |
1153 | if (!ContainingType) |
1154 | Ops.pop_back(); |
1155 | } |
1156 | } |
1157 | } |
1158 | } |
1159 | DEFINE_GETIMPL_STORE_N( |
1160 | DISubprogram, |
1161 | (Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags, SPFlags), Ops, |
1162 | Ops.size()); |
1163 | } |
1164 | |
1165 | bool DISubprogram::describes(const Function *F) const { |
1166 | assert(F && "Invalid function" ); |
1167 | return F->getSubprogram() == this; |
1168 | } |
1169 | DILexicalBlockBase::DILexicalBlockBase(LLVMContext &C, unsigned ID, |
1170 | StorageType Storage, |
1171 | ArrayRef<Metadata *> Ops) |
1172 | : DILocalScope(C, ID, Storage, dwarf::DW_TAG_lexical_block, Ops) {} |
1173 | |
1174 | DILexicalBlock *DILexicalBlock::getImpl(LLVMContext &Context, Metadata *Scope, |
1175 | Metadata *File, unsigned Line, |
1176 | unsigned Column, StorageType Storage, |
1177 | bool ShouldCreate) { |
1178 | // Fixup column. |
1179 | adjustColumn(Column); |
1180 | |
1181 | assert(Scope && "Expected scope" ); |
1182 | DEFINE_GETIMPL_LOOKUP(DILexicalBlock, (Scope, File, Line, Column)); |
1183 | Metadata *Ops[] = {File, Scope}; |
1184 | DEFINE_GETIMPL_STORE(DILexicalBlock, (Line, Column), Ops); |
1185 | } |
1186 | |
1187 | DILexicalBlockFile *DILexicalBlockFile::getImpl(LLVMContext &Context, |
1188 | Metadata *Scope, Metadata *File, |
1189 | unsigned Discriminator, |
1190 | StorageType Storage, |
1191 | bool ShouldCreate) { |
1192 | assert(Scope && "Expected scope" ); |
1193 | DEFINE_GETIMPL_LOOKUP(DILexicalBlockFile, (Scope, File, Discriminator)); |
1194 | Metadata *Ops[] = {File, Scope}; |
1195 | DEFINE_GETIMPL_STORE(DILexicalBlockFile, (Discriminator), Ops); |
1196 | } |
1197 | |
1198 | DINamespace::DINamespace(LLVMContext &Context, StorageType Storage, |
1199 | bool ExportSymbols, ArrayRef<Metadata *> Ops) |
1200 | : DIScope(Context, DINamespaceKind, Storage, dwarf::DW_TAG_namespace, Ops) { |
1201 | SubclassData1 = ExportSymbols; |
1202 | } |
1203 | DINamespace *DINamespace::getImpl(LLVMContext &Context, Metadata *Scope, |
1204 | MDString *Name, bool ExportSymbols, |
1205 | StorageType Storage, bool ShouldCreate) { |
1206 | assert(isCanonical(Name) && "Expected canonical MDString" ); |
1207 | DEFINE_GETIMPL_LOOKUP(DINamespace, (Scope, Name, ExportSymbols)); |
1208 | // The nullptr is for DIScope's File operand. This should be refactored. |
1209 | Metadata *Ops[] = {nullptr, Scope, Name}; |
1210 | DEFINE_GETIMPL_STORE(DINamespace, (ExportSymbols), Ops); |
1211 | } |
1212 | |
1213 | DICommonBlock::DICommonBlock(LLVMContext &Context, StorageType Storage, |
1214 | unsigned LineNo, ArrayRef<Metadata *> Ops) |
1215 | : DIScope(Context, DICommonBlockKind, Storage, dwarf::DW_TAG_common_block, |
1216 | Ops) { |
1217 | SubclassData32 = LineNo; |
1218 | } |
1219 | DICommonBlock *DICommonBlock::getImpl(LLVMContext &Context, Metadata *Scope, |
1220 | Metadata *Decl, MDString *Name, |
1221 | Metadata *File, unsigned LineNo, |
1222 | StorageType Storage, bool ShouldCreate) { |
1223 | assert(isCanonical(Name) && "Expected canonical MDString" ); |
1224 | DEFINE_GETIMPL_LOOKUP(DICommonBlock, (Scope, Decl, Name, File, LineNo)); |
1225 | // The nullptr is for DIScope's File operand. This should be refactored. |
1226 | Metadata *Ops[] = {Scope, Decl, Name, File}; |
1227 | DEFINE_GETIMPL_STORE(DICommonBlock, (LineNo), Ops); |
1228 | } |
1229 | |
1230 | DIModule::DIModule(LLVMContext &Context, StorageType Storage, unsigned LineNo, |
1231 | bool IsDecl, ArrayRef<Metadata *> Ops) |
1232 | : DIScope(Context, DIModuleKind, Storage, dwarf::DW_TAG_module, Ops) { |
1233 | SubclassData1 = IsDecl; |
1234 | SubclassData32 = LineNo; |
1235 | } |
1236 | DIModule *DIModule::getImpl(LLVMContext &Context, Metadata *File, |
1237 | Metadata *Scope, MDString *Name, |
1238 | MDString *ConfigurationMacros, |
1239 | MDString *IncludePath, MDString *APINotesFile, |
1240 | unsigned LineNo, bool IsDecl, StorageType Storage, |
1241 | bool ShouldCreate) { |
1242 | assert(isCanonical(Name) && "Expected canonical MDString" ); |
1243 | DEFINE_GETIMPL_LOOKUP(DIModule, (File, Scope, Name, ConfigurationMacros, |
1244 | IncludePath, APINotesFile, LineNo, IsDecl)); |
1245 | Metadata *Ops[] = {File, Scope, Name, ConfigurationMacros, |
1246 | IncludePath, APINotesFile}; |
1247 | DEFINE_GETIMPL_STORE(DIModule, (LineNo, IsDecl), Ops); |
1248 | } |
1249 | DITemplateTypeParameter::DITemplateTypeParameter(LLVMContext &Context, |
1250 | StorageType Storage, |
1251 | bool IsDefault, |
1252 | ArrayRef<Metadata *> Ops) |
1253 | : DITemplateParameter(Context, DITemplateTypeParameterKind, Storage, |
1254 | dwarf::DW_TAG_template_type_parameter, IsDefault, |
1255 | Ops) {} |
1256 | |
1257 | DITemplateTypeParameter * |
1258 | DITemplateTypeParameter::getImpl(LLVMContext &Context, MDString *Name, |
1259 | Metadata *Type, bool isDefault, |
1260 | StorageType Storage, bool ShouldCreate) { |
1261 | assert(isCanonical(Name) && "Expected canonical MDString" ); |
1262 | DEFINE_GETIMPL_LOOKUP(DITemplateTypeParameter, (Name, Type, isDefault)); |
1263 | Metadata *Ops[] = {Name, Type}; |
1264 | DEFINE_GETIMPL_STORE(DITemplateTypeParameter, (isDefault), Ops); |
1265 | } |
1266 | |
1267 | DITemplateValueParameter *DITemplateValueParameter::getImpl( |
1268 | LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *Type, |
1269 | bool isDefault, Metadata *Value, StorageType Storage, bool ShouldCreate) { |
1270 | assert(isCanonical(Name) && "Expected canonical MDString" ); |
1271 | DEFINE_GETIMPL_LOOKUP(DITemplateValueParameter, |
1272 | (Tag, Name, Type, isDefault, Value)); |
1273 | Metadata *Ops[] = {Name, Type, Value}; |
1274 | DEFINE_GETIMPL_STORE(DITemplateValueParameter, (Tag, isDefault), Ops); |
1275 | } |
1276 | |
1277 | DIGlobalVariable * |
1278 | DIGlobalVariable::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name, |
1279 | MDString *LinkageName, Metadata *File, unsigned Line, |
1280 | Metadata *Type, bool IsLocalToUnit, bool IsDefinition, |
1281 | Metadata *StaticDataMemberDeclaration, |
1282 | Metadata *TemplateParams, uint32_t AlignInBits, |
1283 | Metadata *Annotations, StorageType Storage, |
1284 | bool ShouldCreate) { |
1285 | assert(isCanonical(Name) && "Expected canonical MDString" ); |
1286 | assert(isCanonical(LinkageName) && "Expected canonical MDString" ); |
1287 | DEFINE_GETIMPL_LOOKUP( |
1288 | DIGlobalVariable, |
1289 | (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition, |
1290 | StaticDataMemberDeclaration, TemplateParams, AlignInBits, Annotations)); |
1291 | Metadata *Ops[] = {Scope, |
1292 | Name, |
1293 | File, |
1294 | Type, |
1295 | Name, |
1296 | LinkageName, |
1297 | StaticDataMemberDeclaration, |
1298 | TemplateParams, |
1299 | Annotations}; |
1300 | DEFINE_GETIMPL_STORE(DIGlobalVariable, |
1301 | (Line, IsLocalToUnit, IsDefinition, AlignInBits), Ops); |
1302 | } |
1303 | |
1304 | DILocalVariable * |
1305 | DILocalVariable::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name, |
1306 | Metadata *File, unsigned Line, Metadata *Type, |
1307 | unsigned Arg, DIFlags Flags, uint32_t AlignInBits, |
1308 | Metadata *Annotations, StorageType Storage, |
1309 | bool ShouldCreate) { |
1310 | // 64K ought to be enough for any frontend. |
1311 | assert(Arg <= UINT16_MAX && "Expected argument number to fit in 16-bits" ); |
1312 | |
1313 | assert(Scope && "Expected scope" ); |
1314 | assert(isCanonical(Name) && "Expected canonical MDString" ); |
1315 | DEFINE_GETIMPL_LOOKUP(DILocalVariable, (Scope, Name, File, Line, Type, Arg, |
1316 | Flags, AlignInBits, Annotations)); |
1317 | Metadata *Ops[] = {Scope, Name, File, Type, Annotations}; |
1318 | DEFINE_GETIMPL_STORE(DILocalVariable, (Line, Arg, Flags, AlignInBits), Ops); |
1319 | } |
1320 | |
1321 | DIVariable::DIVariable(LLVMContext &C, unsigned ID, StorageType Storage, |
1322 | signed Line, ArrayRef<Metadata *> Ops, |
1323 | uint32_t AlignInBits) |
1324 | : DINode(C, ID, Storage, dwarf::DW_TAG_variable, Ops), Line(Line) { |
1325 | SubclassData32 = AlignInBits; |
1326 | } |
1327 | std::optional<uint64_t> DIVariable::getSizeInBits() const { |
1328 | // This is used by the Verifier so be mindful of broken types. |
1329 | const Metadata *RawType = getRawType(); |
1330 | while (RawType) { |
1331 | // Try to get the size directly. |
1332 | if (auto *T = dyn_cast<DIType>(Val: RawType)) |
1333 | if (uint64_t Size = T->getSizeInBits()) |
1334 | return Size; |
1335 | |
1336 | if (auto *DT = dyn_cast<DIDerivedType>(Val: RawType)) { |
1337 | // Look at the base type. |
1338 | RawType = DT->getRawBaseType(); |
1339 | continue; |
1340 | } |
1341 | |
1342 | // Missing type or size. |
1343 | break; |
1344 | } |
1345 | |
1346 | // Fail gracefully. |
1347 | return std::nullopt; |
1348 | } |
1349 | |
1350 | DILabel::DILabel(LLVMContext &C, StorageType Storage, unsigned Line, |
1351 | ArrayRef<Metadata *> Ops) |
1352 | : DINode(C, DILabelKind, Storage, dwarf::DW_TAG_label, Ops) { |
1353 | SubclassData32 = Line; |
1354 | } |
1355 | DILabel *DILabel::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name, |
1356 | Metadata *File, unsigned Line, StorageType Storage, |
1357 | bool ShouldCreate) { |
1358 | assert(Scope && "Expected scope" ); |
1359 | assert(isCanonical(Name) && "Expected canonical MDString" ); |
1360 | DEFINE_GETIMPL_LOOKUP(DILabel, (Scope, Name, File, Line)); |
1361 | Metadata *Ops[] = {Scope, Name, File}; |
1362 | DEFINE_GETIMPL_STORE(DILabel, (Line), Ops); |
1363 | } |
1364 | |
1365 | DIExpression *DIExpression::getImpl(LLVMContext &Context, |
1366 | ArrayRef<uint64_t> Elements, |
1367 | StorageType Storage, bool ShouldCreate) { |
1368 | DEFINE_GETIMPL_LOOKUP(DIExpression, (Elements)); |
1369 | DEFINE_GETIMPL_STORE_NO_OPS(DIExpression, (Elements)); |
1370 | } |
1371 | bool DIExpression::isEntryValue() const { |
1372 | if (auto singleLocElts = getSingleLocationExpressionElements()) { |
1373 | return singleLocElts->size() > 0 && |
1374 | (*singleLocElts)[0] == dwarf::DW_OP_LLVM_entry_value; |
1375 | } |
1376 | return false; |
1377 | } |
1378 | bool DIExpression::startsWithDeref() const { |
1379 | if (auto singleLocElts = getSingleLocationExpressionElements()) |
1380 | return singleLocElts->size() > 0 && |
1381 | (*singleLocElts)[0] == dwarf::DW_OP_deref; |
1382 | return false; |
1383 | } |
1384 | bool DIExpression::isDeref() const { |
1385 | if (auto singleLocElts = getSingleLocationExpressionElements()) |
1386 | return singleLocElts->size() == 1 && |
1387 | (*singleLocElts)[0] == dwarf::DW_OP_deref; |
1388 | return false; |
1389 | } |
1390 | |
1391 | DIAssignID *DIAssignID::getImpl(LLVMContext &Context, StorageType Storage, |
1392 | bool ShouldCreate) { |
1393 | // Uniqued DIAssignID are not supported as the instance address *is* the ID. |
1394 | assert(Storage != StorageType::Uniqued && "uniqued DIAssignID unsupported" ); |
1395 | return storeImpl(N: new (0u, Storage) DIAssignID(Context, Storage), Storage); |
1396 | } |
1397 | |
1398 | unsigned DIExpression::ExprOperand::getSize() const { |
1399 | uint64_t Op = getOp(); |
1400 | |
1401 | if (Op >= dwarf::DW_OP_breg0 && Op <= dwarf::DW_OP_breg31) |
1402 | return 2; |
1403 | |
1404 | switch (Op) { |
1405 | case dwarf::DW_OP_LLVM_convert: |
1406 | case dwarf::DW_OP_LLVM_fragment: |
1407 | case dwarf::DW_OP_bregx: |
1408 | return 3; |
1409 | case dwarf::DW_OP_constu: |
1410 | case dwarf::DW_OP_consts: |
1411 | case dwarf::DW_OP_deref_size: |
1412 | case dwarf::DW_OP_plus_uconst: |
1413 | case dwarf::DW_OP_LLVM_tag_offset: |
1414 | case dwarf::DW_OP_LLVM_entry_value: |
1415 | case dwarf::DW_OP_LLVM_arg: |
1416 | case dwarf::DW_OP_regx: |
1417 | return 2; |
1418 | default: |
1419 | return 1; |
1420 | } |
1421 | } |
1422 | |
1423 | bool DIExpression::isValid() const { |
1424 | for (auto I = expr_op_begin(), E = expr_op_end(); I != E; ++I) { |
1425 | // Check that there's space for the operand. |
1426 | if (I->get() + I->getSize() > E->get()) |
1427 | return false; |
1428 | |
1429 | uint64_t Op = I->getOp(); |
1430 | if ((Op >= dwarf::DW_OP_reg0 && Op <= dwarf::DW_OP_reg31) || |
1431 | (Op >= dwarf::DW_OP_breg0 && Op <= dwarf::DW_OP_breg31)) |
1432 | return true; |
1433 | |
1434 | // Check that the operand is valid. |
1435 | switch (Op) { |
1436 | default: |
1437 | return false; |
1438 | case dwarf::DW_OP_LLVM_fragment: |
1439 | // A fragment operator must appear at the end. |
1440 | return I->get() + I->getSize() == E->get(); |
1441 | case dwarf::DW_OP_stack_value: { |
1442 | // Must be the last one or followed by a DW_OP_LLVM_fragment. |
1443 | if (I->get() + I->getSize() == E->get()) |
1444 | break; |
1445 | auto J = I; |
1446 | if ((++J)->getOp() != dwarf::DW_OP_LLVM_fragment) |
1447 | return false; |
1448 | break; |
1449 | } |
1450 | case dwarf::DW_OP_swap: { |
1451 | // Must be more than one implicit element on the stack. |
1452 | |
1453 | // FIXME: A better way to implement this would be to add a local variable |
1454 | // that keeps track of the stack depth and introduce something like a |
1455 | // DW_LLVM_OP_implicit_location as a placeholder for the location this |
1456 | // DIExpression is attached to, or else pass the number of implicit stack |
1457 | // elements into isValid. |
1458 | if (getNumElements() == 1) |
1459 | return false; |
1460 | break; |
1461 | } |
1462 | case dwarf::DW_OP_LLVM_entry_value: { |
1463 | // An entry value operator must appear at the beginning or immediately |
1464 | // following `DW_OP_LLVM_arg 0`, and the number of operations it cover can |
1465 | // currently only be 1, because we support only entry values of a simple |
1466 | // register location. One reason for this is that we currently can't |
1467 | // calculate the size of the resulting DWARF block for other expressions. |
1468 | auto FirstOp = expr_op_begin(); |
1469 | if (FirstOp->getOp() == dwarf::DW_OP_LLVM_arg && FirstOp->getArg(I: 0) == 0) |
1470 | ++FirstOp; |
1471 | return I->get() == FirstOp->get() && I->getArg(I: 0) == 1; |
1472 | } |
1473 | case dwarf::DW_OP_LLVM_implicit_pointer: |
1474 | case dwarf::DW_OP_LLVM_convert: |
1475 | case dwarf::DW_OP_LLVM_arg: |
1476 | case dwarf::DW_OP_LLVM_tag_offset: |
1477 | case dwarf::DW_OP_constu: |
1478 | case dwarf::DW_OP_plus_uconst: |
1479 | case dwarf::DW_OP_plus: |
1480 | case dwarf::DW_OP_minus: |
1481 | case dwarf::DW_OP_mul: |
1482 | case dwarf::DW_OP_div: |
1483 | case dwarf::DW_OP_mod: |
1484 | case dwarf::DW_OP_or: |
1485 | case dwarf::DW_OP_and: |
1486 | case dwarf::DW_OP_xor: |
1487 | case dwarf::DW_OP_shl: |
1488 | case dwarf::DW_OP_shr: |
1489 | case dwarf::DW_OP_shra: |
1490 | case dwarf::DW_OP_deref: |
1491 | case dwarf::DW_OP_deref_size: |
1492 | case dwarf::DW_OP_xderef: |
1493 | case dwarf::DW_OP_lit0: |
1494 | case dwarf::DW_OP_not: |
1495 | case dwarf::DW_OP_dup: |
1496 | case dwarf::DW_OP_regx: |
1497 | case dwarf::DW_OP_bregx: |
1498 | case dwarf::DW_OP_push_object_address: |
1499 | case dwarf::DW_OP_over: |
1500 | case dwarf::DW_OP_consts: |
1501 | case dwarf::DW_OP_eq: |
1502 | case dwarf::DW_OP_ne: |
1503 | case dwarf::DW_OP_gt: |
1504 | case dwarf::DW_OP_ge: |
1505 | case dwarf::DW_OP_lt: |
1506 | case dwarf::DW_OP_le: |
1507 | break; |
1508 | } |
1509 | } |
1510 | return true; |
1511 | } |
1512 | |
1513 | bool DIExpression::isImplicit() const { |
1514 | if (!isValid()) |
1515 | return false; |
1516 | |
1517 | if (getNumElements() == 0) |
1518 | return false; |
1519 | |
1520 | for (const auto &It : expr_ops()) { |
1521 | switch (It.getOp()) { |
1522 | default: |
1523 | break; |
1524 | case dwarf::DW_OP_stack_value: |
1525 | return true; |
1526 | } |
1527 | } |
1528 | |
1529 | return false; |
1530 | } |
1531 | |
1532 | bool DIExpression::isComplex() const { |
1533 | if (!isValid()) |
1534 | return false; |
1535 | |
1536 | if (getNumElements() == 0) |
1537 | return false; |
1538 | |
1539 | // If there are any elements other than fragment or tag_offset, then some |
1540 | // kind of complex computation occurs. |
1541 | for (const auto &It : expr_ops()) { |
1542 | switch (It.getOp()) { |
1543 | case dwarf::DW_OP_LLVM_tag_offset: |
1544 | case dwarf::DW_OP_LLVM_fragment: |
1545 | case dwarf::DW_OP_LLVM_arg: |
1546 | continue; |
1547 | default: |
1548 | return true; |
1549 | } |
1550 | } |
1551 | |
1552 | return false; |
1553 | } |
1554 | |
1555 | bool DIExpression::isSingleLocationExpression() const { |
1556 | if (!isValid()) |
1557 | return false; |
1558 | |
1559 | if (getNumElements() == 0) |
1560 | return true; |
1561 | |
1562 | auto ExprOpBegin = expr_ops().begin(); |
1563 | auto ExprOpEnd = expr_ops().end(); |
1564 | if (ExprOpBegin->getOp() == dwarf::DW_OP_LLVM_arg) { |
1565 | if (ExprOpBegin->getArg(I: 0) != 0) |
1566 | return false; |
1567 | ++ExprOpBegin; |
1568 | } |
1569 | |
1570 | return !std::any_of(first: ExprOpBegin, last: ExprOpEnd, pred: [](auto Op) { |
1571 | return Op.getOp() == dwarf::DW_OP_LLVM_arg; |
1572 | }); |
1573 | } |
1574 | |
1575 | std::optional<ArrayRef<uint64_t>> |
1576 | DIExpression::getSingleLocationExpressionElements() const { |
1577 | // Check for `isValid` covered by `isSingleLocationExpression`. |
1578 | if (!isSingleLocationExpression()) |
1579 | return std::nullopt; |
1580 | |
1581 | // An empty expression is already non-variadic. |
1582 | if (!getNumElements()) |
1583 | return ArrayRef<uint64_t>(); |
1584 | |
1585 | // If Expr does not have a leading DW_OP_LLVM_arg then we don't need to do |
1586 | // anything. |
1587 | if (getElements()[0] == dwarf::DW_OP_LLVM_arg) |
1588 | return getElements().drop_front(N: 2); |
1589 | return getElements(); |
1590 | } |
1591 | |
1592 | const DIExpression * |
1593 | DIExpression::convertToUndefExpression(const DIExpression *Expr) { |
1594 | SmallVector<uint64_t, 3> UndefOps; |
1595 | if (auto FragmentInfo = Expr->getFragmentInfo()) { |
1596 | UndefOps.append(IL: {dwarf::DW_OP_LLVM_fragment, FragmentInfo->OffsetInBits, |
1597 | FragmentInfo->SizeInBits}); |
1598 | } |
1599 | return DIExpression::get(Context&: Expr->getContext(), Elements: UndefOps); |
1600 | } |
1601 | |
1602 | const DIExpression * |
1603 | DIExpression::convertToVariadicExpression(const DIExpression *Expr) { |
1604 | if (any_of(Range: Expr->expr_ops(), P: [](auto ExprOp) { |
1605 | return ExprOp.getOp() == dwarf::DW_OP_LLVM_arg; |
1606 | })) |
1607 | return Expr; |
1608 | SmallVector<uint64_t> NewOps; |
1609 | NewOps.reserve(N: Expr->getNumElements() + 2); |
1610 | NewOps.append(IL: {dwarf::DW_OP_LLVM_arg, 0}); |
1611 | NewOps.append(in_start: Expr->elements_begin(), in_end: Expr->elements_end()); |
1612 | return DIExpression::get(Context&: Expr->getContext(), Elements: NewOps); |
1613 | } |
1614 | |
1615 | std::optional<const DIExpression *> |
1616 | DIExpression::convertToNonVariadicExpression(const DIExpression *Expr) { |
1617 | if (!Expr) |
1618 | return std::nullopt; |
1619 | |
1620 | if (auto Elts = Expr->getSingleLocationExpressionElements()) |
1621 | return DIExpression::get(Context&: Expr->getContext(), Elements: *Elts); |
1622 | |
1623 | return std::nullopt; |
1624 | } |
1625 | |
1626 | void DIExpression::canonicalizeExpressionOps(SmallVectorImpl<uint64_t> &Ops, |
1627 | const DIExpression *Expr, |
1628 | bool IsIndirect) { |
1629 | // If Expr is not already variadic, insert the implied `DW_OP_LLVM_arg 0` |
1630 | // to the existing expression ops. |
1631 | if (none_of(Range: Expr->expr_ops(), P: [](auto ExprOp) { |
1632 | return ExprOp.getOp() == dwarf::DW_OP_LLVM_arg; |
1633 | })) |
1634 | Ops.append(IL: {dwarf::DW_OP_LLVM_arg, 0}); |
1635 | // If Expr is not indirect, we only need to insert the expression elements and |
1636 | // we're done. |
1637 | if (!IsIndirect) { |
1638 | Ops.append(in_start: Expr->elements_begin(), in_end: Expr->elements_end()); |
1639 | return; |
1640 | } |
1641 | // If Expr is indirect, insert the implied DW_OP_deref at the end of the |
1642 | // expression but before DW_OP_{stack_value, LLVM_fragment} if they are |
1643 | // present. |
1644 | for (auto Op : Expr->expr_ops()) { |
1645 | if (Op.getOp() == dwarf::DW_OP_stack_value || |
1646 | Op.getOp() == dwarf::DW_OP_LLVM_fragment) { |
1647 | Ops.push_back(Elt: dwarf::DW_OP_deref); |
1648 | IsIndirect = false; |
1649 | } |
1650 | Op.appendToVector(V&: Ops); |
1651 | } |
1652 | if (IsIndirect) |
1653 | Ops.push_back(Elt: dwarf::DW_OP_deref); |
1654 | } |
1655 | |
1656 | bool DIExpression::isEqualExpression(const DIExpression *FirstExpr, |
1657 | bool FirstIndirect, |
1658 | const DIExpression *SecondExpr, |
1659 | bool SecondIndirect) { |
1660 | SmallVector<uint64_t> FirstOps; |
1661 | DIExpression::canonicalizeExpressionOps(Ops&: FirstOps, Expr: FirstExpr, IsIndirect: FirstIndirect); |
1662 | SmallVector<uint64_t> SecondOps; |
1663 | DIExpression::canonicalizeExpressionOps(Ops&: SecondOps, Expr: SecondExpr, |
1664 | IsIndirect: SecondIndirect); |
1665 | return FirstOps == SecondOps; |
1666 | } |
1667 | |
1668 | std::optional<DIExpression::FragmentInfo> |
1669 | DIExpression::getFragmentInfo(expr_op_iterator Start, expr_op_iterator End) { |
1670 | for (auto I = Start; I != End; ++I) |
1671 | if (I->getOp() == dwarf::DW_OP_LLVM_fragment) { |
1672 | DIExpression::FragmentInfo Info = {I->getArg(I: 1), I->getArg(I: 0)}; |
1673 | return Info; |
1674 | } |
1675 | return std::nullopt; |
1676 | } |
1677 | |
1678 | void DIExpression::appendOffset(SmallVectorImpl<uint64_t> &Ops, |
1679 | int64_t Offset) { |
1680 | if (Offset > 0) { |
1681 | Ops.push_back(Elt: dwarf::DW_OP_plus_uconst); |
1682 | Ops.push_back(Elt: Offset); |
1683 | } else if (Offset < 0) { |
1684 | Ops.push_back(Elt: dwarf::DW_OP_constu); |
1685 | // Avoid UB when encountering LLONG_MIN, because in 2's complement |
1686 | // abs(LLONG_MIN) is LLONG_MAX+1. |
1687 | uint64_t AbsMinusOne = -(Offset+1); |
1688 | Ops.push_back(Elt: AbsMinusOne + 1); |
1689 | Ops.push_back(Elt: dwarf::DW_OP_minus); |
1690 | } |
1691 | } |
1692 | |
1693 | bool DIExpression::(int64_t &Offset) const { |
1694 | auto SingleLocEltsOpt = getSingleLocationExpressionElements(); |
1695 | if (!SingleLocEltsOpt) |
1696 | return false; |
1697 | auto SingleLocElts = *SingleLocEltsOpt; |
1698 | |
1699 | if (SingleLocElts.size() == 0) { |
1700 | Offset = 0; |
1701 | return true; |
1702 | } |
1703 | |
1704 | if (SingleLocElts.size() == 2 && |
1705 | SingleLocElts[0] == dwarf::DW_OP_plus_uconst) { |
1706 | Offset = SingleLocElts[1]; |
1707 | return true; |
1708 | } |
1709 | |
1710 | if (SingleLocElts.size() == 3 && SingleLocElts[0] == dwarf::DW_OP_constu) { |
1711 | if (SingleLocElts[2] == dwarf::DW_OP_plus) { |
1712 | Offset = SingleLocElts[1]; |
1713 | return true; |
1714 | } |
1715 | if (SingleLocElts[2] == dwarf::DW_OP_minus) { |
1716 | Offset = -SingleLocElts[1]; |
1717 | return true; |
1718 | } |
1719 | } |
1720 | |
1721 | return false; |
1722 | } |
1723 | |
1724 | bool DIExpression::hasAllLocationOps(unsigned N) const { |
1725 | SmallDenseSet<uint64_t, 4> SeenOps; |
1726 | for (auto ExprOp : expr_ops()) |
1727 | if (ExprOp.getOp() == dwarf::DW_OP_LLVM_arg) |
1728 | SeenOps.insert(V: ExprOp.getArg(I: 0)); |
1729 | for (uint64_t Idx = 0; Idx < N; ++Idx) |
1730 | if (!SeenOps.contains(V: Idx)) |
1731 | return false; |
1732 | return true; |
1733 | } |
1734 | |
1735 | const DIExpression *DIExpression::(const DIExpression *Expr, |
1736 | unsigned &AddrClass) { |
1737 | // FIXME: This seems fragile. Nothing that verifies that these elements |
1738 | // actually map to ops and not operands. |
1739 | auto SingleLocEltsOpt = Expr->getSingleLocationExpressionElements(); |
1740 | if (!SingleLocEltsOpt) |
1741 | return nullptr; |
1742 | auto SingleLocElts = *SingleLocEltsOpt; |
1743 | |
1744 | const unsigned PatternSize = 4; |
1745 | if (SingleLocElts.size() >= PatternSize && |
1746 | SingleLocElts[PatternSize - 4] == dwarf::DW_OP_constu && |
1747 | SingleLocElts[PatternSize - 2] == dwarf::DW_OP_swap && |
1748 | SingleLocElts[PatternSize - 1] == dwarf::DW_OP_xderef) { |
1749 | AddrClass = SingleLocElts[PatternSize - 3]; |
1750 | |
1751 | if (SingleLocElts.size() == PatternSize) |
1752 | return nullptr; |
1753 | return DIExpression::get( |
1754 | Context&: Expr->getContext(), |
1755 | Elements: ArrayRef(&*SingleLocElts.begin(), SingleLocElts.size() - PatternSize)); |
1756 | } |
1757 | return Expr; |
1758 | } |
1759 | |
1760 | DIExpression *DIExpression::prepend(const DIExpression *Expr, uint8_t Flags, |
1761 | int64_t Offset) { |
1762 | SmallVector<uint64_t, 8> Ops; |
1763 | if (Flags & DIExpression::DerefBefore) |
1764 | Ops.push_back(Elt: dwarf::DW_OP_deref); |
1765 | |
1766 | appendOffset(Ops, Offset); |
1767 | if (Flags & DIExpression::DerefAfter) |
1768 | Ops.push_back(Elt: dwarf::DW_OP_deref); |
1769 | |
1770 | bool StackValue = Flags & DIExpression::StackValue; |
1771 | bool EntryValue = Flags & DIExpression::EntryValue; |
1772 | |
1773 | return prependOpcodes(Expr, Ops, StackValue, EntryValue); |
1774 | } |
1775 | |
1776 | DIExpression *DIExpression::appendOpsToArg(const DIExpression *Expr, |
1777 | ArrayRef<uint64_t> Ops, |
1778 | unsigned ArgNo, bool StackValue) { |
1779 | assert(Expr && "Can't add ops to this expression" ); |
1780 | |
1781 | // Handle non-variadic intrinsics by prepending the opcodes. |
1782 | if (!any_of(Range: Expr->expr_ops(), |
1783 | P: [](auto Op) { return Op.getOp() == dwarf::DW_OP_LLVM_arg; })) { |
1784 | assert(ArgNo == 0 && |
1785 | "Location Index must be 0 for a non-variadic expression." ); |
1786 | SmallVector<uint64_t, 8> NewOps(Ops.begin(), Ops.end()); |
1787 | return DIExpression::prependOpcodes(Expr, Ops&: NewOps, StackValue); |
1788 | } |
1789 | |
1790 | SmallVector<uint64_t, 8> NewOps; |
1791 | for (auto Op : Expr->expr_ops()) { |
1792 | // A DW_OP_stack_value comes at the end, but before a DW_OP_LLVM_fragment. |
1793 | if (StackValue) { |
1794 | if (Op.getOp() == dwarf::DW_OP_stack_value) |
1795 | StackValue = false; |
1796 | else if (Op.getOp() == dwarf::DW_OP_LLVM_fragment) { |
1797 | NewOps.push_back(Elt: dwarf::DW_OP_stack_value); |
1798 | StackValue = false; |
1799 | } |
1800 | } |
1801 | Op.appendToVector(V&: NewOps); |
1802 | if (Op.getOp() == dwarf::DW_OP_LLVM_arg && Op.getArg(I: 0) == ArgNo) |
1803 | NewOps.insert(I: NewOps.end(), From: Ops.begin(), To: Ops.end()); |
1804 | } |
1805 | if (StackValue) |
1806 | NewOps.push_back(Elt: dwarf::DW_OP_stack_value); |
1807 | |
1808 | return DIExpression::get(Context&: Expr->getContext(), Elements: NewOps); |
1809 | } |
1810 | |
1811 | DIExpression *DIExpression::replaceArg(const DIExpression *Expr, |
1812 | uint64_t OldArg, uint64_t NewArg) { |
1813 | assert(Expr && "Can't replace args in this expression" ); |
1814 | |
1815 | SmallVector<uint64_t, 8> NewOps; |
1816 | |
1817 | for (auto Op : Expr->expr_ops()) { |
1818 | if (Op.getOp() != dwarf::DW_OP_LLVM_arg || Op.getArg(I: 0) < OldArg) { |
1819 | Op.appendToVector(V&: NewOps); |
1820 | continue; |
1821 | } |
1822 | NewOps.push_back(Elt: dwarf::DW_OP_LLVM_arg); |
1823 | uint64_t Arg = Op.getArg(I: 0) == OldArg ? NewArg : Op.getArg(I: 0); |
1824 | // OldArg has been deleted from the Op list, so decrement all indices |
1825 | // greater than it. |
1826 | if (Arg > OldArg) |
1827 | --Arg; |
1828 | NewOps.push_back(Elt: Arg); |
1829 | } |
1830 | return DIExpression::get(Context&: Expr->getContext(), Elements: NewOps); |
1831 | } |
1832 | |
1833 | DIExpression *DIExpression::prependOpcodes(const DIExpression *Expr, |
1834 | SmallVectorImpl<uint64_t> &Ops, |
1835 | bool StackValue, bool EntryValue) { |
1836 | assert(Expr && "Can't prepend ops to this expression" ); |
1837 | |
1838 | if (EntryValue) { |
1839 | Ops.push_back(Elt: dwarf::DW_OP_LLVM_entry_value); |
1840 | // Use a block size of 1 for the target register operand. The |
1841 | // DWARF backend currently cannot emit entry values with a block |
1842 | // size > 1. |
1843 | Ops.push_back(Elt: 1); |
1844 | } |
1845 | |
1846 | // If there are no ops to prepend, do not even add the DW_OP_stack_value. |
1847 | if (Ops.empty()) |
1848 | StackValue = false; |
1849 | for (auto Op : Expr->expr_ops()) { |
1850 | // A DW_OP_stack_value comes at the end, but before a DW_OP_LLVM_fragment. |
1851 | if (StackValue) { |
1852 | if (Op.getOp() == dwarf::DW_OP_stack_value) |
1853 | StackValue = false; |
1854 | else if (Op.getOp() == dwarf::DW_OP_LLVM_fragment) { |
1855 | Ops.push_back(Elt: dwarf::DW_OP_stack_value); |
1856 | StackValue = false; |
1857 | } |
1858 | } |
1859 | Op.appendToVector(V&: Ops); |
1860 | } |
1861 | if (StackValue) |
1862 | Ops.push_back(Elt: dwarf::DW_OP_stack_value); |
1863 | return DIExpression::get(Context&: Expr->getContext(), Elements: Ops); |
1864 | } |
1865 | |
1866 | DIExpression *DIExpression::append(const DIExpression *Expr, |
1867 | ArrayRef<uint64_t> Ops) { |
1868 | assert(Expr && !Ops.empty() && "Can't append ops to this expression" ); |
1869 | |
1870 | // Copy Expr's current op list. |
1871 | SmallVector<uint64_t, 16> NewOps; |
1872 | for (auto Op : Expr->expr_ops()) { |
1873 | // Append new opcodes before DW_OP_{stack_value, LLVM_fragment}. |
1874 | if (Op.getOp() == dwarf::DW_OP_stack_value || |
1875 | Op.getOp() == dwarf::DW_OP_LLVM_fragment) { |
1876 | NewOps.append(in_start: Ops.begin(), in_end: Ops.end()); |
1877 | |
1878 | // Ensure that the new opcodes are only appended once. |
1879 | Ops = std::nullopt; |
1880 | } |
1881 | Op.appendToVector(V&: NewOps); |
1882 | } |
1883 | |
1884 | NewOps.append(in_start: Ops.begin(), in_end: Ops.end()); |
1885 | auto *result = DIExpression::get(Context&: Expr->getContext(), Elements: NewOps); |
1886 | assert(result->isValid() && "concatenated expression is not valid" ); |
1887 | return result; |
1888 | } |
1889 | |
1890 | DIExpression *DIExpression::appendToStack(const DIExpression *Expr, |
1891 | ArrayRef<uint64_t> Ops) { |
1892 | assert(Expr && !Ops.empty() && "Can't append ops to this expression" ); |
1893 | assert(std::none_of(expr_op_iterator(Ops.begin()), |
1894 | expr_op_iterator(Ops.end()), |
1895 | [](auto Op) { |
1896 | return Op.getOp() == dwarf::DW_OP_stack_value || |
1897 | Op.getOp() == dwarf::DW_OP_LLVM_fragment; |
1898 | }) && |
1899 | "Can't append this op" ); |
1900 | |
1901 | // Append a DW_OP_deref after Expr's current op list if it's non-empty and |
1902 | // has no DW_OP_stack_value. |
1903 | // |
1904 | // Match .* DW_OP_stack_value (DW_OP_LLVM_fragment A B)?. |
1905 | std::optional<FragmentInfo> FI = Expr->getFragmentInfo(); |
1906 | unsigned DropUntilStackValue = FI ? 3 : 0; |
1907 | ArrayRef<uint64_t> ExprOpsBeforeFragment = |
1908 | Expr->getElements().drop_back(N: DropUntilStackValue); |
1909 | bool NeedsDeref = (Expr->getNumElements() > DropUntilStackValue) && |
1910 | (ExprOpsBeforeFragment.back() != dwarf::DW_OP_stack_value); |
1911 | bool NeedsStackValue = NeedsDeref || ExprOpsBeforeFragment.empty(); |
1912 | |
1913 | // Append a DW_OP_deref after Expr's current op list if needed, then append |
1914 | // the new ops, and finally ensure that a single DW_OP_stack_value is present. |
1915 | SmallVector<uint64_t, 16> NewOps; |
1916 | if (NeedsDeref) |
1917 | NewOps.push_back(Elt: dwarf::DW_OP_deref); |
1918 | NewOps.append(in_start: Ops.begin(), in_end: Ops.end()); |
1919 | if (NeedsStackValue) |
1920 | NewOps.push_back(Elt: dwarf::DW_OP_stack_value); |
1921 | return DIExpression::append(Expr, Ops: NewOps); |
1922 | } |
1923 | |
1924 | std::optional<DIExpression *> DIExpression::createFragmentExpression( |
1925 | const DIExpression *Expr, unsigned OffsetInBits, unsigned SizeInBits) { |
1926 | SmallVector<uint64_t, 8> Ops; |
1927 | // Track whether it's safe to split the value at the top of the DWARF stack, |
1928 | // assuming that it'll be used as an implicit location value. |
1929 | bool CanSplitValue = true; |
1930 | // Copy over the expression, but leave off any trailing DW_OP_LLVM_fragment. |
1931 | if (Expr) { |
1932 | for (auto Op : Expr->expr_ops()) { |
1933 | switch (Op.getOp()) { |
1934 | default: |
1935 | break; |
1936 | case dwarf::DW_OP_shr: |
1937 | case dwarf::DW_OP_shra: |
1938 | case dwarf::DW_OP_shl: |
1939 | case dwarf::DW_OP_plus: |
1940 | case dwarf::DW_OP_plus_uconst: |
1941 | case dwarf::DW_OP_minus: |
1942 | // We can't safely split arithmetic or shift operations into multiple |
1943 | // fragments because we can't express carry-over between fragments. |
1944 | // |
1945 | // FIXME: We *could* preserve the lowest fragment of a constant offset |
1946 | // operation if the offset fits into SizeInBits. |
1947 | CanSplitValue = false; |
1948 | break; |
1949 | case dwarf::DW_OP_deref: |
1950 | case dwarf::DW_OP_deref_size: |
1951 | case dwarf::DW_OP_deref_type: |
1952 | case dwarf::DW_OP_xderef: |
1953 | case dwarf::DW_OP_xderef_size: |
1954 | case dwarf::DW_OP_xderef_type: |
1955 | // Preceeding arithmetic operations have been applied to compute an |
1956 | // address. It's okay to split the value loaded from that address. |
1957 | CanSplitValue = true; |
1958 | break; |
1959 | case dwarf::DW_OP_stack_value: |
1960 | // Bail if this expression computes a value that cannot be split. |
1961 | if (!CanSplitValue) |
1962 | return std::nullopt; |
1963 | break; |
1964 | case dwarf::DW_OP_LLVM_fragment: { |
1965 | // Make the new offset point into the existing fragment. |
1966 | uint64_t FragmentOffsetInBits = Op.getArg(I: 0); |
1967 | uint64_t FragmentSizeInBits = Op.getArg(I: 1); |
1968 | (void)FragmentSizeInBits; |
1969 | assert((OffsetInBits + SizeInBits <= FragmentSizeInBits) && |
1970 | "new fragment outside of original fragment" ); |
1971 | OffsetInBits += FragmentOffsetInBits; |
1972 | continue; |
1973 | } |
1974 | } |
1975 | Op.appendToVector(V&: Ops); |
1976 | } |
1977 | } |
1978 | assert((!Expr->isImplicit() || CanSplitValue) && "Expr can't be split" ); |
1979 | assert(Expr && "Unknown DIExpression" ); |
1980 | Ops.push_back(Elt: dwarf::DW_OP_LLVM_fragment); |
1981 | Ops.push_back(Elt: OffsetInBits); |
1982 | Ops.push_back(Elt: SizeInBits); |
1983 | return DIExpression::get(Context&: Expr->getContext(), Elements: Ops); |
1984 | } |
1985 | |
1986 | std::pair<DIExpression *, const ConstantInt *> |
1987 | DIExpression::constantFold(const ConstantInt *CI) { |
1988 | // Copy the APInt so we can modify it. |
1989 | APInt NewInt = CI->getValue(); |
1990 | SmallVector<uint64_t, 8> Ops; |
1991 | |
1992 | // Fold operators only at the beginning of the expression. |
1993 | bool First = true; |
1994 | bool Changed = false; |
1995 | for (auto Op : expr_ops()) { |
1996 | switch (Op.getOp()) { |
1997 | default: |
1998 | // We fold only the leading part of the expression; if we get to a part |
1999 | // that we're going to copy unchanged, and haven't done any folding, |
2000 | // then the entire expression is unchanged and we can return early. |
2001 | if (!Changed) |
2002 | return {this, CI}; |
2003 | First = false; |
2004 | break; |
2005 | case dwarf::DW_OP_LLVM_convert: |
2006 | if (!First) |
2007 | break; |
2008 | Changed = true; |
2009 | if (Op.getArg(I: 1) == dwarf::DW_ATE_signed) |
2010 | NewInt = NewInt.sextOrTrunc(width: Op.getArg(I: 0)); |
2011 | else { |
2012 | assert(Op.getArg(1) == dwarf::DW_ATE_unsigned && "Unexpected operand" ); |
2013 | NewInt = NewInt.zextOrTrunc(width: Op.getArg(I: 0)); |
2014 | } |
2015 | continue; |
2016 | } |
2017 | Op.appendToVector(V&: Ops); |
2018 | } |
2019 | if (!Changed) |
2020 | return {this, CI}; |
2021 | return {DIExpression::get(Context&: getContext(), Elements: Ops), |
2022 | ConstantInt::get(Context&: getContext(), V: NewInt)}; |
2023 | } |
2024 | |
2025 | uint64_t DIExpression::getNumLocationOperands() const { |
2026 | uint64_t Result = 0; |
2027 | for (auto ExprOp : expr_ops()) |
2028 | if (ExprOp.getOp() == dwarf::DW_OP_LLVM_arg) |
2029 | Result = std::max(a: Result, b: ExprOp.getArg(I: 0) + 1); |
2030 | assert(hasAllLocationOps(Result) && |
2031 | "Expression is missing one or more location operands." ); |
2032 | return Result; |
2033 | } |
2034 | |
2035 | std::optional<DIExpression::SignedOrUnsignedConstant> |
2036 | DIExpression::isConstant() const { |
2037 | |
2038 | // Recognize signed and unsigned constants. |
2039 | // An signed constants can be represented as DW_OP_consts C DW_OP_stack_value |
2040 | // (DW_OP_LLVM_fragment of Len). |
2041 | // An unsigned constant can be represented as |
2042 | // DW_OP_constu C DW_OP_stack_value (DW_OP_LLVM_fragment of Len). |
2043 | |
2044 | if ((getNumElements() != 2 && getNumElements() != 3 && |
2045 | getNumElements() != 6) || |
2046 | (getElement(I: 0) != dwarf::DW_OP_consts && |
2047 | getElement(I: 0) != dwarf::DW_OP_constu)) |
2048 | return std::nullopt; |
2049 | |
2050 | if (getNumElements() == 2 && getElement(I: 0) == dwarf::DW_OP_consts) |
2051 | return SignedOrUnsignedConstant::SignedConstant; |
2052 | |
2053 | if ((getNumElements() == 3 && getElement(I: 2) != dwarf::DW_OP_stack_value) || |
2054 | (getNumElements() == 6 && (getElement(I: 2) != dwarf::DW_OP_stack_value || |
2055 | getElement(I: 3) != dwarf::DW_OP_LLVM_fragment))) |
2056 | return std::nullopt; |
2057 | return getElement(I: 0) == dwarf::DW_OP_constu |
2058 | ? SignedOrUnsignedConstant::UnsignedConstant |
2059 | : SignedOrUnsignedConstant::SignedConstant; |
2060 | } |
2061 | |
2062 | DIExpression::ExtOps DIExpression::getExtOps(unsigned FromSize, unsigned ToSize, |
2063 | bool Signed) { |
2064 | dwarf::TypeKind TK = Signed ? dwarf::DW_ATE_signed : dwarf::DW_ATE_unsigned; |
2065 | DIExpression::ExtOps Ops{._M_elems: {dwarf::DW_OP_LLVM_convert, FromSize, TK, |
2066 | dwarf::DW_OP_LLVM_convert, ToSize, TK}}; |
2067 | return Ops; |
2068 | } |
2069 | |
2070 | DIExpression *DIExpression::appendExt(const DIExpression *Expr, |
2071 | unsigned FromSize, unsigned ToSize, |
2072 | bool Signed) { |
2073 | return appendToStack(Expr, Ops: getExtOps(FromSize, ToSize, Signed)); |
2074 | } |
2075 | |
2076 | DIGlobalVariableExpression * |
2077 | DIGlobalVariableExpression::getImpl(LLVMContext &Context, Metadata *Variable, |
2078 | Metadata *Expression, StorageType Storage, |
2079 | bool ShouldCreate) { |
2080 | DEFINE_GETIMPL_LOOKUP(DIGlobalVariableExpression, (Variable, Expression)); |
2081 | Metadata *Ops[] = {Variable, Expression}; |
2082 | DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIGlobalVariableExpression, Ops); |
2083 | } |
2084 | DIObjCProperty::DIObjCProperty(LLVMContext &C, StorageType Storage, |
2085 | unsigned Line, unsigned Attributes, |
2086 | ArrayRef<Metadata *> Ops) |
2087 | : DINode(C, DIObjCPropertyKind, Storage, dwarf::DW_TAG_APPLE_property, Ops), |
2088 | Line(Line), Attributes(Attributes) {} |
2089 | |
2090 | DIObjCProperty *DIObjCProperty::getImpl( |
2091 | LLVMContext &Context, MDString *Name, Metadata *File, unsigned Line, |
2092 | MDString *GetterName, MDString *SetterName, unsigned Attributes, |
2093 | Metadata *Type, StorageType Storage, bool ShouldCreate) { |
2094 | assert(isCanonical(Name) && "Expected canonical MDString" ); |
2095 | assert(isCanonical(GetterName) && "Expected canonical MDString" ); |
2096 | assert(isCanonical(SetterName) && "Expected canonical MDString" ); |
2097 | DEFINE_GETIMPL_LOOKUP(DIObjCProperty, (Name, File, Line, GetterName, |
2098 | SetterName, Attributes, Type)); |
2099 | Metadata *Ops[] = {Name, File, GetterName, SetterName, Type}; |
2100 | DEFINE_GETIMPL_STORE(DIObjCProperty, (Line, Attributes), Ops); |
2101 | } |
2102 | |
2103 | DIImportedEntity *DIImportedEntity::getImpl(LLVMContext &Context, unsigned Tag, |
2104 | Metadata *Scope, Metadata *Entity, |
2105 | Metadata *File, unsigned Line, |
2106 | MDString *Name, Metadata *Elements, |
2107 | StorageType Storage, |
2108 | bool ShouldCreate) { |
2109 | assert(isCanonical(Name) && "Expected canonical MDString" ); |
2110 | DEFINE_GETIMPL_LOOKUP(DIImportedEntity, |
2111 | (Tag, Scope, Entity, File, Line, Name, Elements)); |
2112 | Metadata *Ops[] = {Scope, Entity, Name, File, Elements}; |
2113 | DEFINE_GETIMPL_STORE(DIImportedEntity, (Tag, Line), Ops); |
2114 | } |
2115 | |
2116 | DIMacro *DIMacro::getImpl(LLVMContext &Context, unsigned MIType, unsigned Line, |
2117 | MDString *Name, MDString *Value, StorageType Storage, |
2118 | bool ShouldCreate) { |
2119 | assert(isCanonical(Name) && "Expected canonical MDString" ); |
2120 | DEFINE_GETIMPL_LOOKUP(DIMacro, (MIType, Line, Name, Value)); |
2121 | Metadata *Ops[] = {Name, Value}; |
2122 | DEFINE_GETIMPL_STORE(DIMacro, (MIType, Line), Ops); |
2123 | } |
2124 | |
2125 | DIMacroFile *DIMacroFile::getImpl(LLVMContext &Context, unsigned MIType, |
2126 | unsigned Line, Metadata *File, |
2127 | Metadata *Elements, StorageType Storage, |
2128 | bool ShouldCreate) { |
2129 | DEFINE_GETIMPL_LOOKUP(DIMacroFile, (MIType, Line, File, Elements)); |
2130 | Metadata *Ops[] = {File, Elements}; |
2131 | DEFINE_GETIMPL_STORE(DIMacroFile, (MIType, Line), Ops); |
2132 | } |
2133 | |
2134 | DIArgList *DIArgList::get(LLVMContext &Context, |
2135 | ArrayRef<ValueAsMetadata *> Args) { |
2136 | auto ExistingIt = Context.pImpl->DIArgLists.find_as(Val: DIArgListKeyInfo(Args)); |
2137 | if (ExistingIt != Context.pImpl->DIArgLists.end()) |
2138 | return *ExistingIt; |
2139 | DIArgList *NewArgList = new DIArgList(Context, Args); |
2140 | Context.pImpl->DIArgLists.insert(V: NewArgList); |
2141 | return NewArgList; |
2142 | } |
2143 | |
2144 | void DIArgList::handleChangedOperand(void *Ref, Metadata *New) { |
2145 | ValueAsMetadata **OldVMPtr = static_cast<ValueAsMetadata **>(Ref); |
2146 | assert((!New || isa<ValueAsMetadata>(New)) && |
2147 | "DIArgList must be passed a ValueAsMetadata" ); |
2148 | untrack(); |
2149 | // We need to update the set storage once the Args are updated since they |
2150 | // form the key to the DIArgLists store. |
2151 | getContext().pImpl->DIArgLists.erase(V: this); |
2152 | ValueAsMetadata *NewVM = cast_or_null<ValueAsMetadata>(Val: New); |
2153 | for (ValueAsMetadata *&VM : Args) { |
2154 | if (&VM == OldVMPtr) { |
2155 | if (NewVM) |
2156 | VM = NewVM; |
2157 | else |
2158 | VM = ValueAsMetadata::get(V: PoisonValue::get(T: VM->getValue()->getType())); |
2159 | } |
2160 | } |
2161 | // We've changed the contents of this DIArgList, and the set storage may |
2162 | // already contain a DIArgList with our new set of args; if it does, then we |
2163 | // must RAUW this with the existing DIArgList, otherwise we simply insert this |
2164 | // back into the set storage. |
2165 | DIArgList *ExistingArgList = getUniqued(Store&: getContext().pImpl->DIArgLists, Key: this); |
2166 | if (ExistingArgList) { |
2167 | replaceAllUsesWith(MD: ExistingArgList); |
2168 | // Clear this here so we don't try to untrack in the destructor. |
2169 | Args.clear(); |
2170 | delete this; |
2171 | return; |
2172 | } |
2173 | getContext().pImpl->DIArgLists.insert(V: this); |
2174 | track(); |
2175 | } |
2176 | void DIArgList::track() { |
2177 | for (ValueAsMetadata *&VAM : Args) |
2178 | if (VAM) |
2179 | MetadataTracking::track(Ref: &VAM, MD&: *VAM, Owner&: *this); |
2180 | } |
2181 | void DIArgList::untrack() { |
2182 | for (ValueAsMetadata *&VAM : Args) |
2183 | if (VAM) |
2184 | MetadataTracking::untrack(Ref: &VAM, MD&: *VAM); |
2185 | } |
2186 | void DIArgList::dropAllReferences(bool Untrack) { |
2187 | if (Untrack) |
2188 | untrack(); |
2189 | Args.clear(); |
2190 | ReplaceableMetadataImpl::resolveAllUses(/* ResolveUsers */ false); |
2191 | } |
2192 | |