Bug Summary

File:llvm/lib/IR/DebugInfoMetadata.cpp
Warning:line 137, column 16
The result of the left shift is undefined due to shifting by '35', which is greater or equal to the width of type 'unsigned int'

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name DebugInfoMetadata.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/build-llvm/lib/IR -I /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR -I /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/build-llvm/include -I /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/build-llvm/lib/IR -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2020-01-13-084841-49055-1 -x c++ /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp

/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp

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/SmallSet.h"
17#include "llvm/ADT/StringSwitch.h"
18#include "llvm/IR/DIBuilder.h"
19#include "llvm/IR/Function.h"
20#include "llvm/IR/Instructions.h"
21
22#include <numeric>
23
24using namespace llvm;
25
26const DIExpression::FragmentInfo DebugVariable::DefaultFragment = {
27 std::numeric_limits<uint64_t>::max(), std::numeric_limits<uint64_t>::min()};
28
29DILocation::DILocation(LLVMContext &C, StorageType Storage, unsigned Line,
30 unsigned Column, ArrayRef<Metadata *> MDs,
31 bool ImplicitCode)
32 : MDNode(C, DILocationKind, Storage, MDs) {
33 assert((MDs.size() == 1 || MDs.size() == 2) &&(((MDs.size() == 1 || MDs.size() == 2) && "Expected a scope and optional inlined-at"
) ? static_cast<void> (0) : __assert_fail ("(MDs.size() == 1 || MDs.size() == 2) && \"Expected a scope and optional inlined-at\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 34, __PRETTY_FUNCTION__))
34 "Expected a scope and optional inlined-at")(((MDs.size() == 1 || MDs.size() == 2) && "Expected a scope and optional inlined-at"
) ? static_cast<void> (0) : __assert_fail ("(MDs.size() == 1 || MDs.size() == 2) && \"Expected a scope and optional inlined-at\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 34, __PRETTY_FUNCTION__))
;
35
36 // Set line and column.
37 assert(Column < (1u << 16) && "Expected 16-bit column")((Column < (1u << 16) && "Expected 16-bit column"
) ? static_cast<void> (0) : __assert_fail ("Column < (1u << 16) && \"Expected 16-bit column\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 37, __PRETTY_FUNCTION__))
;
38
39 SubclassData32 = Line;
40 SubclassData16 = Column;
41
42 setImplicitCode(ImplicitCode);
43}
44
45static void adjustColumn(unsigned &Column) {
46 // Set to unknown on overflow. We only have 16 bits to play with here.
47 if (Column >= (1u << 16))
48 Column = 0;
49}
50
51DILocation *DILocation::getImpl(LLVMContext &Context, unsigned Line,
52 unsigned Column, Metadata *Scope,
53 Metadata *InlinedAt, bool ImplicitCode,
54 StorageType Storage, bool ShouldCreate) {
55 // Fixup column.
56 adjustColumn(Column);
57
58 if (Storage == Uniqued) {
59 if (auto *N = getUniqued(Context.pImpl->DILocations,
60 DILocationInfo::KeyTy(Line, Column, Scope,
61 InlinedAt, ImplicitCode)))
62 return N;
63 if (!ShouldCreate)
64 return nullptr;
65 } else {
66 assert(ShouldCreate && "Expected non-uniqued nodes to always be created")((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 66, __PRETTY_FUNCTION__))
;
67 }
68
69 SmallVector<Metadata *, 2> Ops;
70 Ops.push_back(Scope);
71 if (InlinedAt)
72 Ops.push_back(InlinedAt);
73 return storeImpl(new (Ops.size()) DILocation(Context, Storage, Line, Column,
74 Ops, ImplicitCode),
75 Storage, Context.pImpl->DILocations);
76}
77
78const DILocation *DILocation::getMergedLocation(const DILocation *LocA,
79 const DILocation *LocB) {
80 if (!LocA || !LocB)
81 return nullptr;
82
83 if (LocA == LocB)
84 return LocA;
85
86 SmallPtrSet<DILocation *, 5> InlinedLocationsA;
87 for (DILocation *L = LocA->getInlinedAt(); L; L = L->getInlinedAt())
88 InlinedLocationsA.insert(L);
89 SmallSet<std::pair<DIScope *, DILocation *>, 5> Locations;
90 DIScope *S = LocA->getScope();
91 DILocation *L = LocA->getInlinedAt();
92 while (S) {
93 Locations.insert(std::make_pair(S, L));
94 S = S->getScope();
95 if (!S && L) {
96 S = L->getScope();
97 L = L->getInlinedAt();
98 }
99 }
100 const DILocation *Result = LocB;
101 S = LocB->getScope();
102 L = LocB->getInlinedAt();
103 while (S) {
104 if (Locations.count(std::make_pair(S, L)))
105 break;
106 S = S->getScope();
107 if (!S && L) {
108 S = L->getScope();
109 L = L->getInlinedAt();
110 }
111 }
112
113 // If the two locations are irreconsilable, just pick one. This is misleading,
114 // but on the other hand, it's a "line 0" location.
115 if (!S || !isa<DILocalScope>(S))
116 S = LocA->getScope();
117 return DILocation::get(Result->getContext(), 0, 0, S, L);
118}
119
120Optional<unsigned> DILocation::encodeDiscriminator(unsigned BD, unsigned DF, unsigned CI) {
121 SmallVector<unsigned, 3> Components = {BD, DF, CI};
122 uint64_t RemainingWork = 0U;
123 // We use RemainingWork to figure out if we have no remaining components to
124 // encode. For example: if BD != 0 but DF == 0 && CI == 0, we don't need to
125 // encode anything for the latter 2.
126 // Since any of the input components is at most 32 bits, their sum will be
127 // less than 34 bits, and thus RemainingWork won't overflow.
128 RemainingWork = std::accumulate(Components.begin(), Components.end(), RemainingWork);
129
130 int I = 0;
131 unsigned Ret = 0;
132 unsigned NextBitInsertionIndex = 0;
133 while (RemainingWork > 0) {
1
Assuming 'RemainingWork' is > 0
2
Loop condition is true. Entering loop body
3
Assuming 'RemainingWork' is > 0
4
Loop condition is true. Entering loop body
5
Assuming 'RemainingWork' is > 0
6
Loop condition is true. Entering loop body
14
Assuming 'RemainingWork' is > 0
15
Loop condition is true. Entering loop body
134 unsigned C = Components[I++];
135 RemainingWork -= C;
136 unsigned EC = encodeComponent(C);
137 Ret |= (EC << NextBitInsertionIndex);
16
The result of the left shift is undefined due to shifting by '35', which is greater or equal to the width of type 'unsigned int'
138 NextBitInsertionIndex += encodingBits(C);
7
Calling 'DILocation::encodingBits'
12
Returning from 'DILocation::encodingBits'
13
The value 35 is assigned to 'NextBitInsertionIndex'
139 }
140
141 // Encoding may be unsuccessful because of overflow. We determine success by
142 // checking equivalence of components before & after encoding. Alternatively,
143 // we could determine Success during encoding, but the current alternative is
144 // simpler.
145 unsigned TBD, TDF, TCI = 0;
146 decodeDiscriminator(Ret, TBD, TDF, TCI);
147 if (TBD == BD && TDF == DF && TCI == CI)
148 return Ret;
149 return None;
150}
151
152void DILocation::decodeDiscriminator(unsigned D, unsigned &BD, unsigned &DF,
153 unsigned &CI) {
154 BD = getUnsignedFromPrefixEncoding(D);
155 DF = getUnsignedFromPrefixEncoding(getNextComponentInDiscriminator(D));
156 CI = getUnsignedFromPrefixEncoding(
157 getNextComponentInDiscriminator(getNextComponentInDiscriminator(D)));
158}
159
160
161DINode::DIFlags DINode::getFlag(StringRef Flag) {
162 return StringSwitch<DIFlags>(Flag)
163#define HANDLE_DI_FLAG(ID, NAME) .Case("DIFlag" #NAME, Flag##NAME)
164#include "llvm/IR/DebugInfoFlags.def"
165 .Default(DINode::FlagZero);
166}
167
168StringRef DINode::getFlagString(DIFlags Flag) {
169 switch (Flag) {
170#define HANDLE_DI_FLAG(ID, NAME) \
171 case Flag##NAME: \
172 return "DIFlag" #NAME;
173#include "llvm/IR/DebugInfoFlags.def"
174 }
175 return "";
176}
177
178DINode::DIFlags DINode::splitFlags(DIFlags Flags,
179 SmallVectorImpl<DIFlags> &SplitFlags) {
180 // Flags that are packed together need to be specially handled, so
181 // that, for example, we emit "DIFlagPublic" and not
182 // "DIFlagPrivate | DIFlagProtected".
183 if (DIFlags A = Flags & FlagAccessibility) {
184 if (A == FlagPrivate)
185 SplitFlags.push_back(FlagPrivate);
186 else if (A == FlagProtected)
187 SplitFlags.push_back(FlagProtected);
188 else
189 SplitFlags.push_back(FlagPublic);
190 Flags &= ~A;
191 }
192 if (DIFlags R = Flags & FlagPtrToMemberRep) {
193 if (R == FlagSingleInheritance)
194 SplitFlags.push_back(FlagSingleInheritance);
195 else if (R == FlagMultipleInheritance)
196 SplitFlags.push_back(FlagMultipleInheritance);
197 else
198 SplitFlags.push_back(FlagVirtualInheritance);
199 Flags &= ~R;
200 }
201 if ((Flags & FlagIndirectVirtualBase) == FlagIndirectVirtualBase) {
202 Flags &= ~FlagIndirectVirtualBase;
203 SplitFlags.push_back(FlagIndirectVirtualBase);
204 }
205
206#define HANDLE_DI_FLAG(ID, NAME) \
207 if (DIFlags Bit = Flags & Flag##NAME) { \
208 SplitFlags.push_back(Bit); \
209 Flags &= ~Bit; \
210 }
211#include "llvm/IR/DebugInfoFlags.def"
212 return Flags;
213}
214
215DIScope *DIScope::getScope() const {
216 if (auto *T = dyn_cast<DIType>(this))
217 return T->getScope();
218
219 if (auto *SP = dyn_cast<DISubprogram>(this))
220 return SP->getScope();
221
222 if (auto *LB = dyn_cast<DILexicalBlockBase>(this))
223 return LB->getScope();
224
225 if (auto *NS = dyn_cast<DINamespace>(this))
226 return NS->getScope();
227
228 if (auto *CB = dyn_cast<DICommonBlock>(this))
229 return CB->getScope();
230
231 if (auto *M = dyn_cast<DIModule>(this))
232 return M->getScope();
233
234 assert((isa<DIFile>(this) || isa<DICompileUnit>(this)) &&(((isa<DIFile>(this) || isa<DICompileUnit>(this))
&& "Unhandled type of scope.") ? static_cast<void
> (0) : __assert_fail ("(isa<DIFile>(this) || isa<DICompileUnit>(this)) && \"Unhandled type of scope.\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 235, __PRETTY_FUNCTION__))
235 "Unhandled type of scope.")(((isa<DIFile>(this) || isa<DICompileUnit>(this))
&& "Unhandled type of scope.") ? static_cast<void
> (0) : __assert_fail ("(isa<DIFile>(this) || isa<DICompileUnit>(this)) && \"Unhandled type of scope.\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 235, __PRETTY_FUNCTION__))
;
236 return nullptr;
237}
238
239StringRef DIScope::getName() const {
240 if (auto *T = dyn_cast<DIType>(this))
241 return T->getName();
242 if (auto *SP = dyn_cast<DISubprogram>(this))
243 return SP->getName();
244 if (auto *NS = dyn_cast<DINamespace>(this))
245 return NS->getName();
246 if (auto *CB = dyn_cast<DICommonBlock>(this))
247 return CB->getName();
248 if (auto *M = dyn_cast<DIModule>(this))
249 return M->getName();
250 assert((isa<DILexicalBlockBase>(this) || isa<DIFile>(this) ||(((isa<DILexicalBlockBase>(this) || isa<DIFile>(this
) || isa<DICompileUnit>(this)) && "Unhandled type of scope."
) ? static_cast<void> (0) : __assert_fail ("(isa<DILexicalBlockBase>(this) || isa<DIFile>(this) || isa<DICompileUnit>(this)) && \"Unhandled type of scope.\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 252, __PRETTY_FUNCTION__))
251 isa<DICompileUnit>(this)) &&(((isa<DILexicalBlockBase>(this) || isa<DIFile>(this
) || isa<DICompileUnit>(this)) && "Unhandled type of scope."
) ? static_cast<void> (0) : __assert_fail ("(isa<DILexicalBlockBase>(this) || isa<DIFile>(this) || isa<DICompileUnit>(this)) && \"Unhandled type of scope.\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 252, __PRETTY_FUNCTION__))
252 "Unhandled type of scope.")(((isa<DILexicalBlockBase>(this) || isa<DIFile>(this
) || isa<DICompileUnit>(this)) && "Unhandled type of scope."
) ? static_cast<void> (0) : __assert_fail ("(isa<DILexicalBlockBase>(this) || isa<DIFile>(this) || isa<DICompileUnit>(this)) && \"Unhandled type of scope.\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 252, __PRETTY_FUNCTION__))
;
253 return "";
254}
255
256#ifndef NDEBUG
257static bool isCanonical(const MDString *S) {
258 return !S || !S->getString().empty();
259}
260#endif
261
262GenericDINode *GenericDINode::getImpl(LLVMContext &Context, unsigned Tag,
263 MDString *Header,
264 ArrayRef<Metadata *> DwarfOps,
265 StorageType Storage, bool ShouldCreate) {
266 unsigned Hash = 0;
267 if (Storage == Uniqued) {
268 GenericDINodeInfo::KeyTy Key(Tag, Header, DwarfOps);
269 if (auto *N = getUniqued(Context.pImpl->GenericDINodes, Key))
270 return N;
271 if (!ShouldCreate)
272 return nullptr;
273 Hash = Key.getHash();
274 } else {
275 assert(ShouldCreate && "Expected non-uniqued nodes to always be created")((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 275, __PRETTY_FUNCTION__))
;
276 }
277
278 // Use a nullptr for empty headers.
279 assert(isCanonical(Header) && "Expected canonical MDString")((isCanonical(Header) && "Expected canonical MDString"
) ? static_cast<void> (0) : __assert_fail ("isCanonical(Header) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 279, __PRETTY_FUNCTION__))
;
280 Metadata *PreOps[] = {Header};
281 return storeImpl(new (DwarfOps.size() + 1) GenericDINode(
282 Context, Storage, Hash, Tag, PreOps, DwarfOps),
283 Storage, Context.pImpl->GenericDINodes);
284}
285
286void GenericDINode::recalculateHash() {
287 setHash(GenericDINodeInfo::KeyTy::calculateHash(this));
288}
289
290#define UNWRAP_ARGS_IMPL(...)... __VA_ARGS__
291#define UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS UNWRAP_ARGS_IMPL ARGS
292#define DEFINE_GETIMPL_LOOKUP(CLASS, ARGS)do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->CLASSs, CLASSInfo::KeyTy(UNWRAP_ARGS_IMPL ARGS))) return
N; if (!ShouldCreate) return nullptr; } else { ((ShouldCreate
&& "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 292, __PRETTY_FUNCTION__)); } } while (false)
\
293 do { \
294 if (Storage == Uniqued) { \
295 if (auto *N = getUniqued(Context.pImpl->CLASS##s, \
296 CLASS##Info::KeyTy(UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS))) \
297 return N; \
298 if (!ShouldCreate) \
299 return nullptr; \
300 } else { \
301 assert(ShouldCreate && \((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 302, __PRETTY_FUNCTION__))
302 "Expected non-uniqued nodes to always be created")((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 302, __PRETTY_FUNCTION__))
; \
303 } \
304 } while (false)
305#define DEFINE_GETIMPL_STORE(CLASS, ARGS, OPS)return storeImpl(new (array_lengthof(OPS)) CLASS(Context, Storage
, UNWRAP_ARGS_IMPL ARGS, OPS), Storage, Context.pImpl->CLASSs
)
\
306 return storeImpl(new (array_lengthof(OPS)) \
307 CLASS(Context, Storage, UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS, OPS), \
308 Storage, Context.pImpl->CLASS##s)
309#define DEFINE_GETIMPL_STORE_NO_OPS(CLASS, ARGS)return storeImpl(new (0u) CLASS(Context, Storage, UNWRAP_ARGS_IMPL
ARGS), Storage, Context.pImpl->CLASSs)
\
310 return storeImpl(new (0u) CLASS(Context, Storage, UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS), \
311 Storage, Context.pImpl->CLASS##s)
312#define DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(CLASS, OPS)return storeImpl(new (array_lengthof(OPS)) CLASS(Context, Storage
, OPS), Storage, Context.pImpl->CLASSs)
\
313 return storeImpl(new (array_lengthof(OPS)) CLASS(Context, Storage, OPS), \
314 Storage, Context.pImpl->CLASS##s)
315#define DEFINE_GETIMPL_STORE_N(CLASS, ARGS, OPS, NUM_OPS)return storeImpl(new (NUM_OPS) CLASS(Context, Storage, UNWRAP_ARGS_IMPL
ARGS, OPS), Storage, Context.pImpl->CLASSs)
\
316 return storeImpl(new (NUM_OPS) \
317 CLASS(Context, Storage, UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS, OPS), \
318 Storage, Context.pImpl->CLASS##s)
319
320DISubrange *DISubrange::getImpl(LLVMContext &Context, int64_t Count, int64_t Lo,
321 StorageType Storage, bool ShouldCreate) {
322 auto *CountNode = ConstantAsMetadata::get(
323 ConstantInt::getSigned(Type::getInt64Ty(Context), Count));
324 return getImpl(Context, CountNode, Lo, Storage, ShouldCreate);
325}
326
327DISubrange *DISubrange::getImpl(LLVMContext &Context, Metadata *CountNode,
328 int64_t Lo, StorageType Storage,
329 bool ShouldCreate) {
330 DEFINE_GETIMPL_LOOKUP(DISubrange, (CountNode, Lo))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DISubranges, DISubrangeInfo::KeyTy(CountNode, Lo))
) return N; if (!ShouldCreate) return nullptr; } else { ((ShouldCreate
&& "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 330, __PRETTY_FUNCTION__)); } } while (false)
;
331 Metadata *Ops[] = { CountNode };
332 DEFINE_GETIMPL_STORE(DISubrange, (CountNode, Lo), Ops)return storeImpl(new (array_lengthof(Ops)) DISubrange(Context
, Storage, CountNode, Lo, Ops), Storage, Context.pImpl->DISubranges
)
;
333}
334
335DIEnumerator *DIEnumerator::getImpl(LLVMContext &Context, int64_t Value,
336 bool IsUnsigned, MDString *Name,
337 StorageType Storage, bool ShouldCreate) {
338 assert(isCanonical(Name) && "Expected canonical MDString")((isCanonical(Name) && "Expected canonical MDString")
? static_cast<void> (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 338, __PRETTY_FUNCTION__))
;
339 DEFINE_GETIMPL_LOOKUP(DIEnumerator, (Value, IsUnsigned, Name))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIEnumerators, DIEnumeratorInfo::KeyTy(Value, IsUnsigned
, Name))) return N; if (!ShouldCreate) return nullptr; } else
{ ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 339, __PRETTY_FUNCTION__)); } } while (false)
;
340 Metadata *Ops[] = {Name};
341 DEFINE_GETIMPL_STORE(DIEnumerator, (Value, IsUnsigned), Ops)return storeImpl(new (array_lengthof(Ops)) DIEnumerator(Context
, Storage, Value, IsUnsigned, Ops), Storage, Context.pImpl->
DIEnumerators)
;
342}
343
344DIBasicType *DIBasicType::getImpl(LLVMContext &Context, unsigned Tag,
345 MDString *Name, uint64_t SizeInBits,
346 uint32_t AlignInBits, unsigned Encoding,
347 DIFlags Flags, StorageType Storage,
348 bool ShouldCreate) {
349 assert(isCanonical(Name) && "Expected canonical MDString")((isCanonical(Name) && "Expected canonical MDString")
? static_cast<void> (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 349, __PRETTY_FUNCTION__))
;
350 DEFINE_GETIMPL_LOOKUP(DIBasicType,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIBasicTypes, DIBasicTypeInfo::KeyTy(Tag, Name, SizeInBits
, AlignInBits, Encoding, Flags))) return N; if (!ShouldCreate
) return nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 351, __PRETTY_FUNCTION__)); } } while (false)
351 (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIBasicTypes, DIBasicTypeInfo::KeyTy(Tag, Name, SizeInBits
, AlignInBits, Encoding, Flags))) return N; if (!ShouldCreate
) return nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 351, __PRETTY_FUNCTION__)); } } while (false)
;
352 Metadata *Ops[] = {nullptr, nullptr, Name};
353 DEFINE_GETIMPL_STORE(DIBasicType, (Tag, SizeInBits, AlignInBits, Encoding,return storeImpl(new (array_lengthof(Ops)) DIBasicType(Context
, Storage, Tag, SizeInBits, AlignInBits, Encoding, Flags, Ops
), Storage, Context.pImpl->DIBasicTypes)
354 Flags), Ops)return storeImpl(new (array_lengthof(Ops)) DIBasicType(Context
, Storage, Tag, SizeInBits, AlignInBits, Encoding, Flags, Ops
), Storage, Context.pImpl->DIBasicTypes)
;
355}
356
357Optional<DIBasicType::Signedness> DIBasicType::getSignedness() const {
358 switch (getEncoding()) {
359 case dwarf::DW_ATE_signed:
360 case dwarf::DW_ATE_signed_char:
361 return Signedness::Signed;
362 case dwarf::DW_ATE_unsigned:
363 case dwarf::DW_ATE_unsigned_char:
364 return Signedness::Unsigned;
365 default:
366 return None;
367 }
368}
369
370DIDerivedType *DIDerivedType::getImpl(
371 LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
372 unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
373 uint32_t AlignInBits, uint64_t OffsetInBits,
374 Optional<unsigned> DWARFAddressSpace, DIFlags Flags, Metadata *ExtraData,
375 StorageType Storage, bool ShouldCreate) {
376 assert(isCanonical(Name) && "Expected canonical MDString")((isCanonical(Name) && "Expected canonical MDString")
? static_cast<void> (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 376, __PRETTY_FUNCTION__))
;
377 DEFINE_GETIMPL_LOOKUP(DIDerivedType,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIDerivedTypes, DIDerivedTypeInfo::KeyTy(Tag, Name
, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits
, DWARFAddressSpace, Flags, ExtraData))) return N; if (!ShouldCreate
) return nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 380, __PRETTY_FUNCTION__)); } } while (false)
378 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIDerivedTypes, DIDerivedTypeInfo::KeyTy(Tag, Name
, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits
, DWARFAddressSpace, Flags, ExtraData))) return N; if (!ShouldCreate
) return nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 380, __PRETTY_FUNCTION__)); } } while (false)
379 AlignInBits, OffsetInBits, DWARFAddressSpace, Flags,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIDerivedTypes, DIDerivedTypeInfo::KeyTy(Tag, Name
, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits
, DWARFAddressSpace, Flags, ExtraData))) return N; if (!ShouldCreate
) return nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 380, __PRETTY_FUNCTION__)); } } while (false)
380 ExtraData))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIDerivedTypes, DIDerivedTypeInfo::KeyTy(Tag, Name
, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits
, DWARFAddressSpace, Flags, ExtraData))) return N; if (!ShouldCreate
) return nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 380, __PRETTY_FUNCTION__)); } } while (false)
;
381 Metadata *Ops[] = {File, Scope, Name, BaseType, ExtraData};
382 DEFINE_GETIMPL_STORE(return storeImpl(new (array_lengthof(Ops)) DIDerivedType(Context
, Storage, Tag, Line, SizeInBits, AlignInBits, OffsetInBits, DWARFAddressSpace
, Flags, Ops), Storage, Context.pImpl->DIDerivedTypes)
383 DIDerivedType, (Tag, Line, SizeInBits, AlignInBits, OffsetInBits,return storeImpl(new (array_lengthof(Ops)) DIDerivedType(Context
, Storage, Tag, Line, SizeInBits, AlignInBits, OffsetInBits, DWARFAddressSpace
, Flags, Ops), Storage, Context.pImpl->DIDerivedTypes)
384 DWARFAddressSpace, Flags), Ops)return storeImpl(new (array_lengthof(Ops)) DIDerivedType(Context
, Storage, Tag, Line, SizeInBits, AlignInBits, OffsetInBits, DWARFAddressSpace
, Flags, Ops), Storage, Context.pImpl->DIDerivedTypes)
;
385}
386
387DICompositeType *DICompositeType::getImpl(
388 LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
389 unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
390 uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
391 Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder,
392 Metadata *TemplateParams, MDString *Identifier, Metadata *Discriminator,
393 StorageType Storage, bool ShouldCreate) {
394 assert(isCanonical(Name) && "Expected canonical MDString")((isCanonical(Name) && "Expected canonical MDString")
? static_cast<void> (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 394, __PRETTY_FUNCTION__))
;
395
396 // Keep this in sync with buildODRType.
397 DEFINE_GETIMPL_LOOKUP(do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DICompositeTypes, DICompositeTypeInfo::KeyTy(Tag, Name
, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits
, Flags, Elements, RuntimeLang, VTableHolder, TemplateParams,
Identifier, Discriminator))) return N; if (!ShouldCreate) return
nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 400, __PRETTY_FUNCTION__)); } } while (false)
398 DICompositeType, (Tag, Name, File, Line, Scope, BaseType, SizeInBits,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DICompositeTypes, DICompositeTypeInfo::KeyTy(Tag, Name
, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits
, Flags, Elements, RuntimeLang, VTableHolder, TemplateParams,
Identifier, Discriminator))) return N; if (!ShouldCreate) return
nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 400, __PRETTY_FUNCTION__)); } } while (false)
399 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DICompositeTypes, DICompositeTypeInfo::KeyTy(Tag, Name
, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits
, Flags, Elements, RuntimeLang, VTableHolder, TemplateParams,
Identifier, Discriminator))) return N; if (!ShouldCreate) return
nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 400, __PRETTY_FUNCTION__)); } } while (false)
400 VTableHolder, TemplateParams, Identifier, Discriminator))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DICompositeTypes, DICompositeTypeInfo::KeyTy(Tag, Name
, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits
, Flags, Elements, RuntimeLang, VTableHolder, TemplateParams,
Identifier, Discriminator))) return N; if (!ShouldCreate) return
nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 400, __PRETTY_FUNCTION__)); } } while (false)
;
401 Metadata *Ops[] = {File, Scope, Name, BaseType,
402 Elements, VTableHolder, TemplateParams, Identifier,
403 Discriminator};
404 DEFINE_GETIMPL_STORE(DICompositeType, (Tag, Line, RuntimeLang, SizeInBits,return storeImpl(new (array_lengthof(Ops)) DICompositeType(Context
, Storage, Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits
, Flags, Ops), Storage, Context.pImpl->DICompositeTypes)
405 AlignInBits, OffsetInBits, Flags),return storeImpl(new (array_lengthof(Ops)) DICompositeType(Context
, Storage, Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits
, Flags, Ops), Storage, Context.pImpl->DICompositeTypes)
406 Ops)return storeImpl(new (array_lengthof(Ops)) DICompositeType(Context
, Storage, Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits
, Flags, Ops), Storage, Context.pImpl->DICompositeTypes)
;
407}
408
409DICompositeType *DICompositeType::buildODRType(
410 LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name,
411 Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType,
412 uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
413 DIFlags Flags, Metadata *Elements, unsigned RuntimeLang,
414 Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator) {
415 assert(!Identifier.getString().empty() && "Expected valid identifier")((!Identifier.getString().empty() && "Expected valid identifier"
) ? static_cast<void> (0) : __assert_fail ("!Identifier.getString().empty() && \"Expected valid identifier\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 415, __PRETTY_FUNCTION__))
;
416 if (!Context.isODRUniquingDebugTypes())
417 return nullptr;
418 auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier];
419 if (!CT)
420 return CT = DICompositeType::getDistinct(
421 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
422 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
423 VTableHolder, TemplateParams, &Identifier, Discriminator);
424
425 // Only mutate CT if it's a forward declaration and the new operands aren't.
426 assert(CT->getRawIdentifier() == &Identifier && "Wrong ODR identifier?")((CT->getRawIdentifier() == &Identifier && "Wrong ODR identifier?"
) ? static_cast<void> (0) : __assert_fail ("CT->getRawIdentifier() == &Identifier && \"Wrong ODR identifier?\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 426, __PRETTY_FUNCTION__))
;
427 if (!CT->isForwardDecl() || (Flags & DINode::FlagFwdDecl))
428 return CT;
429
430 // Mutate CT in place. Keep this in sync with getImpl.
431 CT->mutate(Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits,
432 Flags);
433 Metadata *Ops[] = {File, Scope, Name, BaseType,
434 Elements, VTableHolder, TemplateParams, &Identifier,
435 Discriminator};
436 assert((std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands() &&(((std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands
() && "Mismatched number of operands") ? static_cast<
void> (0) : __assert_fail ("(std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands() && \"Mismatched number of operands\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 437, __PRETTY_FUNCTION__))
437 "Mismatched number of operands")(((std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands
() && "Mismatched number of operands") ? static_cast<
void> (0) : __assert_fail ("(std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands() && \"Mismatched number of operands\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 437, __PRETTY_FUNCTION__))
;
438 for (unsigned I = 0, E = CT->getNumOperands(); I != E; ++I)
439 if (Ops[I] != CT->getOperand(I))
440 CT->setOperand(I, Ops[I]);
441 return CT;
442}
443
444DICompositeType *DICompositeType::getODRType(
445 LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name,
446 Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType,
447 uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
448 DIFlags Flags, Metadata *Elements, unsigned RuntimeLang,
449 Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator) {
450 assert(!Identifier.getString().empty() && "Expected valid identifier")((!Identifier.getString().empty() && "Expected valid identifier"
) ? static_cast<void> (0) : __assert_fail ("!Identifier.getString().empty() && \"Expected valid identifier\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 450, __PRETTY_FUNCTION__))
;
451 if (!Context.isODRUniquingDebugTypes())
452 return nullptr;
453 auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier];
454 if (!CT)
455 CT = DICompositeType::getDistinct(
456 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
457 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, VTableHolder,
458 TemplateParams, &Identifier, Discriminator);
459 return CT;
460}
461
462DICompositeType *DICompositeType::getODRTypeIfExists(LLVMContext &Context,
463 MDString &Identifier) {
464 assert(!Identifier.getString().empty() && "Expected valid identifier")((!Identifier.getString().empty() && "Expected valid identifier"
) ? static_cast<void> (0) : __assert_fail ("!Identifier.getString().empty() && \"Expected valid identifier\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 464, __PRETTY_FUNCTION__))
;
465 if (!Context.isODRUniquingDebugTypes())
466 return nullptr;
467 return Context.pImpl->DITypeMap->lookup(&Identifier);
468}
469
470DISubroutineType *DISubroutineType::getImpl(LLVMContext &Context, DIFlags Flags,
471 uint8_t CC, Metadata *TypeArray,
472 StorageType Storage,
473 bool ShouldCreate) {
474 DEFINE_GETIMPL_LOOKUP(DISubroutineType, (Flags, CC, TypeArray))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DISubroutineTypes, DISubroutineTypeInfo::KeyTy(Flags
, CC, TypeArray))) return N; if (!ShouldCreate) return nullptr
; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 474, __PRETTY_FUNCTION__)); } } while (false)
;
475 Metadata *Ops[] = {nullptr, nullptr, nullptr, TypeArray};
476 DEFINE_GETIMPL_STORE(DISubroutineType, (Flags, CC), Ops)return storeImpl(new (array_lengthof(Ops)) DISubroutineType(Context
, Storage, Flags, CC, Ops), Storage, Context.pImpl->DISubroutineTypes
)
;
477}
478
479// FIXME: Implement this string-enum correspondence with a .def file and macros,
480// so that the association is explicit rather than implied.
481static const char *ChecksumKindName[DIFile::CSK_Last] = {
482 "CSK_MD5",
483 "CSK_SHA1"
484};
485
486StringRef DIFile::getChecksumKindAsString(ChecksumKind CSKind) {
487 assert(CSKind <= DIFile::CSK_Last && "Invalid checksum kind")((CSKind <= DIFile::CSK_Last && "Invalid checksum kind"
) ? static_cast<void> (0) : __assert_fail ("CSKind <= DIFile::CSK_Last && \"Invalid checksum kind\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 487, __PRETTY_FUNCTION__))
;
488 // The first space was originally the CSK_None variant, which is now
489 // obsolete, but the space is still reserved in ChecksumKind, so we account
490 // for it here.
491 return ChecksumKindName[CSKind - 1];
492}
493
494Optional<DIFile::ChecksumKind> DIFile::getChecksumKind(StringRef CSKindStr) {
495 return StringSwitch<Optional<DIFile::ChecksumKind>>(CSKindStr)
496 .Case("CSK_MD5", DIFile::CSK_MD5)
497 .Case("CSK_SHA1", DIFile::CSK_SHA1)
498 .Default(None);
499}
500
501DIFile *DIFile::getImpl(LLVMContext &Context, MDString *Filename,
502 MDString *Directory,
503 Optional<DIFile::ChecksumInfo<MDString *>> CS,
504 Optional<MDString *> Source, StorageType Storage,
505 bool ShouldCreate) {
506 assert(isCanonical(Filename) && "Expected canonical MDString")((isCanonical(Filename) && "Expected canonical MDString"
) ? static_cast<void> (0) : __assert_fail ("isCanonical(Filename) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 506, __PRETTY_FUNCTION__))
;
507 assert(isCanonical(Directory) && "Expected canonical MDString")((isCanonical(Directory) && "Expected canonical MDString"
) ? static_cast<void> (0) : __assert_fail ("isCanonical(Directory) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 507, __PRETTY_FUNCTION__))
;
508 assert((!CS || isCanonical(CS->Value)) && "Expected canonical MDString")(((!CS || isCanonical(CS->Value)) && "Expected canonical MDString"
) ? static_cast<void> (0) : __assert_fail ("(!CS || isCanonical(CS->Value)) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 508, __PRETTY_FUNCTION__))
;
509 assert((!Source || isCanonical(*Source)) && "Expected canonical MDString")(((!Source || isCanonical(*Source)) && "Expected canonical MDString"
) ? static_cast<void> (0) : __assert_fail ("(!Source || isCanonical(*Source)) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 509, __PRETTY_FUNCTION__))
;
510 DEFINE_GETIMPL_LOOKUP(DIFile, (Filename, Directory, CS, Source))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIFiles, DIFileInfo::KeyTy(Filename, Directory, CS
, Source))) return N; if (!ShouldCreate) return nullptr; } else
{ ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 510, __PRETTY_FUNCTION__)); } } while (false)
;
511 Metadata *Ops[] = {Filename, Directory, CS ? CS->Value : nullptr,
512 Source.getValueOr(nullptr)};
513 DEFINE_GETIMPL_STORE(DIFile, (CS, Source), Ops)return storeImpl(new (array_lengthof(Ops)) DIFile(Context, Storage
, CS, Source, Ops), Storage, Context.pImpl->DIFiles)
;
514}
515
516DICompileUnit *DICompileUnit::getImpl(
517 LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
518 MDString *Producer, bool IsOptimized, MDString *Flags,
519 unsigned RuntimeVersion, MDString *SplitDebugFilename,
520 unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
521 Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata *Macros,
522 uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
523 unsigned NameTableKind, bool RangesBaseAddress, StorageType Storage,
524 bool ShouldCreate) {
525 assert(Storage != Uniqued && "Cannot unique DICompileUnit")((Storage != Uniqued && "Cannot unique DICompileUnit"
) ? static_cast<void> (0) : __assert_fail ("Storage != Uniqued && \"Cannot unique DICompileUnit\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 525, __PRETTY_FUNCTION__))
;
526 assert(isCanonical(Producer) && "Expected canonical MDString")((isCanonical(Producer) && "Expected canonical MDString"
) ? static_cast<void> (0) : __assert_fail ("isCanonical(Producer) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 526, __PRETTY_FUNCTION__))
;
527 assert(isCanonical(Flags) && "Expected canonical MDString")((isCanonical(Flags) && "Expected canonical MDString"
) ? static_cast<void> (0) : __assert_fail ("isCanonical(Flags) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 527, __PRETTY_FUNCTION__))
;
528 assert(isCanonical(SplitDebugFilename) && "Expected canonical MDString")((isCanonical(SplitDebugFilename) && "Expected canonical MDString"
) ? static_cast<void> (0) : __assert_fail ("isCanonical(SplitDebugFilename) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 528, __PRETTY_FUNCTION__))
;
529
530 Metadata *Ops[] = {
531 File, Producer, Flags, SplitDebugFilename,
532 EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities,
533 Macros};
534 return storeImpl(new (array_lengthof(Ops)) DICompileUnit(
535 Context, Storage, SourceLanguage, IsOptimized,
536 RuntimeVersion, EmissionKind, DWOId, SplitDebugInlining,
537 DebugInfoForProfiling, NameTableKind, RangesBaseAddress,
538 Ops),
539 Storage);
540}
541
542Optional<DICompileUnit::DebugEmissionKind>
543DICompileUnit::getEmissionKind(StringRef Str) {
544 return StringSwitch<Optional<DebugEmissionKind>>(Str)
545 .Case("NoDebug", NoDebug)
546 .Case("FullDebug", FullDebug)
547 .Case("LineTablesOnly", LineTablesOnly)
548 .Case("DebugDirectivesOnly", DebugDirectivesOnly)
549 .Default(None);
550}
551
552Optional<DICompileUnit::DebugNameTableKind>
553DICompileUnit::getNameTableKind(StringRef Str) {
554 return StringSwitch<Optional<DebugNameTableKind>>(Str)
555 .Case("Default", DebugNameTableKind::Default)
556 .Case("GNU", DebugNameTableKind::GNU)
557 .Case("None", DebugNameTableKind::None)
558 .Default(None);
559}
560
561const char *DICompileUnit::emissionKindString(DebugEmissionKind EK) {
562 switch (EK) {
563 case NoDebug: return "NoDebug";
564 case FullDebug: return "FullDebug";
565 case LineTablesOnly: return "LineTablesOnly";
566 case DebugDirectivesOnly: return "DebugDirectivesOnly";
567 }
568 return nullptr;
569}
570
571const char *DICompileUnit::nameTableKindString(DebugNameTableKind NTK) {
572 switch (NTK) {
573 case DebugNameTableKind::Default:
574 return nullptr;
575 case DebugNameTableKind::GNU:
576 return "GNU";
577 case DebugNameTableKind::None:
578 return "None";
579 }
580 return nullptr;
581}
582
583DISubprogram *DILocalScope::getSubprogram() const {
584 if (auto *Block = dyn_cast<DILexicalBlockBase>(this))
585 return Block->getScope()->getSubprogram();
586 return const_cast<DISubprogram *>(cast<DISubprogram>(this));
587}
588
589DILocalScope *DILocalScope::getNonLexicalBlockFileScope() const {
590 if (auto *File = dyn_cast<DILexicalBlockFile>(this))
591 return File->getScope()->getNonLexicalBlockFileScope();
592 return const_cast<DILocalScope *>(this);
593}
594
595DISubprogram::DISPFlags DISubprogram::getFlag(StringRef Flag) {
596 return StringSwitch<DISPFlags>(Flag)
597#define HANDLE_DISP_FLAG(ID, NAME) .Case("DISPFlag" #NAME, SPFlag##NAME)
598#include "llvm/IR/DebugInfoFlags.def"
599 .Default(SPFlagZero);
600}
601
602StringRef DISubprogram::getFlagString(DISPFlags Flag) {
603 switch (Flag) {
604 // Appease a warning.
605 case SPFlagVirtuality:
606 return "";
607#define HANDLE_DISP_FLAG(ID, NAME) \
608 case SPFlag##NAME: \
609 return "DISPFlag" #NAME;
610#include "llvm/IR/DebugInfoFlags.def"
611 }
612 return "";
613}
614
615DISubprogram::DISPFlags
616DISubprogram::splitFlags(DISPFlags Flags,
617 SmallVectorImpl<DISPFlags> &SplitFlags) {
618 // Multi-bit fields can require special handling. In our case, however, the
619 // only multi-bit field is virtuality, and all its values happen to be
620 // single-bit values, so the right behavior just falls out.
621#define HANDLE_DISP_FLAG(ID, NAME) \
622 if (DISPFlags Bit = Flags & SPFlag##NAME) { \
623 SplitFlags.push_back(Bit); \
624 Flags &= ~Bit; \
625 }
626#include "llvm/IR/DebugInfoFlags.def"
627 return Flags;
628}
629
630DISubprogram *DISubprogram::getImpl(
631 LLVMContext &Context, Metadata *Scope, MDString *Name,
632 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
633 unsigned ScopeLine, Metadata *ContainingType, unsigned VirtualIndex,
634 int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags, Metadata *Unit,
635 Metadata *TemplateParams, Metadata *Declaration, Metadata *RetainedNodes,
636 Metadata *ThrownTypes, StorageType Storage, bool ShouldCreate) {
637 assert(isCanonical(Name) && "Expected canonical MDString")((isCanonical(Name) && "Expected canonical MDString")
? static_cast<void> (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 637, __PRETTY_FUNCTION__))
;
638 assert(isCanonical(LinkageName) && "Expected canonical MDString")((isCanonical(LinkageName) && "Expected canonical MDString"
) ? static_cast<void> (0) : __assert_fail ("isCanonical(LinkageName) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 638, __PRETTY_FUNCTION__))
;
639 DEFINE_GETIMPL_LOOKUP(DISubprogram,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name
, LinkageName, File, Line, Type, ScopeLine, ContainingType, VirtualIndex
, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams, Declaration
, RetainedNodes, ThrownTypes))) return N; if (!ShouldCreate) return
nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 643, __PRETTY_FUNCTION__)); } } while (false)
640 (Scope, Name, LinkageName, File, Line, Type, ScopeLine,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name
, LinkageName, File, Line, Type, ScopeLine, ContainingType, VirtualIndex
, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams, Declaration
, RetainedNodes, ThrownTypes))) return N; if (!ShouldCreate) return
nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 643, __PRETTY_FUNCTION__)); } } while (false)
641 ContainingType, VirtualIndex, ThisAdjustment, Flags,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name
, LinkageName, File, Line, Type, ScopeLine, ContainingType, VirtualIndex
, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams, Declaration
, RetainedNodes, ThrownTypes))) return N; if (!ShouldCreate) return
nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 643, __PRETTY_FUNCTION__)); } } while (false)
642 SPFlags, Unit, TemplateParams, Declaration,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name
, LinkageName, File, Line, Type, ScopeLine, ContainingType, VirtualIndex
, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams, Declaration
, RetainedNodes, ThrownTypes))) return N; if (!ShouldCreate) return
nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 643, __PRETTY_FUNCTION__)); } } while (false)
643 RetainedNodes, ThrownTypes))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name
, LinkageName, File, Line, Type, ScopeLine, ContainingType, VirtualIndex
, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams, Declaration
, RetainedNodes, ThrownTypes))) return N; if (!ShouldCreate) return
nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 643, __PRETTY_FUNCTION__)); } } while (false)
;
644 SmallVector<Metadata *, 11> Ops = {
645 File, Scope, Name, LinkageName, Type, Unit,
646 Declaration, RetainedNodes, ContainingType, TemplateParams, ThrownTypes};
647 if (!ThrownTypes) {
648 Ops.pop_back();
649 if (!TemplateParams) {
650 Ops.pop_back();
651 if (!ContainingType)
652 Ops.pop_back();
653 }
654 }
655 DEFINE_GETIMPL_STORE_N(return storeImpl(new (Ops.size()) DISubprogram(Context, Storage
, Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags, SPFlags
, Ops), Storage, Context.pImpl->DISubprograms)
656 DISubprogram,return storeImpl(new (Ops.size()) DISubprogram(Context, Storage
, Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags, SPFlags
, Ops), Storage, Context.pImpl->DISubprograms)
657 (Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags, SPFlags), Ops,return storeImpl(new (Ops.size()) DISubprogram(Context, Storage
, Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags, SPFlags
, Ops), Storage, Context.pImpl->DISubprograms)
658 Ops.size())return storeImpl(new (Ops.size()) DISubprogram(Context, Storage
, Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags, SPFlags
, Ops), Storage, Context.pImpl->DISubprograms)
;
659}
660
661bool DISubprogram::describes(const Function *F) const {
662 assert(F && "Invalid function")((F && "Invalid function") ? static_cast<void> (
0) : __assert_fail ("F && \"Invalid function\"", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 662, __PRETTY_FUNCTION__))
;
663 if (F->getSubprogram() == this)
664 return true;
665 StringRef Name = getLinkageName();
666 if (Name.empty())
667 Name = getName();
668 return F->getName() == Name;
669}
670
671DILexicalBlock *DILexicalBlock::getImpl(LLVMContext &Context, Metadata *Scope,
672 Metadata *File, unsigned Line,
673 unsigned Column, StorageType Storage,
674 bool ShouldCreate) {
675 // Fixup column.
676 adjustColumn(Column);
677
678 assert(Scope && "Expected scope")((Scope && "Expected scope") ? static_cast<void>
(0) : __assert_fail ("Scope && \"Expected scope\"", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 678, __PRETTY_FUNCTION__))
;
679 DEFINE_GETIMPL_LOOKUP(DILexicalBlock, (Scope, File, Line, Column))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DILexicalBlocks, DILexicalBlockInfo::KeyTy(Scope, File
, Line, Column))) return N; if (!ShouldCreate) return nullptr
; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 679, __PRETTY_FUNCTION__)); } } while (false)
;
680 Metadata *Ops[] = {File, Scope};
681 DEFINE_GETIMPL_STORE(DILexicalBlock, (Line, Column), Ops)return storeImpl(new (array_lengthof(Ops)) DILexicalBlock(Context
, Storage, Line, Column, Ops), Storage, Context.pImpl->DILexicalBlocks
)
;
682}
683
684DILexicalBlockFile *DILexicalBlockFile::getImpl(LLVMContext &Context,
685 Metadata *Scope, Metadata *File,
686 unsigned Discriminator,
687 StorageType Storage,
688 bool ShouldCreate) {
689 assert(Scope && "Expected scope")((Scope && "Expected scope") ? static_cast<void>
(0) : __assert_fail ("Scope && \"Expected scope\"", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 689, __PRETTY_FUNCTION__))
;
690 DEFINE_GETIMPL_LOOKUP(DILexicalBlockFile, (Scope, File, Discriminator))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DILexicalBlockFiles, DILexicalBlockFileInfo::KeyTy
(Scope, File, Discriminator))) return N; if (!ShouldCreate) return
nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 690, __PRETTY_FUNCTION__)); } } while (false)
;
691 Metadata *Ops[] = {File, Scope};
692 DEFINE_GETIMPL_STORE(DILexicalBlockFile, (Discriminator), Ops)return storeImpl(new (array_lengthof(Ops)) DILexicalBlockFile
(Context, Storage, Discriminator, Ops), Storage, Context.pImpl
->DILexicalBlockFiles)
;
693}
694
695DINamespace *DINamespace::getImpl(LLVMContext &Context, Metadata *Scope,
696 MDString *Name, bool ExportSymbols,
697 StorageType Storage, bool ShouldCreate) {
698 assert(isCanonical(Name) && "Expected canonical MDString")((isCanonical(Name) && "Expected canonical MDString")
? static_cast<void> (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 698, __PRETTY_FUNCTION__))
;
699 DEFINE_GETIMPL_LOOKUP(DINamespace, (Scope, Name, ExportSymbols))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DINamespaces, DINamespaceInfo::KeyTy(Scope, Name, ExportSymbols
))) return N; if (!ShouldCreate) return nullptr; } else { ((ShouldCreate
&& "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 699, __PRETTY_FUNCTION__)); } } while (false)
;
700 // The nullptr is for DIScope's File operand. This should be refactored.
701 Metadata *Ops[] = {nullptr, Scope, Name};
702 DEFINE_GETIMPL_STORE(DINamespace, (ExportSymbols), Ops)return storeImpl(new (array_lengthof(Ops)) DINamespace(Context
, Storage, ExportSymbols, Ops), Storage, Context.pImpl->DINamespaces
)
;
703}
704
705DICommonBlock *DICommonBlock::getImpl(LLVMContext &Context, Metadata *Scope,
706 Metadata *Decl, MDString *Name,
707 Metadata *File, unsigned LineNo,
708 StorageType Storage, bool ShouldCreate) {
709 assert(isCanonical(Name) && "Expected canonical MDString")((isCanonical(Name) && "Expected canonical MDString")
? static_cast<void> (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 709, __PRETTY_FUNCTION__))
;
710 DEFINE_GETIMPL_LOOKUP(DICommonBlock, (Scope, Decl, Name, File, LineNo))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DICommonBlocks, DICommonBlockInfo::KeyTy(Scope, Decl
, Name, File, LineNo))) return N; if (!ShouldCreate) return nullptr
; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 710, __PRETTY_FUNCTION__)); } } while (false)
;
711 // The nullptr is for DIScope's File operand. This should be refactored.
712 Metadata *Ops[] = {Scope, Decl, Name, File};
713 DEFINE_GETIMPL_STORE(DICommonBlock, (LineNo), Ops)return storeImpl(new (array_lengthof(Ops)) DICommonBlock(Context
, Storage, LineNo, Ops), Storage, Context.pImpl->DICommonBlocks
)
;
714}
715
716DIModule *DIModule::getImpl(LLVMContext &Context, Metadata *Scope,
717 MDString *Name, MDString *ConfigurationMacros,
718 MDString *IncludePath, MDString *SysRoot,
719 StorageType Storage, bool ShouldCreate) {
720 assert(isCanonical(Name) && "Expected canonical MDString")((isCanonical(Name) && "Expected canonical MDString")
? static_cast<void> (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 720, __PRETTY_FUNCTION__))
;
721 DEFINE_GETIMPL_LOOKUP(do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIModules, DIModuleInfo::KeyTy(Scope, Name, ConfigurationMacros
, IncludePath, SysRoot))) return N; if (!ShouldCreate) return
nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 722, __PRETTY_FUNCTION__)); } } while (false)
722 DIModule, (Scope, Name, ConfigurationMacros, IncludePath, SysRoot))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIModules, DIModuleInfo::KeyTy(Scope, Name, ConfigurationMacros
, IncludePath, SysRoot))) return N; if (!ShouldCreate) return
nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 722, __PRETTY_FUNCTION__)); } } while (false)
;
723 Metadata *Ops[] = {Scope, Name, ConfigurationMacros, IncludePath, SysRoot};
724 DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIModule, Ops)return storeImpl(new (array_lengthof(Ops)) DIModule(Context, Storage
, Ops), Storage, Context.pImpl->DIModules)
;
725}
726
727DITemplateTypeParameter *DITemplateTypeParameter::getImpl(LLVMContext &Context,
728 MDString *Name,
729 Metadata *Type,
730 StorageType Storage,
731 bool ShouldCreate) {
732 assert(isCanonical(Name) && "Expected canonical MDString")((isCanonical(Name) && "Expected canonical MDString")
? static_cast<void> (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 732, __PRETTY_FUNCTION__))
;
733 DEFINE_GETIMPL_LOOKUP(DITemplateTypeParameter, (Name, Type))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DITemplateTypeParameters, DITemplateTypeParameterInfo
::KeyTy(Name, Type))) return N; if (!ShouldCreate) return nullptr
; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 733, __PRETTY_FUNCTION__)); } } while (false)
;
734 Metadata *Ops[] = {Name, Type};
735 DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DITemplateTypeParameter, Ops)return storeImpl(new (array_lengthof(Ops)) DITemplateTypeParameter
(Context, Storage, Ops), Storage, Context.pImpl->DITemplateTypeParameters
)
;
736}
737
738DITemplateValueParameter *DITemplateValueParameter::getImpl(
739 LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *Type,
740 Metadata *Value, StorageType Storage, bool ShouldCreate) {
741 assert(isCanonical(Name) && "Expected canonical MDString")((isCanonical(Name) && "Expected canonical MDString")
? static_cast<void> (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 741, __PRETTY_FUNCTION__))
;
742 DEFINE_GETIMPL_LOOKUP(DITemplateValueParameter, (Tag, Name, Type, Value))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DITemplateValueParameters, DITemplateValueParameterInfo
::KeyTy(Tag, Name, Type, Value))) return N; if (!ShouldCreate
) return nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 742, __PRETTY_FUNCTION__)); } } while (false)
;
743 Metadata *Ops[] = {Name, Type, Value};
744 DEFINE_GETIMPL_STORE(DITemplateValueParameter, (Tag), Ops)return storeImpl(new (array_lengthof(Ops)) DITemplateValueParameter
(Context, Storage, Tag, Ops), Storage, Context.pImpl->DITemplateValueParameters
)
;
745}
746
747DIGlobalVariable *
748DIGlobalVariable::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
749 MDString *LinkageName, Metadata *File, unsigned Line,
750 Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
751 Metadata *StaticDataMemberDeclaration,
752 Metadata *TemplateParams, uint32_t AlignInBits,
753 StorageType Storage, bool ShouldCreate) {
754 assert(isCanonical(Name) && "Expected canonical MDString")((isCanonical(Name) && "Expected canonical MDString")
? static_cast<void> (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 754, __PRETTY_FUNCTION__))
;
755 assert(isCanonical(LinkageName) && "Expected canonical MDString")((isCanonical(LinkageName) && "Expected canonical MDString"
) ? static_cast<void> (0) : __assert_fail ("isCanonical(LinkageName) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 755, __PRETTY_FUNCTION__))
;
756 DEFINE_GETIMPL_LOOKUP(DIGlobalVariable, (Scope, Name, LinkageName, File, Line,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIGlobalVariables, DIGlobalVariableInfo::KeyTy(Scope
, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition
, StaticDataMemberDeclaration, TemplateParams, AlignInBits)))
return N; if (!ShouldCreate) return nullptr; } else { ((ShouldCreate
&& "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 759, __PRETTY_FUNCTION__)); } } while (false)
757 Type, IsLocalToUnit, IsDefinition,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIGlobalVariables, DIGlobalVariableInfo::KeyTy(Scope
, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition
, StaticDataMemberDeclaration, TemplateParams, AlignInBits)))
return N; if (!ShouldCreate) return nullptr; } else { ((ShouldCreate
&& "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 759, __PRETTY_FUNCTION__)); } } while (false)
758 StaticDataMemberDeclaration,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIGlobalVariables, DIGlobalVariableInfo::KeyTy(Scope
, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition
, StaticDataMemberDeclaration, TemplateParams, AlignInBits)))
return N; if (!ShouldCreate) return nullptr; } else { ((ShouldCreate
&& "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 759, __PRETTY_FUNCTION__)); } } while (false)
759 TemplateParams, AlignInBits))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIGlobalVariables, DIGlobalVariableInfo::KeyTy(Scope
, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition
, StaticDataMemberDeclaration, TemplateParams, AlignInBits)))
return N; if (!ShouldCreate) return nullptr; } else { ((ShouldCreate
&& "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 759, __PRETTY_FUNCTION__)); } } while (false)
;
760 Metadata *Ops[] = {Scope,
761 Name,
762 File,
763 Type,
764 Name,
765 LinkageName,
766 StaticDataMemberDeclaration,
767 TemplateParams};
768 DEFINE_GETIMPL_STORE(DIGlobalVariable,return storeImpl(new (array_lengthof(Ops)) DIGlobalVariable(Context
, Storage, Line, IsLocalToUnit, IsDefinition, AlignInBits, Ops
), Storage, Context.pImpl->DIGlobalVariables)
769 (Line, IsLocalToUnit, IsDefinition, AlignInBits), Ops)return storeImpl(new (array_lengthof(Ops)) DIGlobalVariable(Context
, Storage, Line, IsLocalToUnit, IsDefinition, AlignInBits, Ops
), Storage, Context.pImpl->DIGlobalVariables)
;
770}
771
772DILocalVariable *DILocalVariable::getImpl(LLVMContext &Context, Metadata *Scope,
773 MDString *Name, Metadata *File,
774 unsigned Line, Metadata *Type,
775 unsigned Arg, DIFlags Flags,
776 uint32_t AlignInBits,
777 StorageType Storage,
778 bool ShouldCreate) {
779 // 64K ought to be enough for any frontend.
780 assert(Arg <= UINT16_MAX && "Expected argument number to fit in 16-bits")((Arg <= (65535) && "Expected argument number to fit in 16-bits"
) ? static_cast<void> (0) : __assert_fail ("Arg <= UINT16_MAX && \"Expected argument number to fit in 16-bits\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 780, __PRETTY_FUNCTION__))
;
781
782 assert(Scope && "Expected scope")((Scope && "Expected scope") ? static_cast<void>
(0) : __assert_fail ("Scope && \"Expected scope\"", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 782, __PRETTY_FUNCTION__))
;
783 assert(isCanonical(Name) && "Expected canonical MDString")((isCanonical(Name) && "Expected canonical MDString")
? static_cast<void> (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 783, __PRETTY_FUNCTION__))
;
784 DEFINE_GETIMPL_LOOKUP(DILocalVariable,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DILocalVariables, DILocalVariableInfo::KeyTy(Scope
, Name, File, Line, Type, Arg, Flags, AlignInBits))) return N
; if (!ShouldCreate) return nullptr; } else { ((ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? static_cast
<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 786, __PRETTY_FUNCTION__)); } } while (false)
785 (Scope, Name, File, Line, Type, Arg, Flags,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DILocalVariables, DILocalVariableInfo::KeyTy(Scope
, Name, File, Line, Type, Arg, Flags, AlignInBits))) return N
; if (!ShouldCreate) return nullptr; } else { ((ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? static_cast
<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 786, __PRETTY_FUNCTION__)); } } while (false)
786 AlignInBits))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DILocalVariables, DILocalVariableInfo::KeyTy(Scope
, Name, File, Line, Type, Arg, Flags, AlignInBits))) return N
; if (!ShouldCreate) return nullptr; } else { ((ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? static_cast
<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 786, __PRETTY_FUNCTION__)); } } while (false)
;
787 Metadata *Ops[] = {Scope, Name, File, Type};
788 DEFINE_GETIMPL_STORE(DILocalVariable, (Line, Arg, Flags, AlignInBits), Ops)return storeImpl(new (array_lengthof(Ops)) DILocalVariable(Context
, Storage, Line, Arg, Flags, AlignInBits, Ops), Storage, Context
.pImpl->DILocalVariables)
;
789}
790
791Optional<uint64_t> DIVariable::getSizeInBits() const {
792 // This is used by the Verifier so be mindful of broken types.
793 const Metadata *RawType = getRawType();
794 while (RawType) {
795 // Try to get the size directly.
796 if (auto *T = dyn_cast<DIType>(RawType))
797 if (uint64_t Size = T->getSizeInBits())
798 return Size;
799
800 if (auto *DT = dyn_cast<DIDerivedType>(RawType)) {
801 // Look at the base type.
802 RawType = DT->getRawBaseType();
803 continue;
804 }
805
806 // Missing type or size.
807 break;
808 }
809
810 // Fail gracefully.
811 return None;
812}
813
814DILabel *DILabel::getImpl(LLVMContext &Context, Metadata *Scope,
815 MDString *Name, Metadata *File, unsigned Line,
816 StorageType Storage,
817 bool ShouldCreate) {
818 assert(Scope && "Expected scope")((Scope && "Expected scope") ? static_cast<void>
(0) : __assert_fail ("Scope && \"Expected scope\"", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 818, __PRETTY_FUNCTION__))
;
819 assert(isCanonical(Name) && "Expected canonical MDString")((isCanonical(Name) && "Expected canonical MDString")
? static_cast<void> (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 819, __PRETTY_FUNCTION__))
;
820 DEFINE_GETIMPL_LOOKUP(DILabel,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DILabels, DILabelInfo::KeyTy(Scope, Name, File, Line
))) return N; if (!ShouldCreate) return nullptr; } else { ((ShouldCreate
&& "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 821, __PRETTY_FUNCTION__)); } } while (false)
821 (Scope, Name, File, Line))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DILabels, DILabelInfo::KeyTy(Scope, Name, File, Line
))) return N; if (!ShouldCreate) return nullptr; } else { ((ShouldCreate
&& "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 821, __PRETTY_FUNCTION__)); } } while (false)
;
822 Metadata *Ops[] = {Scope, Name, File};
823 DEFINE_GETIMPL_STORE(DILabel, (Line), Ops)return storeImpl(new (array_lengthof(Ops)) DILabel(Context, Storage
, Line, Ops), Storage, Context.pImpl->DILabels)
;
824}
825
826DIExpression *DIExpression::getImpl(LLVMContext &Context,
827 ArrayRef<uint64_t> Elements,
828 StorageType Storage, bool ShouldCreate) {
829 DEFINE_GETIMPL_LOOKUP(DIExpression, (Elements))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIExpressions, DIExpressionInfo::KeyTy(Elements)))
return N; if (!ShouldCreate) return nullptr; } else { ((ShouldCreate
&& "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 829, __PRETTY_FUNCTION__)); } } while (false)
;
830 DEFINE_GETIMPL_STORE_NO_OPS(DIExpression, (Elements))return storeImpl(new (0u) DIExpression(Context, Storage, Elements
), Storage, Context.pImpl->DIExpressions)
;
831}
832
833unsigned DIExpression::ExprOperand::getSize() const {
834 uint64_t Op = getOp();
835
836 if (Op >= dwarf::DW_OP_breg0 && Op <= dwarf::DW_OP_breg31)
837 return 2;
838
839 switch (Op) {
840 case dwarf::DW_OP_LLVM_convert:
841 case dwarf::DW_OP_LLVM_fragment:
842 case dwarf::DW_OP_bregx:
843 return 3;
844 case dwarf::DW_OP_constu:
845 case dwarf::DW_OP_consts:
846 case dwarf::DW_OP_deref_size:
847 case dwarf::DW_OP_plus_uconst:
848 case dwarf::DW_OP_LLVM_tag_offset:
849 case dwarf::DW_OP_LLVM_entry_value:
850 case dwarf::DW_OP_regx:
851 return 2;
852 default:
853 return 1;
854 }
855}
856
857bool DIExpression::isValid() const {
858 for (auto I = expr_op_begin(), E = expr_op_end(); I != E; ++I) {
859 // Check that there's space for the operand.
860 if (I->get() + I->getSize() > E->get())
861 return false;
862
863 uint64_t Op = I->getOp();
864 if ((Op >= dwarf::DW_OP_reg0 && Op <= dwarf::DW_OP_reg31) ||
865 (Op >= dwarf::DW_OP_breg0 && Op <= dwarf::DW_OP_breg31))
866 return true;
867
868 // Check that the operand is valid.
869 switch (Op) {
870 default:
871 return false;
872 case dwarf::DW_OP_LLVM_fragment:
873 // A fragment operator must appear at the end.
874 return I->get() + I->getSize() == E->get();
875 case dwarf::DW_OP_stack_value: {
876 // Must be the last one or followed by a DW_OP_LLVM_fragment.
877 if (I->get() + I->getSize() == E->get())
878 break;
879 auto J = I;
880 if ((++J)->getOp() != dwarf::DW_OP_LLVM_fragment)
881 return false;
882 break;
883 }
884 case dwarf::DW_OP_swap: {
885 // Must be more than one implicit element on the stack.
886
887 // FIXME: A better way to implement this would be to add a local variable
888 // that keeps track of the stack depth and introduce something like a
889 // DW_LLVM_OP_implicit_location as a placeholder for the location this
890 // DIExpression is attached to, or else pass the number of implicit stack
891 // elements into isValid.
892 if (getNumElements() == 1)
893 return false;
894 break;
895 }
896 case dwarf::DW_OP_LLVM_entry_value: {
897 // An entry value operator must appear at the beginning and the number of
898 // operations it cover can currently only be 1, because we support only
899 // entry values of a simple register location. One reason for this is that
900 // we currently can't calculate the size of the resulting DWARF block for
901 // other expressions.
902 return I->get() == expr_op_begin()->get() && I->getArg(0) == 1 &&
903 getNumElements() == 2;
904 }
905 case dwarf::DW_OP_LLVM_convert:
906 case dwarf::DW_OP_LLVM_tag_offset:
907 case dwarf::DW_OP_constu:
908 case dwarf::DW_OP_plus_uconst:
909 case dwarf::DW_OP_plus:
910 case dwarf::DW_OP_minus:
911 case dwarf::DW_OP_mul:
912 case dwarf::DW_OP_div:
913 case dwarf::DW_OP_mod:
914 case dwarf::DW_OP_or:
915 case dwarf::DW_OP_and:
916 case dwarf::DW_OP_xor:
917 case dwarf::DW_OP_shl:
918 case dwarf::DW_OP_shr:
919 case dwarf::DW_OP_shra:
920 case dwarf::DW_OP_deref:
921 case dwarf::DW_OP_deref_size:
922 case dwarf::DW_OP_xderef:
923 case dwarf::DW_OP_lit0:
924 case dwarf::DW_OP_not:
925 case dwarf::DW_OP_dup:
926 case dwarf::DW_OP_regx:
927 case dwarf::DW_OP_bregx:
928 break;
929 }
930 }
931 return true;
932}
933
934bool DIExpression::isImplicit() const {
935 if (!isValid())
936 return false;
937
938 if (getNumElements() == 0)
939 return false;
940
941 for (const auto &It : expr_ops()) {
942 switch (It.getOp()) {
943 default:
944 break;
945 case dwarf::DW_OP_stack_value:
946 case dwarf::DW_OP_LLVM_tag_offset:
947 return true;
948 }
949 }
950
951 return false;
952}
953
954bool DIExpression::isComplex() const {
955 if (!isValid())
956 return false;
957
958 if (getNumElements() == 0)
959 return false;
960
961 // If there are any elements other than fragment or tag_offset, then some
962 // kind of complex computation occurs.
963 for (const auto &It : expr_ops()) {
964 switch (It.getOp()) {
965 case dwarf::DW_OP_LLVM_tag_offset:
966 case dwarf::DW_OP_LLVM_fragment:
967 continue;
968 default: return true;
969 }
970 }
971
972 return false;
973}
974
975Optional<DIExpression::FragmentInfo>
976DIExpression::getFragmentInfo(expr_op_iterator Start, expr_op_iterator End) {
977 for (auto I = Start; I != End; ++I)
978 if (I->getOp() == dwarf::DW_OP_LLVM_fragment) {
979 DIExpression::FragmentInfo Info = {I->getArg(1), I->getArg(0)};
980 return Info;
981 }
982 return None;
983}
984
985void DIExpression::appendOffset(SmallVectorImpl<uint64_t> &Ops,
986 int64_t Offset) {
987 if (Offset > 0) {
988 Ops.push_back(dwarf::DW_OP_plus_uconst);
989 Ops.push_back(Offset);
990 } else if (Offset < 0) {
991 Ops.push_back(dwarf::DW_OP_constu);
992 Ops.push_back(-Offset);
993 Ops.push_back(dwarf::DW_OP_minus);
994 }
995}
996
997bool DIExpression::extractIfOffset(int64_t &Offset) const {
998 if (getNumElements() == 0) {
999 Offset = 0;
1000 return true;
1001 }
1002
1003 if (getNumElements() == 2 && Elements[0] == dwarf::DW_OP_plus_uconst) {
1004 Offset = Elements[1];
1005 return true;
1006 }
1007
1008 if (getNumElements() == 3 && Elements[0] == dwarf::DW_OP_constu) {
1009 if (Elements[2] == dwarf::DW_OP_plus) {
1010 Offset = Elements[1];
1011 return true;
1012 }
1013 if (Elements[2] == dwarf::DW_OP_minus) {
1014 Offset = -Elements[1];
1015 return true;
1016 }
1017 }
1018
1019 return false;
1020}
1021
1022const DIExpression *DIExpression::extractAddressClass(const DIExpression *Expr,
1023 unsigned &AddrClass) {
1024 // FIXME: This seems fragile. Nothing that verifies that these elements
1025 // actually map to ops and not operands.
1026 const unsigned PatternSize = 4;
1027 if (Expr->Elements.size() >= PatternSize &&
1028 Expr->Elements[PatternSize - 4] == dwarf::DW_OP_constu &&
1029 Expr->Elements[PatternSize - 2] == dwarf::DW_OP_swap &&
1030 Expr->Elements[PatternSize - 1] == dwarf::DW_OP_xderef) {
1031 AddrClass = Expr->Elements[PatternSize - 3];
1032
1033 if (Expr->Elements.size() == PatternSize)
1034 return nullptr;
1035 return DIExpression::get(Expr->getContext(),
1036 makeArrayRef(&*Expr->Elements.begin(),
1037 Expr->Elements.size() - PatternSize));
1038 }
1039 return Expr;
1040}
1041
1042DIExpression *DIExpression::prepend(const DIExpression *Expr, uint8_t Flags,
1043 int64_t Offset) {
1044 SmallVector<uint64_t, 8> Ops;
1045 if (Flags & DIExpression::DerefBefore)
1046 Ops.push_back(dwarf::DW_OP_deref);
1047
1048 appendOffset(Ops, Offset);
1049 if (Flags & DIExpression::DerefAfter)
1050 Ops.push_back(dwarf::DW_OP_deref);
1051
1052 bool StackValue = Flags & DIExpression::StackValue;
1053 bool EntryValue = Flags & DIExpression::EntryValue;
1054
1055 return prependOpcodes(Expr, Ops, StackValue, EntryValue);
1056}
1057
1058DIExpression *DIExpression::prependOpcodes(const DIExpression *Expr,
1059 SmallVectorImpl<uint64_t> &Ops,
1060 bool StackValue,
1061 bool EntryValue) {
1062 assert(Expr && "Can't prepend ops to this expression")((Expr && "Can't prepend ops to this expression") ? static_cast
<void> (0) : __assert_fail ("Expr && \"Can't prepend ops to this expression\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1062, __PRETTY_FUNCTION__))
;
1063
1064 if (EntryValue) {
1065 Ops.push_back(dwarf::DW_OP_LLVM_entry_value);
1066 // Add size info needed for entry value expression.
1067 // Add plus one for target register operand.
1068 Ops.push_back(Expr->getNumElements() + 1);
1069 }
1070
1071 // If there are no ops to prepend, do not even add the DW_OP_stack_value.
1072 if (Ops.empty())
1073 StackValue = false;
1074 for (auto Op : Expr->expr_ops()) {
1075 // A DW_OP_stack_value comes at the end, but before a DW_OP_LLVM_fragment.
1076 if (StackValue) {
1077 if (Op.getOp() == dwarf::DW_OP_stack_value)
1078 StackValue = false;
1079 else if (Op.getOp() == dwarf::DW_OP_LLVM_fragment) {
1080 Ops.push_back(dwarf::DW_OP_stack_value);
1081 StackValue = false;
1082 }
1083 }
1084 Op.appendToVector(Ops);
1085 }
1086 if (StackValue)
1087 Ops.push_back(dwarf::DW_OP_stack_value);
1088 return DIExpression::get(Expr->getContext(), Ops);
1089}
1090
1091DIExpression *DIExpression::append(const DIExpression *Expr,
1092 ArrayRef<uint64_t> Ops) {
1093 assert(Expr && !Ops.empty() && "Can't append ops to this expression")((Expr && !Ops.empty() && "Can't append ops to this expression"
) ? static_cast<void> (0) : __assert_fail ("Expr && !Ops.empty() && \"Can't append ops to this expression\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1093, __PRETTY_FUNCTION__))
;
1094
1095 // Copy Expr's current op list.
1096 SmallVector<uint64_t, 16> NewOps;
1097 for (auto Op : Expr->expr_ops()) {
1098 // Append new opcodes before DW_OP_{stack_value, LLVM_fragment}.
1099 if (Op.getOp() == dwarf::DW_OP_stack_value ||
1100 Op.getOp() == dwarf::DW_OP_LLVM_fragment) {
1101 NewOps.append(Ops.begin(), Ops.end());
1102
1103 // Ensure that the new opcodes are only appended once.
1104 Ops = None;
1105 }
1106 Op.appendToVector(NewOps);
1107 }
1108
1109 NewOps.append(Ops.begin(), Ops.end());
1110 return DIExpression::get(Expr->getContext(), NewOps);
1111}
1112
1113DIExpression *DIExpression::appendToStack(const DIExpression *Expr,
1114 ArrayRef<uint64_t> Ops) {
1115 assert(Expr && !Ops.empty() && "Can't append ops to this expression")((Expr && !Ops.empty() && "Can't append ops to this expression"
) ? static_cast<void> (0) : __assert_fail ("Expr && !Ops.empty() && \"Can't append ops to this expression\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1115, __PRETTY_FUNCTION__))
;
1116 assert(none_of(Ops,((none_of(Ops, [](uint64_t Op) { return Op == dwarf::DW_OP_stack_value
|| Op == dwarf::DW_OP_LLVM_fragment; }) && "Can't append this op"
) ? static_cast<void> (0) : __assert_fail ("none_of(Ops, [](uint64_t Op) { return Op == dwarf::DW_OP_stack_value || Op == dwarf::DW_OP_LLVM_fragment; }) && \"Can't append this op\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1121, __PRETTY_FUNCTION__))
1117 [](uint64_t Op) {((none_of(Ops, [](uint64_t Op) { return Op == dwarf::DW_OP_stack_value
|| Op == dwarf::DW_OP_LLVM_fragment; }) && "Can't append this op"
) ? static_cast<void> (0) : __assert_fail ("none_of(Ops, [](uint64_t Op) { return Op == dwarf::DW_OP_stack_value || Op == dwarf::DW_OP_LLVM_fragment; }) && \"Can't append this op\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1121, __PRETTY_FUNCTION__))
1118 return Op == dwarf::DW_OP_stack_value ||((none_of(Ops, [](uint64_t Op) { return Op == dwarf::DW_OP_stack_value
|| Op == dwarf::DW_OP_LLVM_fragment; }) && "Can't append this op"
) ? static_cast<void> (0) : __assert_fail ("none_of(Ops, [](uint64_t Op) { return Op == dwarf::DW_OP_stack_value || Op == dwarf::DW_OP_LLVM_fragment; }) && \"Can't append this op\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1121, __PRETTY_FUNCTION__))
1119 Op == dwarf::DW_OP_LLVM_fragment;((none_of(Ops, [](uint64_t Op) { return Op == dwarf::DW_OP_stack_value
|| Op == dwarf::DW_OP_LLVM_fragment; }) && "Can't append this op"
) ? static_cast<void> (0) : __assert_fail ("none_of(Ops, [](uint64_t Op) { return Op == dwarf::DW_OP_stack_value || Op == dwarf::DW_OP_LLVM_fragment; }) && \"Can't append this op\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1121, __PRETTY_FUNCTION__))
1120 }) &&((none_of(Ops, [](uint64_t Op) { return Op == dwarf::DW_OP_stack_value
|| Op == dwarf::DW_OP_LLVM_fragment; }) && "Can't append this op"
) ? static_cast<void> (0) : __assert_fail ("none_of(Ops, [](uint64_t Op) { return Op == dwarf::DW_OP_stack_value || Op == dwarf::DW_OP_LLVM_fragment; }) && \"Can't append this op\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1121, __PRETTY_FUNCTION__))
1121 "Can't append this op")((none_of(Ops, [](uint64_t Op) { return Op == dwarf::DW_OP_stack_value
|| Op == dwarf::DW_OP_LLVM_fragment; }) && "Can't append this op"
) ? static_cast<void> (0) : __assert_fail ("none_of(Ops, [](uint64_t Op) { return Op == dwarf::DW_OP_stack_value || Op == dwarf::DW_OP_LLVM_fragment; }) && \"Can't append this op\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1121, __PRETTY_FUNCTION__))
;
1122
1123 // Append a DW_OP_deref after Expr's current op list if it's non-empty and
1124 // has no DW_OP_stack_value.
1125 //
1126 // Match .* DW_OP_stack_value (DW_OP_LLVM_fragment A B)?.
1127 Optional<FragmentInfo> FI = Expr->getFragmentInfo();
1128 unsigned DropUntilStackValue = FI.hasValue() ? 3 : 0;
1129 ArrayRef<uint64_t> ExprOpsBeforeFragment =
1130 Expr->getElements().drop_back(DropUntilStackValue);
1131 bool NeedsDeref = (Expr->getNumElements() > DropUntilStackValue) &&
1132 (ExprOpsBeforeFragment.back() != dwarf::DW_OP_stack_value);
1133 bool NeedsStackValue = NeedsDeref || ExprOpsBeforeFragment.empty();
1134
1135 // Append a DW_OP_deref after Expr's current op list if needed, then append
1136 // the new ops, and finally ensure that a single DW_OP_stack_value is present.
1137 SmallVector<uint64_t, 16> NewOps;
1138 if (NeedsDeref)
1139 NewOps.push_back(dwarf::DW_OP_deref);
1140 NewOps.append(Ops.begin(), Ops.end());
1141 if (NeedsStackValue)
1142 NewOps.push_back(dwarf::DW_OP_stack_value);
1143 return DIExpression::append(Expr, NewOps);
1144}
1145
1146Optional<DIExpression *> DIExpression::createFragmentExpression(
1147 const DIExpression *Expr, unsigned OffsetInBits, unsigned SizeInBits) {
1148 SmallVector<uint64_t, 8> Ops;
1149 // Copy over the expression, but leave off any trailing DW_OP_LLVM_fragment.
1150 if (Expr) {
1151 for (auto Op : Expr->expr_ops()) {
1152 switch (Op.getOp()) {
1153 default: break;
1154 case dwarf::DW_OP_shr:
1155 case dwarf::DW_OP_shra:
1156 case dwarf::DW_OP_shl:
1157 case dwarf::DW_OP_plus:
1158 case dwarf::DW_OP_plus_uconst:
1159 case dwarf::DW_OP_minus:
1160 // We can't safely split arithmetic or shift operations into multiple
1161 // fragments because we can't express carry-over between fragments.
1162 //
1163 // FIXME: We *could* preserve the lowest fragment of a constant offset
1164 // operation if the offset fits into SizeInBits.
1165 return None;
1166 case dwarf::DW_OP_LLVM_fragment: {
1167 // Make the new offset point into the existing fragment.
1168 uint64_t FragmentOffsetInBits = Op.getArg(0);
1169 uint64_t FragmentSizeInBits = Op.getArg(1);
1170 (void)FragmentSizeInBits;
1171 assert((OffsetInBits + SizeInBits <= FragmentSizeInBits) &&(((OffsetInBits + SizeInBits <= FragmentSizeInBits) &&
"new fragment outside of original fragment") ? static_cast<
void> (0) : __assert_fail ("(OffsetInBits + SizeInBits <= FragmentSizeInBits) && \"new fragment outside of original fragment\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1172, __PRETTY_FUNCTION__))
1172 "new fragment outside of original fragment")(((OffsetInBits + SizeInBits <= FragmentSizeInBits) &&
"new fragment outside of original fragment") ? static_cast<
void> (0) : __assert_fail ("(OffsetInBits + SizeInBits <= FragmentSizeInBits) && \"new fragment outside of original fragment\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1172, __PRETTY_FUNCTION__))
;
1173 OffsetInBits += FragmentOffsetInBits;
1174 continue;
1175 }
1176 }
1177 Op.appendToVector(Ops);
1178 }
1179 }
1180 assert(Expr && "Unknown DIExpression")((Expr && "Unknown DIExpression") ? static_cast<void
> (0) : __assert_fail ("Expr && \"Unknown DIExpression\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1180, __PRETTY_FUNCTION__))
;
1181 Ops.push_back(dwarf::DW_OP_LLVM_fragment);
1182 Ops.push_back(OffsetInBits);
1183 Ops.push_back(SizeInBits);
1184 return DIExpression::get(Expr->getContext(), Ops);
1185}
1186
1187bool DIExpression::isConstant() const {
1188 // Recognize DW_OP_constu C DW_OP_stack_value (DW_OP_LLVM_fragment Len Ofs)?.
1189 if (getNumElements() != 3 && getNumElements() != 6)
1190 return false;
1191 if (getElement(0) != dwarf::DW_OP_constu ||
1192 getElement(2) != dwarf::DW_OP_stack_value)
1193 return false;
1194 if (getNumElements() == 6 && getElement(3) != dwarf::DW_OP_LLVM_fragment)
1195 return false;
1196 return true;
1197}
1198
1199DIExpression::ExtOps DIExpression::getExtOps(unsigned FromSize, unsigned ToSize,
1200 bool Signed) {
1201 dwarf::TypeKind TK = Signed ? dwarf::DW_ATE_signed : dwarf::DW_ATE_unsigned;
1202 DIExpression::ExtOps Ops{{dwarf::DW_OP_LLVM_convert, FromSize, TK,
1203 dwarf::DW_OP_LLVM_convert, ToSize, TK}};
1204 return Ops;
1205}
1206
1207DIExpression *DIExpression::appendExt(const DIExpression *Expr,
1208 unsigned FromSize, unsigned ToSize,
1209 bool Signed) {
1210 return appendToStack(Expr, getExtOps(FromSize, ToSize, Signed));
1211}
1212
1213DIGlobalVariableExpression *
1214DIGlobalVariableExpression::getImpl(LLVMContext &Context, Metadata *Variable,
1215 Metadata *Expression, StorageType Storage,
1216 bool ShouldCreate) {
1217 DEFINE_GETIMPL_LOOKUP(DIGlobalVariableExpression, (Variable, Expression))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIGlobalVariableExpressions, DIGlobalVariableExpressionInfo
::KeyTy(Variable, Expression))) return N; if (!ShouldCreate) return
nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1217, __PRETTY_FUNCTION__)); } } while (false)
;
1218 Metadata *Ops[] = {Variable, Expression};
1219 DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIGlobalVariableExpression, Ops)return storeImpl(new (array_lengthof(Ops)) DIGlobalVariableExpression
(Context, Storage, Ops), Storage, Context.pImpl->DIGlobalVariableExpressions
)
;
1220}
1221
1222DIObjCProperty *DIObjCProperty::getImpl(
1223 LLVMContext &Context, MDString *Name, Metadata *File, unsigned Line,
1224 MDString *GetterName, MDString *SetterName, unsigned Attributes,
1225 Metadata *Type, StorageType Storage, bool ShouldCreate) {
1226 assert(isCanonical(Name) && "Expected canonical MDString")((isCanonical(Name) && "Expected canonical MDString")
? static_cast<void> (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1226, __PRETTY_FUNCTION__))
;
1227 assert(isCanonical(GetterName) && "Expected canonical MDString")((isCanonical(GetterName) && "Expected canonical MDString"
) ? static_cast<void> (0) : __assert_fail ("isCanonical(GetterName) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1227, __PRETTY_FUNCTION__))
;
1228 assert(isCanonical(SetterName) && "Expected canonical MDString")((isCanonical(SetterName) && "Expected canonical MDString"
) ? static_cast<void> (0) : __assert_fail ("isCanonical(SetterName) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1228, __PRETTY_FUNCTION__))
;
1229 DEFINE_GETIMPL_LOOKUP(DIObjCProperty, (Name, File, Line, GetterName,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIObjCPropertys, DIObjCPropertyInfo::KeyTy(Name, File
, Line, GetterName, SetterName, Attributes, Type))) return N;
if (!ShouldCreate) return nullptr; } else { ((ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? static_cast
<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1230, __PRETTY_FUNCTION__)); } } while (false)
1230 SetterName, Attributes, Type))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIObjCPropertys, DIObjCPropertyInfo::KeyTy(Name, File
, Line, GetterName, SetterName, Attributes, Type))) return N;
if (!ShouldCreate) return nullptr; } else { ((ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? static_cast
<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1230, __PRETTY_FUNCTION__)); } } while (false)
;
1231 Metadata *Ops[] = {Name, File, GetterName, SetterName, Type};
1232 DEFINE_GETIMPL_STORE(DIObjCProperty, (Line, Attributes), Ops)return storeImpl(new (array_lengthof(Ops)) DIObjCProperty(Context
, Storage, Line, Attributes, Ops), Storage, Context.pImpl->
DIObjCPropertys)
;
1233}
1234
1235DIImportedEntity *DIImportedEntity::getImpl(LLVMContext &Context, unsigned Tag,
1236 Metadata *Scope, Metadata *Entity,
1237 Metadata *File, unsigned Line,
1238 MDString *Name, StorageType Storage,
1239 bool ShouldCreate) {
1240 assert(isCanonical(Name) && "Expected canonical MDString")((isCanonical(Name) && "Expected canonical MDString")
? static_cast<void> (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1240, __PRETTY_FUNCTION__))
;
1241 DEFINE_GETIMPL_LOOKUP(DIImportedEntity,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIImportedEntitys, DIImportedEntityInfo::KeyTy(Tag
, Scope, Entity, File, Line, Name))) return N; if (!ShouldCreate
) return nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1242, __PRETTY_FUNCTION__)); } } while (false)
1242 (Tag, Scope, Entity, File, Line, Name))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIImportedEntitys, DIImportedEntityInfo::KeyTy(Tag
, Scope, Entity, File, Line, Name))) return N; if (!ShouldCreate
) return nullptr; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1242, __PRETTY_FUNCTION__)); } } while (false)
;
1243 Metadata *Ops[] = {Scope, Entity, Name, File};
1244 DEFINE_GETIMPL_STORE(DIImportedEntity, (Tag, Line), Ops)return storeImpl(new (array_lengthof(Ops)) DIImportedEntity(Context
, Storage, Tag, Line, Ops), Storage, Context.pImpl->DIImportedEntitys
)
;
1245}
1246
1247DIMacro *DIMacro::getImpl(LLVMContext &Context, unsigned MIType,
1248 unsigned Line, MDString *Name, MDString *Value,
1249 StorageType Storage, bool ShouldCreate) {
1250 assert(isCanonical(Name) && "Expected canonical MDString")((isCanonical(Name) && "Expected canonical MDString")
? static_cast<void> (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1250, __PRETTY_FUNCTION__))
;
1251 DEFINE_GETIMPL_LOOKUP(DIMacro, (MIType, Line, Name, Value))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIMacros, DIMacroInfo::KeyTy(MIType, Line, Name, Value
))) return N; if (!ShouldCreate) return nullptr; } else { ((ShouldCreate
&& "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1251, __PRETTY_FUNCTION__)); } } while (false)
;
1252 Metadata *Ops[] = { Name, Value };
1253 DEFINE_GETIMPL_STORE(DIMacro, (MIType, Line), Ops)return storeImpl(new (array_lengthof(Ops)) DIMacro(Context, Storage
, MIType, Line, Ops), Storage, Context.pImpl->DIMacros)
;
1254}
1255
1256DIMacroFile *DIMacroFile::getImpl(LLVMContext &Context, unsigned MIType,
1257 unsigned Line, Metadata *File,
1258 Metadata *Elements, StorageType Storage,
1259 bool ShouldCreate) {
1260 DEFINE_GETIMPL_LOOKUP(DIMacroFile,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIMacroFiles, DIMacroFileInfo::KeyTy(MIType, Line,
File, Elements))) return N; if (!ShouldCreate) return nullptr
; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1261, __PRETTY_FUNCTION__)); } } while (false)
1261 (MIType, Line, File, Elements))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIMacroFiles, DIMacroFileInfo::KeyTy(MIType, Line,
File, Elements))) return N; if (!ShouldCreate) return nullptr
; } else { ((ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? static_cast<void> (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/lib/IR/DebugInfoMetadata.cpp"
, 1261, __PRETTY_FUNCTION__)); } } while (false)
;
1262 Metadata *Ops[] = { File, Elements };
1263 DEFINE_GETIMPL_STORE(DIMacroFile, (MIType, Line), Ops)return storeImpl(new (array_lengthof(Ops)) DIMacroFile(Context
, Storage, MIType, Line, Ops), Storage, Context.pImpl->DIMacroFiles
)
;
1264}

/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include/llvm/IR/DebugInfoMetadata.h

1//===- llvm/IR/DebugInfoMetadata.h - Debug info metadata --------*- C++ -*-===//
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// Declarations for metadata specific to debug info.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_IR_DEBUGINFOMETADATA_H
14#define LLVM_IR_DEBUGINFOMETADATA_H
15
16#include "llvm/ADT/ArrayRef.h"
17#include "llvm/ADT/BitmaskEnum.h"
18#include "llvm/ADT/None.h"
19#include "llvm/ADT/Optional.h"
20#include "llvm/ADT/PointerUnion.h"
21#include "llvm/ADT/STLExtras.h"
22#include "llvm/ADT/SmallVector.h"
23#include "llvm/ADT/StringRef.h"
24#include "llvm/ADT/iterator_range.h"
25#include "llvm/BinaryFormat/Dwarf.h"
26#include "llvm/IR/Constants.h"
27#include "llvm/IR/Metadata.h"
28#include "llvm/Support/Casting.h"
29#include <cassert>
30#include <climits>
31#include <cstddef>
32#include <cstdint>
33#include <iterator>
34#include <type_traits>
35#include <vector>
36
37// Helper macros for defining get() overrides.
38#define DEFINE_MDNODE_GET_UNPACK_IMPL(...) __VA_ARGS__
39#define DEFINE_MDNODE_GET_UNPACK(ARGS) DEFINE_MDNODE_GET_UNPACK_IMPL ARGS
40#define DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(CLASS, FORMAL, ARGS)static CLASS *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
(FORMAL)) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(
ARGS), Distinct); } static TempCLASS getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK(FORMAL)) { return TempCLASS
( getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Temporary)
); }
\
41 static CLASS *getDistinct(LLVMContext &Context, \
42 DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \
43 return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Distinct); \
44 } \
45 static Temp##CLASS getTemporary(LLVMContext &Context, \
46 DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \
47 return Temp##CLASS( \
48 getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Temporary)); \
49 }
50#define DEFINE_MDNODE_GET(CLASS, FORMAL, ARGS) \
51 static CLASS *get(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \
52 return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Uniqued); \
53 } \
54 static CLASS *getIfExists(LLVMContext &Context, \
55 DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \
56 return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Uniqued, \
57 /* ShouldCreate */ false); \
58 } \
59 DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(CLASS, FORMAL, ARGS)static CLASS *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
(FORMAL)) { return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(
ARGS), Distinct); } static TempCLASS getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK(FORMAL)) { return TempCLASS
( getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Temporary)
); }
60
61namespace llvm {
62
63class DITypeRefArray {
64 const MDTuple *N = nullptr;
65
66public:
67 DITypeRefArray() = default;
68 DITypeRefArray(const MDTuple *N) : N(N) {}
69
70 explicit operator bool() const { return get(); }
71 explicit operator MDTuple *() const { return get(); }
72
73 MDTuple *get() const { return const_cast<MDTuple *>(N); }
74 MDTuple *operator->() const { return get(); }
75 MDTuple &operator*() const { return *get(); }
76
77 // FIXME: Fix callers and remove condition on N.
78 unsigned size() const { return N ? N->getNumOperands() : 0u; }
79 DIType *operator[](unsigned I) const {
80 return cast_or_null<DIType>(N->getOperand(I));
81 }
82
83 class iterator : std::iterator<std::input_iterator_tag, DIType *,
84 std::ptrdiff_t, void, DIType *> {
85 MDNode::op_iterator I = nullptr;
86
87 public:
88 iterator() = default;
89 explicit iterator(MDNode::op_iterator I) : I(I) {}
90
91 DIType *operator*() const { return cast_or_null<DIType>(*I); }
92
93 iterator &operator++() {
94 ++I;
95 return *this;
96 }
97
98 iterator operator++(int) {
99 iterator Temp(*this);
100 ++I;
101 return Temp;
102 }
103
104 bool operator==(const iterator &X) const { return I == X.I; }
105 bool operator!=(const iterator &X) const { return I != X.I; }
106 };
107
108 // FIXME: Fix callers and remove condition on N.
109 iterator begin() const { return N ? iterator(N->op_begin()) : iterator(); }
110 iterator end() const { return N ? iterator(N->op_end()) : iterator(); }
111};
112
113/// Tagged DWARF-like metadata node.
114///
115/// A metadata node with a DWARF tag (i.e., a constant named \c DW_TAG_*,
116/// defined in llvm/BinaryFormat/Dwarf.h). Called \a DINode because it's
117/// potentially used for non-DWARF output.
118class DINode : public MDNode {
119 friend class LLVMContextImpl;
120 friend class MDNode;
121
122protected:
123 DINode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
124 ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None)
125 : MDNode(C, ID, Storage, Ops1, Ops2) {
126 assert(Tag < 1u << 16)((Tag < 1u << 16) ? static_cast<void> (0) : __assert_fail
("Tag < 1u << 16", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include/llvm/IR/DebugInfoMetadata.h"
, 126, __PRETTY_FUNCTION__))
;
127 SubclassData16 = Tag;
128 }
129 ~DINode() = default;
130
131 template <class Ty> Ty *getOperandAs(unsigned I) const {
132 return cast_or_null<Ty>(getOperand(I));
133 }
134
135 StringRef getStringOperand(unsigned I) const {
136 if (auto *S = getOperandAs<MDString>(I))
137 return S->getString();
138 return StringRef();
139 }
140
141 static MDString *getCanonicalMDString(LLVMContext &Context, StringRef S) {
142 if (S.empty())
143 return nullptr;
144 return MDString::get(Context, S);
145 }
146
147 /// Allow subclasses to mutate the tag.
148 void setTag(unsigned Tag) { SubclassData16 = Tag; }
149
150public:
151 unsigned getTag() const { return SubclassData16; }
152
153 /// Debug info flags.
154 ///
155 /// The three accessibility flags are mutually exclusive and rolled together
156 /// in the first two bits.
157 enum DIFlags : uint32_t {
158#define HANDLE_DI_FLAG(ID, NAME) Flag##NAME = ID,
159#define DI_FLAG_LARGEST_NEEDED
160#include "llvm/IR/DebugInfoFlags.def"
161 FlagAccessibility = FlagPrivate | FlagProtected | FlagPublic,
162 FlagPtrToMemberRep = FlagSingleInheritance | FlagMultipleInheritance |
163 FlagVirtualInheritance,
164 LLVM_MARK_AS_BITMASK_ENUM(FlagLargest)LLVM_BITMASK_LARGEST_ENUMERATOR = FlagLargest
165 };
166
167 static DIFlags getFlag(StringRef Flag);
168 static StringRef getFlagString(DIFlags Flag);
169
170 /// Split up a flags bitfield.
171 ///
172 /// Split \c Flags into \c SplitFlags, a vector of its components. Returns
173 /// any remaining (unrecognized) bits.
174 static DIFlags splitFlags(DIFlags Flags,
175 SmallVectorImpl<DIFlags> &SplitFlags);
176
177 static bool classof(const Metadata *MD) {
178 switch (MD->getMetadataID()) {
179 default:
180 return false;
181 case GenericDINodeKind:
182 case DISubrangeKind:
183 case DIEnumeratorKind:
184 case DIBasicTypeKind:
185 case DIDerivedTypeKind:
186 case DICompositeTypeKind:
187 case DISubroutineTypeKind:
188 case DIFileKind:
189 case DICompileUnitKind:
190 case DISubprogramKind:
191 case DILexicalBlockKind:
192 case DILexicalBlockFileKind:
193 case DINamespaceKind:
194 case DICommonBlockKind:
195 case DITemplateTypeParameterKind:
196 case DITemplateValueParameterKind:
197 case DIGlobalVariableKind:
198 case DILocalVariableKind:
199 case DILabelKind:
200 case DIObjCPropertyKind:
201 case DIImportedEntityKind:
202 case DIModuleKind:
203 return true;
204 }
205 }
206};
207
208/// Generic tagged DWARF-like metadata node.
209///
210/// An un-specialized DWARF-like metadata node. The first operand is a
211/// (possibly empty) null-separated \a MDString header that contains arbitrary
212/// fields. The remaining operands are \a dwarf_operands(), and are pointers
213/// to other metadata.
214class GenericDINode : public DINode {
215 friend class LLVMContextImpl;
216 friend class MDNode;
217
218 GenericDINode(LLVMContext &C, StorageType Storage, unsigned Hash,
219 unsigned Tag, ArrayRef<Metadata *> Ops1,
220 ArrayRef<Metadata *> Ops2)
221 : DINode(C, GenericDINodeKind, Storage, Tag, Ops1, Ops2) {
222 setHash(Hash);
223 }
224 ~GenericDINode() { dropAllReferences(); }
225
226 void setHash(unsigned Hash) { SubclassData32 = Hash; }
227 void recalculateHash();
228
229 static GenericDINode *getImpl(LLVMContext &Context, unsigned Tag,
230 StringRef Header, ArrayRef<Metadata *> DwarfOps,
231 StorageType Storage, bool ShouldCreate = true) {
232 return getImpl(Context, Tag, getCanonicalMDString(Context, Header),
233 DwarfOps, Storage, ShouldCreate);
234 }
235
236 static GenericDINode *getImpl(LLVMContext &Context, unsigned Tag,
237 MDString *Header, ArrayRef<Metadata *> DwarfOps,
238 StorageType Storage, bool ShouldCreate = true);
239
240 TempGenericDINode cloneImpl() const {
241 return getTemporary(
242 getContext(), getTag(), getHeader(),
243 SmallVector<Metadata *, 4>(dwarf_op_begin(), dwarf_op_end()));
244 }
245
246public:
247 unsigned getHash() const { return SubclassData32; }
248
249 DEFINE_MDNODE_GET(GenericDINode, (unsigned Tag, StringRef Header,
250 ArrayRef<Metadata *> DwarfOps),
251 (Tag, Header, DwarfOps))
252 DEFINE_MDNODE_GET(GenericDINode, (unsigned Tag, MDString *Header,
253 ArrayRef<Metadata *> DwarfOps),
254 (Tag, Header, DwarfOps))
255
256 /// Return a (temporary) clone of this.
257 TempGenericDINode clone() const { return cloneImpl(); }
258
259 unsigned getTag() const { return SubclassData16; }
260 StringRef getHeader() const { return getStringOperand(0); }
261 MDString *getRawHeader() const { return getOperandAs<MDString>(0); }
262
263 op_iterator dwarf_op_begin() const { return op_begin() + 1; }
264 op_iterator dwarf_op_end() const { return op_end(); }
265 op_range dwarf_operands() const {
266 return op_range(dwarf_op_begin(), dwarf_op_end());
267 }
268
269 unsigned getNumDwarfOperands() const { return getNumOperands() - 1; }
270 const MDOperand &getDwarfOperand(unsigned I) const {
271 return getOperand(I + 1);
272 }
273 void replaceDwarfOperandWith(unsigned I, Metadata *New) {
274 replaceOperandWith(I + 1, New);
275 }
276
277 static bool classof(const Metadata *MD) {
278 return MD->getMetadataID() == GenericDINodeKind;
279 }
280};
281
282/// Array subrange.
283///
284/// TODO: Merge into node for DW_TAG_array_type, which should have a custom
285/// type.
286class DISubrange : public DINode {
287 friend class LLVMContextImpl;
288 friend class MDNode;
289
290 int64_t LowerBound;
291
292 DISubrange(LLVMContext &C, StorageType Storage, Metadata *Node,
293 int64_t LowerBound, ArrayRef<Metadata *> Ops)
294 : DINode(C, DISubrangeKind, Storage, dwarf::DW_TAG_subrange_type, Ops),
295 LowerBound(LowerBound) {}
296
297 ~DISubrange() = default;
298
299 static DISubrange *getImpl(LLVMContext &Context, int64_t Count,
300 int64_t LowerBound, StorageType Storage,
301 bool ShouldCreate = true);
302
303 static DISubrange *getImpl(LLVMContext &Context, Metadata *CountNode,
304 int64_t LowerBound, StorageType Storage,
305 bool ShouldCreate = true);
306
307 TempDISubrange cloneImpl() const {
308 return getTemporary(getContext(), getRawCountNode(), getLowerBound());
309 }
310
311public:
312 DEFINE_MDNODE_GET(DISubrange, (int64_t Count, int64_t LowerBound = 0),
313 (Count, LowerBound))
314
315 DEFINE_MDNODE_GET(DISubrange, (Metadata *CountNode, int64_t LowerBound = 0),
316 (CountNode, LowerBound))
317
318 TempDISubrange clone() const { return cloneImpl(); }
319
320 int64_t getLowerBound() const { return LowerBound; }
321
322 Metadata *getRawCountNode() const {
323 return getOperand(0).get();
324 }
325
326 typedef PointerUnion<ConstantInt*, DIVariable*> CountType;
327
328 CountType getCount() const {
329 if (auto *MD = dyn_cast<ConstantAsMetadata>(getRawCountNode()))
330 return CountType(cast<ConstantInt>(MD->getValue()));
331
332 if (auto *DV = dyn_cast<DIVariable>(getRawCountNode()))
333 return CountType(DV);
334
335 return CountType();
336 }
337
338 static bool classof(const Metadata *MD) {
339 return MD->getMetadataID() == DISubrangeKind;
340 }
341};
342
343/// Enumeration value.
344///
345/// TODO: Add a pointer to the context (DW_TAG_enumeration_type) once that no
346/// longer creates a type cycle.
347class DIEnumerator : public DINode {
348 friend class LLVMContextImpl;
349 friend class MDNode;
350
351 int64_t Value;
352 DIEnumerator(LLVMContext &C, StorageType Storage, int64_t Value,
353 bool IsUnsigned, ArrayRef<Metadata *> Ops)
354 : DINode(C, DIEnumeratorKind, Storage, dwarf::DW_TAG_enumerator, Ops),
355 Value(Value) {
356 SubclassData32 = IsUnsigned;
357 }
358 ~DIEnumerator() = default;
359
360 static DIEnumerator *getImpl(LLVMContext &Context, int64_t Value,
361 bool IsUnsigned, StringRef Name,
362 StorageType Storage, bool ShouldCreate = true) {
363 return getImpl(Context, Value, IsUnsigned,
364 getCanonicalMDString(Context, Name), Storage, ShouldCreate);
365 }
366 static DIEnumerator *getImpl(LLVMContext &Context, int64_t Value,
367 bool IsUnsigned, MDString *Name,
368 StorageType Storage, bool ShouldCreate = true);
369
370 TempDIEnumerator cloneImpl() const {
371 return getTemporary(getContext(), getValue(), isUnsigned(), getName());
372 }
373
374public:
375 DEFINE_MDNODE_GET(DIEnumerator, (int64_t Value, bool IsUnsigned, StringRef Name),
376 (Value, IsUnsigned, Name))
377 DEFINE_MDNODE_GET(DIEnumerator, (int64_t Value, bool IsUnsigned, MDString *Name),
378 (Value, IsUnsigned, Name))
379
380 TempDIEnumerator clone() const { return cloneImpl(); }
381
382 int64_t getValue() const { return Value; }
383 bool isUnsigned() const { return SubclassData32; }
384 StringRef getName() const { return getStringOperand(0); }
385
386 MDString *getRawName() const { return getOperandAs<MDString>(0); }
387
388 static bool classof(const Metadata *MD) {
389 return MD->getMetadataID() == DIEnumeratorKind;
390 }
391};
392
393/// Base class for scope-like contexts.
394///
395/// Base class for lexical scopes and types (which are also declaration
396/// contexts).
397///
398/// TODO: Separate the concepts of declaration contexts and lexical scopes.
399class DIScope : public DINode {
400protected:
401 DIScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
402 ArrayRef<Metadata *> Ops)
403 : DINode(C, ID, Storage, Tag, Ops) {}
404 ~DIScope() = default;
405
406public:
407 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
408
409 inline StringRef getFilename() const;
410 inline StringRef getDirectory() const;
411 inline Optional<StringRef> getSource() const;
412
413 StringRef getName() const;
414 DIScope *getScope() const;
415
416 /// Return the raw underlying file.
417 ///
418 /// A \a DIFile is a \a DIScope, but it doesn't point at a separate file (it
419 /// \em is the file). If \c this is an \a DIFile, we need to return \c this.
420 /// Otherwise, return the first operand, which is where all other subclasses
421 /// store their file pointer.
422 Metadata *getRawFile() const {
423 return isa<DIFile>(this) ? const_cast<DIScope *>(this)
424 : static_cast<Metadata *>(getOperand(0));
425 }
426
427 static bool classof(const Metadata *MD) {
428 switch (MD->getMetadataID()) {
429 default:
430 return false;
431 case DIBasicTypeKind:
432 case DIDerivedTypeKind:
433 case DICompositeTypeKind:
434 case DISubroutineTypeKind:
435 case DIFileKind:
436 case DICompileUnitKind:
437 case DISubprogramKind:
438 case DILexicalBlockKind:
439 case DILexicalBlockFileKind:
440 case DINamespaceKind:
441 case DICommonBlockKind:
442 case DIModuleKind:
443 return true;
444 }
445 }
446};
447
448/// File.
449///
450/// TODO: Merge with directory/file node (including users).
451/// TODO: Canonicalize paths on creation.
452class DIFile : public DIScope {
453 friend class LLVMContextImpl;
454 friend class MDNode;
455
456public:
457 /// Which algorithm (e.g. MD5) a checksum was generated with.
458 ///
459 /// The encoding is explicit because it is used directly in Bitcode. The
460 /// value 0 is reserved to indicate the absence of a checksum in Bitcode.
461 enum ChecksumKind {
462 // The first variant was originally CSK_None, encoded as 0. The new
463 // internal representation removes the need for this by wrapping the
464 // ChecksumInfo in an Optional, but to preserve Bitcode compatibility the 0
465 // encoding is reserved.
466 CSK_MD5 = 1,
467 CSK_SHA1 = 2,
468 CSK_Last = CSK_SHA1 // Should be last enumeration.
469 };
470
471 /// A single checksum, represented by a \a Kind and a \a Value (a string).
472 template <typename T>
473 struct ChecksumInfo {
474 /// The kind of checksum which \a Value encodes.
475 ChecksumKind Kind;
476 /// The string value of the checksum.
477 T Value;
478
479 ChecksumInfo(ChecksumKind Kind, T Value) : Kind(Kind), Value(Value) { }
480 ~ChecksumInfo() = default;
481 bool operator==(const ChecksumInfo<T> &X) const {
482 return Kind == X.Kind && Value == X.Value;
483 }
484 bool operator!=(const ChecksumInfo<T> &X) const { return !(*this == X); }
485 StringRef getKindAsString() const { return getChecksumKindAsString(Kind); }
486 };
487
488private:
489 Optional<ChecksumInfo<MDString *>> Checksum;
490 Optional<MDString *> Source;
491
492 DIFile(LLVMContext &C, StorageType Storage,
493 Optional<ChecksumInfo<MDString *>> CS, Optional<MDString *> Src,
494 ArrayRef<Metadata *> Ops)
495 : DIScope(C, DIFileKind, Storage, dwarf::DW_TAG_file_type, Ops),
496 Checksum(CS), Source(Src) {}
497 ~DIFile() = default;
498
499 static DIFile *getImpl(LLVMContext &Context, StringRef Filename,
500 StringRef Directory,
501 Optional<ChecksumInfo<StringRef>> CS,
502 Optional<StringRef> Source,
503 StorageType Storage, bool ShouldCreate = true) {
504 Optional<ChecksumInfo<MDString *>> MDChecksum;
505 if (CS)
506 MDChecksum.emplace(CS->Kind, getCanonicalMDString(Context, CS->Value));
507 return getImpl(Context, getCanonicalMDString(Context, Filename),
508 getCanonicalMDString(Context, Directory), MDChecksum,
509 Source ? Optional<MDString *>(getCanonicalMDString(Context, *Source)) : None,
510 Storage, ShouldCreate);
511 }
512 static DIFile *getImpl(LLVMContext &Context, MDString *Filename,
513 MDString *Directory,
514 Optional<ChecksumInfo<MDString *>> CS,
515 Optional<MDString *> Source, StorageType Storage,
516 bool ShouldCreate = true);
517
518 TempDIFile cloneImpl() const {
519 return getTemporary(getContext(), getFilename(), getDirectory(),
520 getChecksum(), getSource());
521 }
522
523public:
524 DEFINE_MDNODE_GET(DIFile, (StringRef Filename, StringRef Directory,
525 Optional<ChecksumInfo<StringRef>> CS = None,
526 Optional<StringRef> Source = None),
527 (Filename, Directory, CS, Source))
528 DEFINE_MDNODE_GET(DIFile, (MDString * Filename, MDString *Directory,
529 Optional<ChecksumInfo<MDString *>> CS = None,
530 Optional<MDString *> Source = None),
531 (Filename, Directory, CS, Source))
532
533 TempDIFile clone() const { return cloneImpl(); }
534
535 StringRef getFilename() const { return getStringOperand(0); }
536 StringRef getDirectory() const { return getStringOperand(1); }
537 Optional<ChecksumInfo<StringRef>> getChecksum() const {
538 Optional<ChecksumInfo<StringRef>> StringRefChecksum;
539 if (Checksum)
540 StringRefChecksum.emplace(Checksum->Kind, Checksum->Value->getString());
541 return StringRefChecksum;
542 }
543 Optional<StringRef> getSource() const {
544 return Source ? Optional<StringRef>((*Source)->getString()) : None;
545 }
546
547 MDString *getRawFilename() const { return getOperandAs<MDString>(0); }
548 MDString *getRawDirectory() const { return getOperandAs<MDString>(1); }
549 Optional<ChecksumInfo<MDString *>> getRawChecksum() const { return Checksum; }
550 Optional<MDString *> getRawSource() const { return Source; }
551
552 static StringRef getChecksumKindAsString(ChecksumKind CSKind);
553 static Optional<ChecksumKind> getChecksumKind(StringRef CSKindStr);
554
555 static bool classof(const Metadata *MD) {
556 return MD->getMetadataID() == DIFileKind;
557 }
558};
559
560StringRef DIScope::getFilename() const {
561 if (auto *F = getFile())
562 return F->getFilename();
563 return "";
564}
565
566StringRef DIScope::getDirectory() const {
567 if (auto *F = getFile())
568 return F->getDirectory();
569 return "";
570}
571
572Optional<StringRef> DIScope::getSource() const {
573 if (auto *F = getFile())
574 return F->getSource();
575 return None;
576}
577
578/// Base class for types.
579///
580/// TODO: Remove the hardcoded name and context, since many types don't use
581/// them.
582/// TODO: Split up flags.
583class DIType : public DIScope {
584 unsigned Line;
585 DIFlags Flags;
586 uint64_t SizeInBits;
587 uint64_t OffsetInBits;
588 uint32_t AlignInBits;
589
590protected:
591 DIType(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
592 unsigned Line, uint64_t SizeInBits, uint32_t AlignInBits,
593 uint64_t OffsetInBits, DIFlags Flags, ArrayRef<Metadata *> Ops)
594 : DIScope(C, ID, Storage, Tag, Ops) {
595 init(Line, SizeInBits, AlignInBits, OffsetInBits, Flags);
596 }
597 ~DIType() = default;
598
599 void init(unsigned Line, uint64_t SizeInBits, uint32_t AlignInBits,
600 uint64_t OffsetInBits, DIFlags Flags) {
601 this->Line = Line;
602 this->Flags = Flags;
603 this->SizeInBits = SizeInBits;
604 this->AlignInBits = AlignInBits;
605 this->OffsetInBits = OffsetInBits;
606 }
607
608 /// Change fields in place.
609 void mutate(unsigned Tag, unsigned Line, uint64_t SizeInBits,
610 uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags) {
611 assert(isDistinct() && "Only distinct nodes can mutate")((isDistinct() && "Only distinct nodes can mutate") ?
static_cast<void> (0) : __assert_fail ("isDistinct() && \"Only distinct nodes can mutate\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include/llvm/IR/DebugInfoMetadata.h"
, 611, __PRETTY_FUNCTION__))
;
612 setTag(Tag);
613 init(Line, SizeInBits, AlignInBits, OffsetInBits, Flags);
614 }
615
616public:
617 TempDIType clone() const {
618 return TempDIType(cast<DIType>(MDNode::clone().release()));
619 }
620
621 unsigned getLine() const { return Line; }
622 uint64_t getSizeInBits() const { return SizeInBits; }
623 uint32_t getAlignInBits() const { return AlignInBits; }
624 uint32_t getAlignInBytes() const { return getAlignInBits() / CHAR_BIT8; }
625 uint64_t getOffsetInBits() const { return OffsetInBits; }
626 DIFlags getFlags() const { return Flags; }
627
628 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
629 StringRef getName() const { return getStringOperand(2); }
630
631
632 Metadata *getRawScope() const { return getOperand(1); }
633 MDString *getRawName() const { return getOperandAs<MDString>(2); }
634
635 /// Returns a new temporary DIType with updated Flags
636 TempDIType cloneWithFlags(DIFlags NewFlags) const {
637 auto NewTy = clone();
638 NewTy->Flags = NewFlags;
639 return NewTy;
640 }
641
642 bool isPrivate() const {
643 return (getFlags() & FlagAccessibility) == FlagPrivate;
644 }
645 bool isProtected() const {
646 return (getFlags() & FlagAccessibility) == FlagProtected;
647 }
648 bool isPublic() const {
649 return (getFlags() & FlagAccessibility) == FlagPublic;
650 }
651 bool isForwardDecl() const { return getFlags() & FlagFwdDecl; }
652 bool isAppleBlockExtension() const { return getFlags() & FlagAppleBlock; }
653 bool isVirtual() const { return getFlags() & FlagVirtual; }
654 bool isArtificial() const { return getFlags() & FlagArtificial; }
655 bool isObjectPointer() const { return getFlags() & FlagObjectPointer; }
656 bool isObjcClassComplete() const {
657 return getFlags() & FlagObjcClassComplete;
658 }
659 bool isVector() const { return getFlags() & FlagVector; }
660 bool isBitField() const { return getFlags() & FlagBitField; }
661 bool isStaticMember() const { return getFlags() & FlagStaticMember; }
662 bool isLValueReference() const { return getFlags() & FlagLValueReference; }
663 bool isRValueReference() const { return getFlags() & FlagRValueReference; }
664 bool isTypePassByValue() const { return getFlags() & FlagTypePassByValue; }
665 bool isTypePassByReference() const {
666 return getFlags() & FlagTypePassByReference;
667 }
668 bool isBigEndian() const { return getFlags() & FlagBigEndian; }
669 bool isLittleEndian() const { return getFlags() & FlagLittleEndian; }
670 bool getExportSymbols() const { return getFlags() & FlagExportSymbols; }
671
672 static bool classof(const Metadata *MD) {
673 switch (MD->getMetadataID()) {
674 default:
675 return false;
676 case DIBasicTypeKind:
677 case DIDerivedTypeKind:
678 case DICompositeTypeKind:
679 case DISubroutineTypeKind:
680 return true;
681 }
682 }
683};
684
685/// Basic type, like 'int' or 'float'.
686///
687/// TODO: Split out DW_TAG_unspecified_type.
688/// TODO: Drop unused accessors.
689class DIBasicType : public DIType {
690 friend class LLVMContextImpl;
691 friend class MDNode;
692
693 unsigned Encoding;
694
695 DIBasicType(LLVMContext &C, StorageType Storage, unsigned Tag,
696 uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding,
697 DIFlags Flags, ArrayRef<Metadata *> Ops)
698 : DIType(C, DIBasicTypeKind, Storage, Tag, 0, SizeInBits, AlignInBits, 0,
699 Flags, Ops),
700 Encoding(Encoding) {}
701 ~DIBasicType() = default;
702
703 static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
704 StringRef Name, uint64_t SizeInBits,
705 uint32_t AlignInBits, unsigned Encoding,
706 DIFlags Flags, StorageType Storage,
707 bool ShouldCreate = true) {
708 return getImpl(Context, Tag, getCanonicalMDString(Context, Name),
709 SizeInBits, AlignInBits, Encoding, Flags, Storage,
710 ShouldCreate);
711 }
712 static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
713 MDString *Name, uint64_t SizeInBits,
714 uint32_t AlignInBits, unsigned Encoding,
715 DIFlags Flags, StorageType Storage,
716 bool ShouldCreate = true);
717
718 TempDIBasicType cloneImpl() const {
719 return getTemporary(getContext(), getTag(), getName(), getSizeInBits(),
720 getAlignInBits(), getEncoding(), getFlags());
721 }
722
723public:
724 DEFINE_MDNODE_GET(DIBasicType, (unsigned Tag, StringRef Name),
725 (Tag, Name, 0, 0, 0, FlagZero))
726 DEFINE_MDNODE_GET(DIBasicType,
727 (unsigned Tag, StringRef Name, uint64_t SizeInBits,
728 uint32_t AlignInBits, unsigned Encoding, DIFlags Flags),
729 (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags))
730 DEFINE_MDNODE_GET(DIBasicType,
731 (unsigned Tag, MDString *Name, uint64_t SizeInBits,
732 uint32_t AlignInBits, unsigned Encoding, DIFlags Flags),
733 (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags))
734
735 TempDIBasicType clone() const { return cloneImpl(); }
736
737 unsigned getEncoding() const { return Encoding; }
738
739 enum class Signedness { Signed, Unsigned };
740
741 /// Return the signedness of this type, or None if this type is neither
742 /// signed nor unsigned.
743 Optional<Signedness> getSignedness() const;
744
745 static bool classof(const Metadata *MD) {
746 return MD->getMetadataID() == DIBasicTypeKind;
747 }
748};
749
750/// Derived types.
751///
752/// This includes qualified types, pointers, references, friends, typedefs, and
753/// class members.
754///
755/// TODO: Split out members (inheritance, fields, methods, etc.).
756class DIDerivedType : public DIType {
757 friend class LLVMContextImpl;
758 friend class MDNode;
759
760 /// The DWARF address space of the memory pointed to or referenced by a
761 /// pointer or reference type respectively.
762 Optional<unsigned> DWARFAddressSpace;
763
764 DIDerivedType(LLVMContext &C, StorageType Storage, unsigned Tag,
765 unsigned Line, uint64_t SizeInBits, uint32_t AlignInBits,
766 uint64_t OffsetInBits, Optional<unsigned> DWARFAddressSpace,
767 DIFlags Flags, ArrayRef<Metadata *> Ops)
768 : DIType(C, DIDerivedTypeKind, Storage, Tag, Line, SizeInBits,
769 AlignInBits, OffsetInBits, Flags, Ops),
770 DWARFAddressSpace(DWARFAddressSpace) {}
771 ~DIDerivedType() = default;
772
773 static DIDerivedType *
774 getImpl(LLVMContext &Context, unsigned Tag, StringRef Name, DIFile *File,
775 unsigned Line, DIScope *Scope, DIType *BaseType, uint64_t SizeInBits,
776 uint32_t AlignInBits, uint64_t OffsetInBits,
777 Optional<unsigned> DWARFAddressSpace, DIFlags Flags,
778 Metadata *ExtraData, StorageType Storage, bool ShouldCreate = true) {
779 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), File,
780 Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits,
781 DWARFAddressSpace, Flags, ExtraData, Storage, ShouldCreate);
782 }
783 static DIDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
784 MDString *Name, Metadata *File, unsigned Line,
785 Metadata *Scope, Metadata *BaseType,
786 uint64_t SizeInBits, uint32_t AlignInBits,
787 uint64_t OffsetInBits,
788 Optional<unsigned> DWARFAddressSpace,
789 DIFlags Flags, Metadata *ExtraData,
790 StorageType Storage, bool ShouldCreate = true);
791
792 TempDIDerivedType cloneImpl() const {
793 return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
794 getScope(), getBaseType(), getSizeInBits(),
795 getAlignInBits(), getOffsetInBits(),
796 getDWARFAddressSpace(), getFlags(), getExtraData());
797 }
798
799public:
800 DEFINE_MDNODE_GET(DIDerivedType,
801 (unsigned Tag, MDString *Name, Metadata *File,
802 unsigned Line, Metadata *Scope, Metadata *BaseType,
803 uint64_t SizeInBits, uint32_t AlignInBits,
804 uint64_t OffsetInBits,
805 Optional<unsigned> DWARFAddressSpace, DIFlags Flags,
806 Metadata *ExtraData = nullptr),
807 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
808 AlignInBits, OffsetInBits, DWARFAddressSpace, Flags,
809 ExtraData))
810 DEFINE_MDNODE_GET(DIDerivedType,
811 (unsigned Tag, StringRef Name, DIFile *File, unsigned Line,
812 DIScope *Scope, DIType *BaseType, uint64_t SizeInBits,
813 uint32_t AlignInBits, uint64_t OffsetInBits,
814 Optional<unsigned> DWARFAddressSpace, DIFlags Flags,
815 Metadata *ExtraData = nullptr),
816 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
817 AlignInBits, OffsetInBits, DWARFAddressSpace, Flags,
818 ExtraData))
819
820 TempDIDerivedType clone() const { return cloneImpl(); }
821
822 /// Get the base type this is derived from.
823 DIType *getBaseType() const { return cast_or_null<DIType>(getRawBaseType()); }
824 Metadata *getRawBaseType() const { return getOperand(3); }
825
826 /// \returns The DWARF address space of the memory pointed to or referenced by
827 /// a pointer or reference type respectively.
828 Optional<unsigned> getDWARFAddressSpace() const { return DWARFAddressSpace; }
829
830 /// Get extra data associated with this derived type.
831 ///
832 /// Class type for pointer-to-members, objective-c property node for ivars,
833 /// global constant wrapper for static members, or virtual base pointer offset
834 /// for inheritance.
835 ///
836 /// TODO: Separate out types that need this extra operand: pointer-to-member
837 /// types and member fields (static members and ivars).
838 Metadata *getExtraData() const { return getRawExtraData(); }
839 Metadata *getRawExtraData() const { return getOperand(4); }
840
841 /// Get casted version of extra data.
842 /// @{
843 DIType *getClassType() const {
844 assert(getTag() == dwarf::DW_TAG_ptr_to_member_type)((getTag() == dwarf::DW_TAG_ptr_to_member_type) ? static_cast
<void> (0) : __assert_fail ("getTag() == dwarf::DW_TAG_ptr_to_member_type"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include/llvm/IR/DebugInfoMetadata.h"
, 844, __PRETTY_FUNCTION__))
;
845 return cast_or_null<DIType>(getExtraData());
846 }
847
848 DIObjCProperty *getObjCProperty() const {
849 return dyn_cast_or_null<DIObjCProperty>(getExtraData());
850 }
851
852 uint32_t getVBPtrOffset() const {
853 assert(getTag() == dwarf::DW_TAG_inheritance)((getTag() == dwarf::DW_TAG_inheritance) ? static_cast<void
> (0) : __assert_fail ("getTag() == dwarf::DW_TAG_inheritance"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include/llvm/IR/DebugInfoMetadata.h"
, 853, __PRETTY_FUNCTION__))
;
854 if (auto *CM = cast_or_null<ConstantAsMetadata>(getExtraData()))
855 if (auto *CI = dyn_cast_or_null<ConstantInt>(CM->getValue()))
856 return static_cast<uint32_t>(CI->getZExtValue());
857 return 0;
858 }
859
860 Constant *getStorageOffsetInBits() const {
861 assert(getTag() == dwarf::DW_TAG_member && isBitField())((getTag() == dwarf::DW_TAG_member && isBitField()) ?
static_cast<void> (0) : __assert_fail ("getTag() == dwarf::DW_TAG_member && isBitField()"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include/llvm/IR/DebugInfoMetadata.h"
, 861, __PRETTY_FUNCTION__))
;
862 if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
863 return C->getValue();
864 return nullptr;
865 }
866
867 Constant *getConstant() const {
868 assert(getTag() == dwarf::DW_TAG_member && isStaticMember())((getTag() == dwarf::DW_TAG_member && isStaticMember(
)) ? static_cast<void> (0) : __assert_fail ("getTag() == dwarf::DW_TAG_member && isStaticMember()"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include/llvm/IR/DebugInfoMetadata.h"
, 868, __PRETTY_FUNCTION__))
;
869 if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
870 return C->getValue();
871 return nullptr;
872 }
873 Constant *getDiscriminantValue() const {
874 assert(getTag() == dwarf::DW_TAG_member && !isStaticMember())((getTag() == dwarf::DW_TAG_member && !isStaticMember
()) ? static_cast<void> (0) : __assert_fail ("getTag() == dwarf::DW_TAG_member && !isStaticMember()"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include/llvm/IR/DebugInfoMetadata.h"
, 874, __PRETTY_FUNCTION__))
;
875 if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
876 return C->getValue();
877 return nullptr;
878 }
879 /// @}
880
881 static bool classof(const Metadata *MD) {
882 return MD->getMetadataID() == DIDerivedTypeKind;
883 }
884};
885
886/// Composite types.
887///
888/// TODO: Detach from DerivedTypeBase (split out MDEnumType?).
889/// TODO: Create a custom, unrelated node for DW_TAG_array_type.
890class DICompositeType : public DIType {
891 friend class LLVMContextImpl;
892 friend class MDNode;
893
894 unsigned RuntimeLang;
895
896 DICompositeType(LLVMContext &C, StorageType Storage, unsigned Tag,
897 unsigned Line, unsigned RuntimeLang, uint64_t SizeInBits,
898 uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
899 ArrayRef<Metadata *> Ops)
900 : DIType(C, DICompositeTypeKind, Storage, Tag, Line, SizeInBits,
901 AlignInBits, OffsetInBits, Flags, Ops),
902 RuntimeLang(RuntimeLang) {}
903 ~DICompositeType() = default;
904
905 /// Change fields in place.
906 void mutate(unsigned Tag, unsigned Line, unsigned RuntimeLang,
907 uint64_t SizeInBits, uint32_t AlignInBits,
908 uint64_t OffsetInBits, DIFlags Flags) {
909 assert(isDistinct() && "Only distinct nodes can mutate")((isDistinct() && "Only distinct nodes can mutate") ?
static_cast<void> (0) : __assert_fail ("isDistinct() && \"Only distinct nodes can mutate\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include/llvm/IR/DebugInfoMetadata.h"
, 909, __PRETTY_FUNCTION__))
;
910 assert(getRawIdentifier() && "Only ODR-uniqued nodes should mutate")((getRawIdentifier() && "Only ODR-uniqued nodes should mutate"
) ? static_cast<void> (0) : __assert_fail ("getRawIdentifier() && \"Only ODR-uniqued nodes should mutate\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include/llvm/IR/DebugInfoMetadata.h"
, 910, __PRETTY_FUNCTION__))
;
911 this->RuntimeLang = RuntimeLang;
912 DIType::mutate(Tag, Line, SizeInBits, AlignInBits, OffsetInBits, Flags);
913 }
914
915 static DICompositeType *
916 getImpl(LLVMContext &Context, unsigned Tag, StringRef Name, Metadata *File,
917 unsigned Line, DIScope *Scope, DIType *BaseType, uint64_t SizeInBits,
918 uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
919 DINodeArray Elements, unsigned RuntimeLang, DIType *VTableHolder,
920 DITemplateParameterArray TemplateParams, StringRef Identifier,
921 DIDerivedType *Discriminator, StorageType Storage,
922 bool ShouldCreate = true) {
923 return getImpl(
924 Context, Tag, getCanonicalMDString(Context, Name), File, Line, Scope,
925 BaseType, SizeInBits, AlignInBits, OffsetInBits, Flags, Elements.get(),
926 RuntimeLang, VTableHolder, TemplateParams.get(),
927 getCanonicalMDString(Context, Identifier), Discriminator, Storage, ShouldCreate);
928 }
929 static DICompositeType *
930 getImpl(LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
931 unsigned Line, Metadata *Scope, Metadata *BaseType,
932 uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
933 DIFlags Flags, Metadata *Elements, unsigned RuntimeLang,
934 Metadata *VTableHolder, Metadata *TemplateParams,
935 MDString *Identifier, Metadata *Discriminator,
936 StorageType Storage, bool ShouldCreate = true);
937
938 TempDICompositeType cloneImpl() const {
939 return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
940 getScope(), getBaseType(), getSizeInBits(),
941 getAlignInBits(), getOffsetInBits(), getFlags(),
942 getElements(), getRuntimeLang(), getVTableHolder(),
943 getTemplateParams(), getIdentifier(), getDiscriminator());
944 }
945
946public:
947 DEFINE_MDNODE_GET(DICompositeType,
948 (unsigned Tag, StringRef Name, DIFile *File, unsigned Line,
949 DIScope *Scope, DIType *BaseType, uint64_t SizeInBits,
950 uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
951 DINodeArray Elements, unsigned RuntimeLang,
952 DIType *VTableHolder,
953 DITemplateParameterArray TemplateParams = nullptr,
954 StringRef Identifier = "",
955 DIDerivedType *Discriminator = nullptr),
956 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
957 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
958 VTableHolder, TemplateParams, Identifier, Discriminator))
959 DEFINE_MDNODE_GET(DICompositeType,
960 (unsigned Tag, MDString *Name, Metadata *File,
961 unsigned Line, Metadata *Scope, Metadata *BaseType,
962 uint64_t SizeInBits, uint32_t AlignInBits,
963 uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
964 unsigned RuntimeLang, Metadata *VTableHolder,
965 Metadata *TemplateParams = nullptr,
966 MDString *Identifier = nullptr,
967 Metadata *Discriminator = nullptr),
968 (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
969 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
970 VTableHolder, TemplateParams, Identifier, Discriminator))
971
972 TempDICompositeType clone() const { return cloneImpl(); }
973
974 /// Get a DICompositeType with the given ODR identifier.
975 ///
976 /// If \a LLVMContext::isODRUniquingDebugTypes(), gets the mapped
977 /// DICompositeType for the given ODR \c Identifier. If none exists, creates
978 /// a new node.
979 ///
980 /// Else, returns \c nullptr.
981 static DICompositeType *
982 getODRType(LLVMContext &Context, MDString &Identifier, unsigned Tag,
983 MDString *Name, Metadata *File, unsigned Line, Metadata *Scope,
984 Metadata *BaseType, uint64_t SizeInBits, uint32_t AlignInBits,
985 uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
986 unsigned RuntimeLang, Metadata *VTableHolder,
987 Metadata *TemplateParams, Metadata *Discriminator);
988 static DICompositeType *getODRTypeIfExists(LLVMContext &Context,
989 MDString &Identifier);
990
991 /// Build a DICompositeType with the given ODR identifier.
992 ///
993 /// Looks up the mapped DICompositeType for the given ODR \c Identifier. If
994 /// it doesn't exist, creates a new one. If it does exist and \a
995 /// isForwardDecl(), and the new arguments would be a definition, mutates the
996 /// the type in place. In either case, returns the type.
997 ///
998 /// If not \a LLVMContext::isODRUniquingDebugTypes(), this function returns
999 /// nullptr.
1000 static DICompositeType *
1001 buildODRType(LLVMContext &Context, MDString &Identifier, unsigned Tag,
1002 MDString *Name, Metadata *File, unsigned Line, Metadata *Scope,
1003 Metadata *BaseType, uint64_t SizeInBits, uint32_t AlignInBits,
1004 uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
1005 unsigned RuntimeLang, Metadata *VTableHolder,
1006 Metadata *TemplateParams, Metadata *Discriminator);
1007
1008 DIType *getBaseType() const { return cast_or_null<DIType>(getRawBaseType()); }
1009 DINodeArray getElements() const {
1010 return cast_or_null<MDTuple>(getRawElements());
1011 }
1012 DIType *getVTableHolder() const {
1013 return cast_or_null<DIType>(getRawVTableHolder());
1014 }
1015 DITemplateParameterArray getTemplateParams() const {
1016 return cast_or_null<MDTuple>(getRawTemplateParams());
1017 }
1018 StringRef getIdentifier() const { return getStringOperand(7); }
1019 unsigned getRuntimeLang() const { return RuntimeLang; }
1020
1021 Metadata *getRawBaseType() const { return getOperand(3); }
1022 Metadata *getRawElements() const { return getOperand(4); }
1023 Metadata *getRawVTableHolder() const { return getOperand(5); }
1024 Metadata *getRawTemplateParams() const { return getOperand(6); }
1025 MDString *getRawIdentifier() const { return getOperandAs<MDString>(7); }
1026 Metadata *getRawDiscriminator() const { return getOperand(8); }
1027 DIDerivedType *getDiscriminator() const { return getOperandAs<DIDerivedType>(8); }
1028
1029 /// Replace operands.
1030 ///
1031 /// If this \a isUniqued() and not \a isResolved(), on a uniquing collision
1032 /// this will be RAUW'ed and deleted. Use a \a TrackingMDRef to keep track
1033 /// of its movement if necessary.
1034 /// @{
1035 void replaceElements(DINodeArray Elements) {
1036#ifndef NDEBUG
1037 for (DINode *Op : getElements())
1038 assert(is_contained(Elements->operands(), Op) &&((is_contained(Elements->operands(), Op) && "Lost a member during member list replacement"
) ? static_cast<void> (0) : __assert_fail ("is_contained(Elements->operands(), Op) && \"Lost a member during member list replacement\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include/llvm/IR/DebugInfoMetadata.h"
, 1039, __PRETTY_FUNCTION__))
1039 "Lost a member during member list replacement")((is_contained(Elements->operands(), Op) && "Lost a member during member list replacement"
) ? static_cast<void> (0) : __assert_fail ("is_contained(Elements->operands(), Op) && \"Lost a member during member list replacement\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include/llvm/IR/DebugInfoMetadata.h"
, 1039, __PRETTY_FUNCTION__))
;
1040#endif
1041 replaceOperandWith(4, Elements.get());
1042 }
1043
1044 void replaceVTableHolder(DIType *VTableHolder) {
1045 replaceOperandWith(5, VTableHolder);
1046 }
1047
1048 void replaceTemplateParams(DITemplateParameterArray TemplateParams) {
1049 replaceOperandWith(6, TemplateParams.get());
1050 }
1051 /// @}
1052
1053 static bool classof(const Metadata *MD) {
1054 return MD->getMetadataID() == DICompositeTypeKind;
1055 }
1056};
1057
1058/// Type array for a subprogram.
1059///
1060/// TODO: Fold the array of types in directly as operands.
1061class DISubroutineType : public DIType {
1062 friend class LLVMContextImpl;
1063 friend class MDNode;
1064
1065 /// The calling convention used with DW_AT_calling_convention. Actually of
1066 /// type dwarf::CallingConvention.
1067 uint8_t CC;
1068
1069 DISubroutineType(LLVMContext &C, StorageType Storage, DIFlags Flags,
1070 uint8_t CC, ArrayRef<Metadata *> Ops)
1071 : DIType(C, DISubroutineTypeKind, Storage, dwarf::DW_TAG_subroutine_type,
1072 0, 0, 0, 0, Flags, Ops),
1073 CC(CC) {}
1074 ~DISubroutineType() = default;
1075
1076 static DISubroutineType *getImpl(LLVMContext &Context, DIFlags Flags,
1077 uint8_t CC, DITypeRefArray TypeArray,
1078 StorageType Storage,
1079 bool ShouldCreate = true) {
1080 return getImpl(Context, Flags, CC, TypeArray.get(), Storage, ShouldCreate);
1081 }
1082 static DISubroutineType *getImpl(LLVMContext &Context, DIFlags Flags,
1083 uint8_t CC, Metadata *TypeArray,
1084 StorageType Storage,
1085 bool ShouldCreate = true);
1086
1087 TempDISubroutineType cloneImpl() const {
1088 return getTemporary(getContext(), getFlags(), getCC(), getTypeArray());
1089 }
1090
1091public:
1092 DEFINE_MDNODE_GET(DISubroutineType,
1093 (DIFlags Flags, uint8_t CC, DITypeRefArray TypeArray),
1094 (Flags, CC, TypeArray))
1095 DEFINE_MDNODE_GET(DISubroutineType,
1096 (DIFlags Flags, uint8_t CC, Metadata *TypeArray),
1097 (Flags, CC, TypeArray))
1098
1099 TempDISubroutineType clone() const { return cloneImpl(); }
1100
1101 uint8_t getCC() const { return CC; }
1102
1103 DITypeRefArray getTypeArray() const {
1104 return cast_or_null<MDTuple>(getRawTypeArray());
1105 }
1106
1107 Metadata *getRawTypeArray() const { return getOperand(3); }
1108
1109 static bool classof(const Metadata *MD) {
1110 return MD->getMetadataID() == DISubroutineTypeKind;
1111 }
1112};
1113
1114/// Compile unit.
1115class DICompileUnit : public DIScope {
1116 friend class LLVMContextImpl;
1117 friend class MDNode;
1118
1119public:
1120 enum DebugEmissionKind : unsigned {
1121 NoDebug = 0,
1122 FullDebug,
1123 LineTablesOnly,
1124 DebugDirectivesOnly,
1125 LastEmissionKind = DebugDirectivesOnly
1126 };
1127
1128 enum class DebugNameTableKind : unsigned {
1129 Default = 0,
1130 GNU = 1,
1131 None = 2,
1132 LastDebugNameTableKind = None
1133 };
1134
1135 static Optional<DebugEmissionKind> getEmissionKind(StringRef Str);
1136 static const char *emissionKindString(DebugEmissionKind EK);
1137 static Optional<DebugNameTableKind> getNameTableKind(StringRef Str);
1138 static const char *nameTableKindString(DebugNameTableKind PK);
1139
1140private:
1141 unsigned SourceLanguage;
1142 bool IsOptimized;
1143 unsigned RuntimeVersion;
1144 unsigned EmissionKind;
1145 uint64_t DWOId;
1146 bool SplitDebugInlining;
1147 bool DebugInfoForProfiling;
1148 unsigned NameTableKind;
1149 bool RangesBaseAddress;
1150
1151 DICompileUnit(LLVMContext &C, StorageType Storage, unsigned SourceLanguage,
1152 bool IsOptimized, unsigned RuntimeVersion,
1153 unsigned EmissionKind, uint64_t DWOId, bool SplitDebugInlining,
1154 bool DebugInfoForProfiling, unsigned NameTableKind,
1155 bool RangesBaseAddress, ArrayRef<Metadata *> Ops)
1156 : DIScope(C, DICompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops),
1157 SourceLanguage(SourceLanguage), IsOptimized(IsOptimized),
1158 RuntimeVersion(RuntimeVersion), EmissionKind(EmissionKind),
1159 DWOId(DWOId), SplitDebugInlining(SplitDebugInlining),
1160 DebugInfoForProfiling(DebugInfoForProfiling),
1161 NameTableKind(NameTableKind), RangesBaseAddress(RangesBaseAddress) {
1162 assert(Storage != Uniqued)((Storage != Uniqued) ? static_cast<void> (0) : __assert_fail
("Storage != Uniqued", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include/llvm/IR/DebugInfoMetadata.h"
, 1162, __PRETTY_FUNCTION__))
;
1163 }
1164 ~DICompileUnit() = default;
1165
1166 static DICompileUnit *
1167 getImpl(LLVMContext &Context, unsigned SourceLanguage, DIFile *File,
1168 StringRef Producer, bool IsOptimized, StringRef Flags,
1169 unsigned RuntimeVersion, StringRef SplitDebugFilename,
1170 unsigned EmissionKind, DICompositeTypeArray EnumTypes,
1171 DIScopeArray RetainedTypes,
1172 DIGlobalVariableExpressionArray GlobalVariables,
1173 DIImportedEntityArray ImportedEntities, DIMacroNodeArray Macros,
1174 uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
1175 unsigned NameTableKind, bool RangesBaseAddress, StorageType Storage,
1176 bool ShouldCreate = true) {
1177 return getImpl(Context, SourceLanguage, File,
1178 getCanonicalMDString(Context, Producer), IsOptimized,
1179 getCanonicalMDString(Context, Flags), RuntimeVersion,
1180 getCanonicalMDString(Context, SplitDebugFilename),
1181 EmissionKind, EnumTypes.get(), RetainedTypes.get(),
1182 GlobalVariables.get(), ImportedEntities.get(), Macros.get(),
1183 DWOId, SplitDebugInlining, DebugInfoForProfiling,
1184 NameTableKind, RangesBaseAddress, Storage, ShouldCreate);
1185 }
1186 static DICompileUnit *
1187 getImpl(LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
1188 MDString *Producer, bool IsOptimized, MDString *Flags,
1189 unsigned RuntimeVersion, MDString *SplitDebugFilename,
1190 unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
1191 Metadata *GlobalVariables, Metadata *ImportedEntities,
1192 Metadata *Macros, uint64_t DWOId, bool SplitDebugInlining,
1193 bool DebugInfoForProfiling, unsigned NameTableKind,
1194 bool RangesBaseAddress, StorageType Storage, bool ShouldCreate = true);
1195
1196 TempDICompileUnit cloneImpl() const {
1197 return getTemporary(
1198 getContext(), getSourceLanguage(), getFile(), getProducer(),
1199 isOptimized(), getFlags(), getRuntimeVersion(), getSplitDebugFilename(),
1200 getEmissionKind(), getEnumTypes(), getRetainedTypes(),
1201 getGlobalVariables(), getImportedEntities(), getMacros(), DWOId,
1202 getSplitDebugInlining(), getDebugInfoForProfiling(), getNameTableKind(),
1203 getRangesBaseAddress());
1204 }
1205
1206public:
1207 static void get() = delete;
1208 static void getIfExists() = delete;
1209
1210 DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, (
unsigned)NameTableKind, RangesBaseAddress)), Distinct); } static
TempDICompileUnit getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return TempDICompileUnit( getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress
)), Temporary)); }
1211 DICompileUnit,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, (
unsigned)NameTableKind, RangesBaseAddress)), Distinct); } static
TempDICompileUnit getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return TempDICompileUnit( getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress
)), Temporary)); }
1212 (unsigned SourceLanguage, DIFile *File, StringRef Producer,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, (
unsigned)NameTableKind, RangesBaseAddress)), Distinct); } static
TempDICompileUnit getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return TempDICompileUnit( getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress
)), Temporary)); }
1213 bool IsOptimized, StringRef Flags, unsigned RuntimeVersion,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, (
unsigned)NameTableKind, RangesBaseAddress)), Distinct); } static
TempDICompileUnit getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return TempDICompileUnit( getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress
)), Temporary)); }
1214 StringRef SplitDebugFilename, DebugEmissionKind EmissionKind,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, (
unsigned)NameTableKind, RangesBaseAddress)), Distinct); } static
TempDICompileUnit getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return TempDICompileUnit( getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress
)), Temporary)); }
1215 DICompositeTypeArray EnumTypes, DIScopeArray RetainedTypes,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, (
unsigned)NameTableKind, RangesBaseAddress)), Distinct); } static
TempDICompileUnit getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return TempDICompileUnit( getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress
)), Temporary)); }
1216 DIGlobalVariableExpressionArray GlobalVariables,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, (
unsigned)NameTableKind, RangesBaseAddress)), Distinct); } static
TempDICompileUnit getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return TempDICompileUnit( getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress
)), Temporary)); }
1217 DIImportedEntityArray ImportedEntities, DIMacroNodeArray Macros,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, (
unsigned)NameTableKind, RangesBaseAddress)), Distinct); } static
TempDICompileUnit getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return TempDICompileUnit( getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress
)), Temporary)); }
1218 uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, (
unsigned)NameTableKind, RangesBaseAddress)), Distinct); } static
TempDICompileUnit getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return TempDICompileUnit( getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress
)), Temporary)); }
1219 DebugNameTableKind NameTableKind, bool RangesBaseAddress),static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, (
unsigned)NameTableKind, RangesBaseAddress)), Distinct); } static
TempDICompileUnit getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return TempDICompileUnit( getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress
)), Temporary)); }
1220 (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, (
unsigned)NameTableKind, RangesBaseAddress)), Distinct); } static
TempDICompileUnit getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return TempDICompileUnit( getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress
)), Temporary)); }
1221 SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, (
unsigned)NameTableKind, RangesBaseAddress)), Distinct); } static
TempDICompileUnit getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return TempDICompileUnit( getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress
)), Temporary)); }
1222 GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, (
unsigned)NameTableKind, RangesBaseAddress)), Distinct); } static
TempDICompileUnit getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return TempDICompileUnit( getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress
)), Temporary)); }
1223 DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress))static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage
, File, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, (
unsigned)NameTableKind, RangesBaseAddress)), Distinct); } static
TempDICompileUnit getTemporary(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, DIFile *File, StringRef Producer, bool
IsOptimized, StringRef Flags, unsigned RuntimeVersion, StringRef
SplitDebugFilename, DebugEmissionKind EmissionKind, DICompositeTypeArray
EnumTypes, DIScopeArray RetainedTypes, DIGlobalVariableExpressionArray
GlobalVariables, DIImportedEntityArray ImportedEntities, DIMacroNodeArray
Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, DebugNameTableKind NameTableKind, bool RangesBaseAddress)))
{ return TempDICompileUnit( getImpl(Context, DEFINE_MDNODE_GET_UNPACK
((SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion
, SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining
, DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress
)), Temporary)); }
1224 DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, unsigned
NameTableKind, bool RangesBaseAddress))) { return getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, NameTableKind, RangesBaseAddress
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, unsigned NameTableKind, bool RangesBaseAddress))) { return TempDICompileUnit
( getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File
, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, NameTableKind
, RangesBaseAddress)), Temporary)); }
1225 DICompileUnit,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, unsigned
NameTableKind, bool RangesBaseAddress))) { return getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, NameTableKind, RangesBaseAddress
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, unsigned NameTableKind, bool RangesBaseAddress))) { return TempDICompileUnit
( getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File
, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, NameTableKind
, RangesBaseAddress)), Temporary)); }
1226 (unsigned SourceLanguage, Metadata *File, MDString *Producer,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, unsigned
NameTableKind, bool RangesBaseAddress))) { return getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, NameTableKind, RangesBaseAddress
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, unsigned NameTableKind, bool RangesBaseAddress))) { return TempDICompileUnit
( getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File
, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, NameTableKind
, RangesBaseAddress)), Temporary)); }
1227 bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, unsigned
NameTableKind, bool RangesBaseAddress))) { return getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, NameTableKind, RangesBaseAddress
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, unsigned NameTableKind, bool RangesBaseAddress))) { return TempDICompileUnit
( getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File
, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, NameTableKind
, RangesBaseAddress)), Temporary)); }
1228 MDString *SplitDebugFilename, unsigned EmissionKind, Metadata *EnumTypes,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, unsigned
NameTableKind, bool RangesBaseAddress))) { return getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, NameTableKind, RangesBaseAddress
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, unsigned NameTableKind, bool RangesBaseAddress))) { return TempDICompileUnit
( getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File
, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, NameTableKind
, RangesBaseAddress)), Temporary)); }
1229 Metadata *RetainedTypes, Metadata *GlobalVariables,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, unsigned
NameTableKind, bool RangesBaseAddress))) { return getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, NameTableKind, RangesBaseAddress
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, unsigned NameTableKind, bool RangesBaseAddress))) { return TempDICompileUnit
( getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File
, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, NameTableKind
, RangesBaseAddress)), Temporary)); }
1230 Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, unsigned
NameTableKind, bool RangesBaseAddress))) { return getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, NameTableKind, RangesBaseAddress
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, unsigned NameTableKind, bool RangesBaseAddress))) { return TempDICompileUnit
( getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File
, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, NameTableKind
, RangesBaseAddress)), Temporary)); }
1231 bool SplitDebugInlining, bool DebugInfoForProfiling,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, unsigned
NameTableKind, bool RangesBaseAddress))) { return getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, NameTableKind, RangesBaseAddress
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, unsigned NameTableKind, bool RangesBaseAddress))) { return TempDICompileUnit
( getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File
, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, NameTableKind
, RangesBaseAddress)), Temporary)); }
1232 unsigned NameTableKind, bool RangesBaseAddress),static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, unsigned
NameTableKind, bool RangesBaseAddress))) { return getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, NameTableKind, RangesBaseAddress
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, unsigned NameTableKind, bool RangesBaseAddress))) { return TempDICompileUnit
( getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File
, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, NameTableKind
, RangesBaseAddress)), Temporary)); }
1233 (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, unsigned
NameTableKind, bool RangesBaseAddress))) { return getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, NameTableKind, RangesBaseAddress
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, unsigned NameTableKind, bool RangesBaseAddress))) { return TempDICompileUnit
( getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File
, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, NameTableKind
, RangesBaseAddress)), Temporary)); }
1234 SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, unsigned
NameTableKind, bool RangesBaseAddress))) { return getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, NameTableKind, RangesBaseAddress
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, unsigned NameTableKind, bool RangesBaseAddress))) { return TempDICompileUnit
( getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File
, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, NameTableKind
, RangesBaseAddress)), Temporary)); }
1235 GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining,static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, unsigned
NameTableKind, bool RangesBaseAddress))) { return getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, NameTableKind, RangesBaseAddress
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, unsigned NameTableKind, bool RangesBaseAddress))) { return TempDICompileUnit
( getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File
, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, NameTableKind
, RangesBaseAddress)), Temporary)); }
1236 DebugInfoForProfiling, NameTableKind, RangesBaseAddress))static DICompileUnit *getDistinct(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK
((unsigned SourceLanguage, Metadata *File, MDString *Producer
, bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
MDString *SplitDebugFilename, unsigned EmissionKind, Metadata
*EnumTypes, Metadata *RetainedTypes, Metadata *GlobalVariables
, Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId
, bool SplitDebugInlining, bool DebugInfoForProfiling, unsigned
NameTableKind, bool RangesBaseAddress))) { return getImpl(Context
, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File, Producer, IsOptimized
, Flags, RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes
, RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId
, SplitDebugInlining, DebugInfoForProfiling, NameTableKind, RangesBaseAddress
)), Distinct); } static TempDICompileUnit getTemporary(LLVMContext
&Context, DEFINE_MDNODE_GET_UNPACK((unsigned SourceLanguage
, Metadata *File, MDString *Producer, bool IsOptimized, MDString
*Flags, unsigned RuntimeVersion, MDString *SplitDebugFilename
, unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes
, Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata
*Macros, uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling
, unsigned NameTableKind, bool RangesBaseAddress))) { return TempDICompileUnit
( getImpl(Context, DEFINE_MDNODE_GET_UNPACK((SourceLanguage, File
, Producer, IsOptimized, Flags, RuntimeVersion, SplitDebugFilename
, EmissionKind, EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities
, Macros, DWOId, SplitDebugInlining, DebugInfoForProfiling, NameTableKind
, RangesBaseAddress)), Temporary)); }
1237
1238 TempDICompileUnit clone() const { return cloneImpl(); }
1239
1240 unsigned getSourceLanguage() const { return SourceLanguage; }
1241 bool isOptimized() const { return IsOptimized; }
1242 unsigned getRuntimeVersion() const { return RuntimeVersion; }
1243 DebugEmissionKind getEmissionKind() const {
1244 return (DebugEmissionKind)EmissionKind;
1245 }
1246 bool isDebugDirectivesOnly() const {
1247 return EmissionKind == DebugDirectivesOnly;
1248 }
1249 bool getDebugInfoForProfiling() const { return DebugInfoForProfiling; }
1250 DebugNameTableKind getNameTableKind() const {
1251 return (DebugNameTableKind)NameTableKind;
1252 }
1253 bool getRangesBaseAddress() const {
1254 return RangesBaseAddress; }
1255 StringRef getProducer() const {
1256 return getStringOperand(1); }
1257 StringRef getFlags() const {
1258 return getStringOperand(2); }
1259 StringRef getSplitDebugFilename() const {
1260 return getStringOperand(3); }
1261 DICompositeTypeArray getEnumTypes() const {
1262 return cast_or_null<MDTuple>(getRawEnumTypes());
1263 }
1264 DIScopeArray getRetainedTypes() const {
1265 return cast_or_null<MDTuple>(getRawRetainedTypes());
1266 }
1267 DIGlobalVariableExpressionArray getGlobalVariables() const {
1268 return cast_or_null<MDTuple>(getRawGlobalVariables());
1269 }
1270 DIImportedEntityArray getImportedEntities() const {
1271 return cast_or_null<MDTuple>(getRawImportedEntities());
1272 }
1273 DIMacroNodeArray getMacros() const {
1274 return cast_or_null<MDTuple>(getRawMacros());
1275 }
1276 uint64_t getDWOId() const { return DWOId; }
1277 void setDWOId(uint64_t DwoId) { DWOId = DwoId; }
1278 bool getSplitDebugInlining() const { return SplitDebugInlining; }
1279 void setSplitDebugInlining(bool SplitDebugInlining) {
1280 this->SplitDebugInlining = SplitDebugInlining;
1281 }
1282
1283 MDString *getRawProducer() const { return getOperandAs<MDString>(1); }
1284 MDString *getRawFlags() const { return getOperandAs<MDString>(2); }
1285 MDString *getRawSplitDebugFilename() const {
1286 return getOperandAs<MDString>(3);
1287 }
1288 Metadata *getRawEnumTypes() const { return getOperand(4); }
1289 Metadata *getRawRetainedTypes() const { return getOperand(5); }
1290 Metadata *getRawGlobalVariables() const { return getOperand(6); }
1291 Metadata *getRawImportedEntities() const { return getOperand(7); }
1292 Metadata *getRawMacros() const { return getOperand(8); }
1293
1294 /// Replace arrays.
1295 ///
1296 /// If this \a isUniqued() and not \a isResolved(), it will be RAUW'ed and
1297 /// deleted on a uniquing collision. In practice, uniquing collisions on \a
1298 /// DICompileUnit should be fairly rare.
1299 /// @{
1300 void replaceEnumTypes(DICompositeTypeArray N) {
1301 replaceOperandWith(4, N.get());
1302 }
1303 void replaceRetainedTypes(DITypeArray N) {
1304 replaceOperandWith(5, N.get());
1305 }
1306 void replaceGlobalVariables(DIGlobalVariableExpressionArray N) {
1307 replaceOperandWith(6, N.get());
1308 }
1309 void replaceImportedEntities(DIImportedEntityArray N) {
1310 replaceOperandWith(7, N.get());
1311 }
1312 void replaceMacros(DIMacroNodeArray N) { replaceOperandWith(8, N.get()); }
1313 /// @}
1314
1315 static bool classof(const Metadata *MD) {
1316 return MD->getMetadataID() == DICompileUnitKind;
1317 }
1318};
1319
1320/// A scope for locals.
1321///
1322/// A legal scope for lexical blocks, local variables, and debug info
1323/// locations. Subclasses are \a DISubprogram, \a DILexicalBlock, and \a
1324/// DILexicalBlockFile.
1325class DILocalScope : public DIScope {
1326protected:
1327 DILocalScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
1328 ArrayRef<Metadata *> Ops)
1329 : DIScope(C, ID, Storage, Tag, Ops) {}
1330 ~DILocalScope() = default;
1331
1332public:
1333 /// Get the subprogram for this scope.
1334 ///
1335 /// Return this if it's an \a DISubprogram; otherwise, look up the scope
1336 /// chain.
1337 DISubprogram *getSubprogram() const;
1338
1339 /// Get the first non DILexicalBlockFile scope of this scope.
1340 ///
1341 /// Return this if it's not a \a DILexicalBlockFIle; otherwise, look up the
1342 /// scope chain.
1343 DILocalScope *getNonLexicalBlockFileScope() const;
1344
1345 static bool classof(const Metadata *MD) {
1346 return MD->getMetadataID() == DISubprogramKind ||
1347 MD->getMetadataID() == DILexicalBlockKind ||
1348 MD->getMetadataID() == DILexicalBlockFileKind;
1349 }
1350};
1351
1352/// Debug location.
1353///
1354/// A debug location in source code, used for debug info and otherwise.
1355class DILocation : public MDNode {
1356 friend class LLVMContextImpl;
1357 friend class MDNode;
1358
1359 DILocation(LLVMContext &C, StorageType Storage, unsigned Line,
1360 unsigned Column, ArrayRef<Metadata *> MDs, bool ImplicitCode);
1361 ~DILocation() { dropAllReferences(); }
1362
1363 static DILocation *getImpl(LLVMContext &Context, unsigned Line,
1364 unsigned Column, Metadata *Scope,
1365 Metadata *InlinedAt, bool ImplicitCode,
1366 StorageType Storage, bool ShouldCreate = true);
1367 static DILocation *getImpl(LLVMContext &Context, unsigned Line,
1368 unsigned Column, DILocalScope *Scope,
1369 DILocation *InlinedAt, bool ImplicitCode,
1370 StorageType Storage, bool ShouldCreate = true) {
1371 return getImpl(Context, Line, Column, static_cast<Metadata *>(Scope),
1372 static_cast<Metadata *>(InlinedAt), ImplicitCode, Storage,
1373 ShouldCreate);
1374 }
1375
1376 /// With a given unsigned int \p U, use up to 13 bits to represent it.
1377 /// old_bit 1~5 --> new_bit 1~5
1378 /// old_bit 6~12 --> new_bit 7~13
1379 /// new_bit_6 is 0 if higher bits (7~13) are all 0
1380 static unsigned getPrefixEncodingFromUnsigned(unsigned U) {
1381 U &= 0xfff;
1382 return U > 0x1f ? (((U & 0xfe0) << 1) | (U & 0x1f) | 0x20) : U;
1383 }
1384
1385 /// Reverse transformation as getPrefixEncodingFromUnsigned.
1386 static unsigned getUnsignedFromPrefixEncoding(unsigned U) {
1387 if (U & 1)
1388 return 0;
1389 U >>= 1;
1390 return (U & 0x20) ? (((U >> 1) & 0xfe0) | (U & 0x1f)) : (U & 0x1f);
1391 }
1392
1393 /// Returns the next component stored in discriminator.
1394 static unsigned getNextComponentInDiscriminator(unsigned D) {
1395 if ((D & 1) == 0)
1396 return D >> ((D & 0x40) ? 14 : 7);
1397 else
1398 return D >> 1;
1399 }
1400
1401 TempDILocation cloneImpl() const {
1402 // Get the raw scope/inlinedAt since it is possible to invoke this on
1403 // a DILocation containing temporary metadata.
1404 return getTemporary(getContext(), getLine(), getColumn(), getRawScope(),
1405 getRawInlinedAt(), isImplicitCode());
1406 }
1407
1408 static unsigned encodeComponent(unsigned C) {
1409 return (C == 0) ? 1U : (getPrefixEncodingFromUnsigned(C) << 1);
1410 }
1411
1412 static unsigned encodingBits(unsigned C) {
1413 return (C
7.1
'C' is not equal to 0
7.1
'C' is not equal to 0
== 0) ? 1 : (C > 0x1f ? 14 : 7)
;
8
'?' condition is false
9
Assuming 'C' is > 31
10
'?' condition is true
11
Returning the value 14
1414 }
1415
1416public:
1417 // Disallow replacing operands.
1418 void replaceOperandWith(unsigned I, Metadata *New) = delete;
1419
1420 DEFINE_MDNODE_GET(DILocation,
1421 (unsigned Line, unsigned Column, Metadata *Scope,
1422 Metadata *InlinedAt = nullptr, bool ImplicitCode = false),
1423 (Line, Column, Scope, InlinedAt, ImplicitCode))
1424 DEFINE_MDNODE_GET(DILocation,
1425 (unsigned Line, unsigned Column, DILocalScope *Scope,
1426 DILocation *InlinedAt = nullptr,
1427 bool ImplicitCode = false),
1428 (Line, Column, Scope, InlinedAt, ImplicitCode))
1429
1430 /// Return a (temporary) clone of this.
1431 TempDILocation clone() const { return cloneImpl(); }
1432
1433 unsigned getLine() const { return SubclassData32; }
1434 unsigned getColumn() const { return SubclassData16; }
1435 DILocalScope *getScope() const { return cast<DILocalScope>(getRawScope()); }
1436
1437 DILocation *getInlinedAt() const {
1438 return cast_or_null<DILocation>(getRawInlinedAt());
1439 }
1440
1441 /// Check if the location corresponds to an implicit code.
1442 /// When the ImplicitCode flag is true, it means that the Instruction
1443 /// with this DILocation has been added by the front-end but it hasn't been
1444 /// written explicitly by the user (e.g. cleanup stuff in C++ put on a closing
1445 /// bracket). It's useful for code coverage to not show a counter on "empty"
1446 /// lines.
1447 bool isImplicitCode() const { return ImplicitCode; }
1448 void setImplicitCode(bool ImplicitCode) { this->ImplicitCode = ImplicitCode; }
1449
1450 DIFile *getFile() const { return getScope()->getFile(); }
1451 StringRef getFilename() const { return getScope()->getFilename(); }
1452 StringRef getDirectory() const { return getScope()->getDirectory(); }
1453 Optional<StringRef> getSource() const { return getScope()->getSource(); }
1454
1455 /// Get the scope where this is inlined.
1456 ///
1457 /// Walk through \a getInlinedAt() and return \a getScope() from the deepest
1458 /// location.
1459 DILocalScope *getInlinedAtScope() const {
1460 if (auto *IA = getInlinedAt())
1461 return IA->getInlinedAtScope();
1462 return getScope();
1463 }
1464
1465 /// Get the DWARF discriminator.
1466 ///
1467 /// DWARF discriminators distinguish identical file locations between
1468 /// instructions that are on different basic blocks.
1469 ///
1470 /// There are 3 components stored in discriminator, from lower bits:
1471 ///
1472 /// Base discriminator: assigned by AddDiscriminators pass to identify IRs
1473 /// that are defined by the same source line, but
1474 /// different basic blocks.
1475 /// Duplication factor: assigned by optimizations that will scale down
1476 /// the execution frequency of the original IR.
1477 /// Copy Identifier: assigned by optimizations that clones the IR.
1478 /// Each copy of the IR will be assigned an identifier.
1479 ///
1480 /// Encoding:
1481 ///
1482 /// The above 3 components are encoded into a 32bit unsigned integer in
1483 /// order. If the lowest bit is 1, the current component is empty, and the
1484 /// next component will start in the next bit. Otherwise, the current
1485 /// component is non-empty, and its content starts in the next bit. The
1486 /// value of each components is either 5 bit or 12 bit: if the 7th bit
1487 /// is 0, the bit 2~6 (5 bits) are used to represent the component; if the
1488 /// 7th bit is 1, the bit 2~6 (5 bits) and 8~14 (7 bits) are combined to
1489 /// represent the component. Thus, the number of bits used for a component
1490 /// is either 0 (if it and all the next components are empty); 1 - if it is
1491 /// empty; 7 - if its value is up to and including 0x1f (lsb and msb are both
1492 /// 0); or 14, if its value is up to and including 0x1ff. Note that the last
1493 /// component is also capped at 0x1ff, even in the case when both first
1494 /// components are 0, and we'd technically have 29 bits available.
1495 ///
1496 /// For precise control over the data being encoded in the discriminator,
1497 /// use encodeDiscriminator/decodeDiscriminator.
1498
1499 inline unsigned getDiscriminator() const;
1500
1501 /// Returns a new DILocation with updated \p Discriminator.
1502 inline const DILocation *cloneWithDiscriminator(unsigned Discriminator) const;
1503
1504 /// Returns a new DILocation with updated base discriminator \p BD. Only the
1505 /// base discriminator is set in the new DILocation, the other encoded values
1506 /// are elided.
1507 /// If the discriminator cannot be encoded, the function returns None.
1508 inline Optional<const DILocation *> cloneWithBaseDiscriminator(unsigned BD) const;
1509
1510 /// Returns the duplication factor stored in the discriminator, or 1 if no
1511 /// duplication factor (or 0) is encoded.
1512 inline unsigned getDuplicationFactor() const;
1513
1514 /// Returns the copy identifier stored in the discriminator.
1515 inline unsigned getCopyIdentifier() const;
1516
1517 /// Returns the base discriminator stored in the discriminator.
1518 inline unsigned getBaseDiscriminator() const;
1519
1520 /// Returns a new DILocation with duplication factor \p DF * current
1521 /// duplication factor encoded in the discriminator. The current duplication
1522 /// factor is as defined by getDuplicationFactor().
1523 /// Returns None if encoding failed.
1524 inline Optional<const DILocation *> cloneByMultiplyingDuplicationFactor(unsigned DF) const;
1525
1526 /// When two instructions are combined into a single instruction we also
1527 /// need to combine the original locations into a single location.
1528 ///
1529 /// When the locations are the same we can use either location. When they
1530 /// differ, we need a third location which is distinct from either. If they
1531 /// have the same file/line but have a different discriminator we could
1532 /// create a location with a new discriminator. If they are from different
1533 /// files/lines the location is ambiguous and can't be represented in a line
1534 /// entry. In this case, if \p GenerateLocation is true, we will set the
1535 /// merged debug location as line 0 of the nearest common scope where the two
1536 /// locations are inlined from.
1537 ///
1538 /// \p GenerateLocation: Whether the merged location can be generated when
1539 /// \p LocA and \p LocB differ.
1540 static const DILocation *getMergedLocation(const DILocation *LocA,
1541 const DILocation *LocB);
1542
1543 /// Returns the base discriminator for a given encoded discriminator \p D.
1544 static unsigned getBaseDiscriminatorFromDiscriminator(unsigned D) {
1545 return getUnsignedFromPrefixEncoding(D);
1546 }
1547
1548 /// Raw encoding of the discriminator. APIs such as cloneWithDuplicationFactor
1549 /// have certain special case behavior (e.g. treating empty duplication factor
1550 /// as the value '1').
1551 /// This API, in conjunction with cloneWithDiscriminator, may be used to encode
1552 /// the raw values provided. \p BD: base discriminator \p DF: duplication factor
1553 /// \p CI: copy index
1554 /// The return is None if the values cannot be encoded in 32 bits - for
1555 /// example, values for BD or DF larger than 12 bits. Otherwise, the return
1556 /// is the encoded value.
1557 static Optional<unsigned> encodeDiscriminator(unsigned BD, unsigned DF, unsigned CI);
1558
1559 /// Raw decoder for values in an encoded discriminator D.
1560 static void decodeDiscriminator(unsigned D, unsigned &BD, unsigned &DF,
1561 unsigned &CI);
1562
1563 /// Returns the duplication factor for a given encoded discriminator \p D, or
1564 /// 1 if no value or 0 is encoded.
1565 static unsigned getDuplicationFactorFromDiscriminator(unsigned D) {
1566 D = getNextComponentInDiscriminator(D);
1567 unsigned Ret = getUnsignedFromPrefixEncoding(D);
1568 if (Ret == 0)
1569 return 1;
1570 return Ret;
1571 }
1572
1573 /// Returns the copy identifier for a given encoded discriminator \p D.
1574 static unsigned getCopyIdentifierFromDiscriminator(unsigned D) {
1575 return getUnsignedFromPrefixEncoding(getNextComponentInDiscriminator(
1576 getNextComponentInDiscriminator(D)));
1577 }
1578
1579
1580 Metadata *getRawScope() const { return getOperand(0); }
1581 Metadata *getRawInlinedAt() const {
1582 if (getNumOperands() == 2)
1583 return getOperand(1);
1584 return nullptr;
1585 }
1586
1587 static bool classof(const Metadata *MD) {
1588 return MD->getMetadataID() == DILocationKind;
1589 }
1590};
1591
1592/// Subprogram description.
1593class DISubprogram : public DILocalScope {
1594 friend class LLVMContextImpl;
1595 friend class MDNode;
1596
1597 unsigned Line;
1598 unsigned ScopeLine;
1599 unsigned VirtualIndex;
1600
1601 /// In the MS ABI, the implicit 'this' parameter is adjusted in the prologue
1602 /// of method overrides from secondary bases by this amount. It may be
1603 /// negative.
1604 int ThisAdjustment;
1605
1606public:
1607 /// Debug info subprogram flags.
1608 enum DISPFlags : uint32_t {
1609#define HANDLE_DISP_FLAG(ID, NAME) SPFlag##NAME = ID,
1610#define DISP_FLAG_LARGEST_NEEDED
1611#include "llvm/IR/DebugInfoFlags.def"
1612 SPFlagNonvirtual = SPFlagZero,
1613 SPFlagVirtuality = SPFlagVirtual | SPFlagPureVirtual,
1614 LLVM_MARK_AS_BITMASK_ENUM(SPFlagLargest)LLVM_BITMASK_LARGEST_ENUMERATOR = SPFlagLargest
1615 };
1616
1617 static DISPFlags getFlag(StringRef Flag);
1618 static StringRef getFlagString(DISPFlags Flag);
1619
1620 /// Split up a flags bitfield for easier printing.
1621 ///
1622 /// Split \c Flags into \c SplitFlags, a vector of its components. Returns
1623 /// any remaining (unrecognized) bits.
1624 static DISPFlags splitFlags(DISPFlags Flags,
1625 SmallVectorImpl<DISPFlags> &SplitFlags);
1626
1627 // Helper for converting old bitfields to new flags word.
1628 static DISPFlags toSPFlags(bool IsLocalToUnit, bool IsDefinition,
1629 bool IsOptimized,
1630 unsigned Virtuality = SPFlagNonvirtual,
1631 bool IsMainSubprogram = false) {
1632 // We're assuming virtuality is the low-order field.
1633 static_assert(
1634 int(SPFlagVirtual) == int(dwarf::DW_VIRTUALITY_virtual) &&
1635 int(SPFlagPureVirtual) == int(dwarf::DW_VIRTUALITY_pure_virtual),
1636 "Virtuality constant mismatch");
1637 return static_cast<DISPFlags>(
1638 (Virtuality & SPFlagVirtuality) |
1639 (IsLocalToUnit ? SPFlagLocalToUnit : SPFlagZero) |
1640 (IsDefinition ? SPFlagDefinition : SPFlagZero) |
1641 (IsOptimized ? SPFlagOptimized : SPFlagZero) |
1642 (IsMainSubprogram ? SPFlagMainSubprogram : SPFlagZero));
1643 }
1644
1645private:
1646 DIFlags Flags;
1647 DISPFlags SPFlags;
1648
1649 DISubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
1650 unsigned ScopeLine, unsigned VirtualIndex, int ThisAdjustment,
1651 DIFlags Flags, DISPFlags SPFlags, ArrayRef<Metadata *> Ops)
1652 : DILocalScope(C, DISubprogramKind, Storage, dwarf::DW_TAG_subprogram,
1653 Ops),
1654 Line(Line), ScopeLine(ScopeLine), VirtualIndex(VirtualIndex),
1655 ThisAdjustment(ThisAdjustment), Flags(Flags), SPFlags(SPFlags) {
1656 static_assert(dwarf::DW_VIRTUALITY_max < 4, "Virtuality out of range");
1657 }
1658 ~DISubprogram() = default;
1659
1660 static DISubprogram *
1661 getImpl(LLVMContext &Context, DIScope *Scope, StringRef Name,
1662 StringRef LinkageName, DIFile *File, unsigned Line,
1663 DISubroutineType *Type, unsigned ScopeLine, DIType *ContainingType,
1664 unsigned VirtualIndex, int ThisAdjustment, DIFlags Flags,
1665 DISPFlags SPFlags, DICompileUnit *Unit,
1666 DITemplateParameterArray TemplateParams, DISubprogram *Declaration,
1667 DINodeArray RetainedNodes, DITypeArray ThrownTypes,
1668 StorageType Storage, bool ShouldCreate = true) {
1669 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
1670 getCanonicalMDString(Context, LinkageName), File, Line, Type,
1671 ScopeLine, ContainingType, VirtualIndex, ThisAdjustment,
1672 Flags, SPFlags, Unit, TemplateParams.get(), Declaration,
1673 RetainedNodes.get(), ThrownTypes.get(), Storage,
1674 ShouldCreate);
1675 }
1676 static DISubprogram *getImpl(LLVMContext &Context, Metadata *Scope,
1677 MDString *Name, MDString *LinkageName,
1678 Metadata *File, unsigned Line, Metadata *Type,
1679 unsigned ScopeLine, Metadata *ContainingType,
1680 unsigned VirtualIndex, int ThisAdjustment,
1681 DIFlags Flags, DISPFlags SPFlags, Metadata *Unit,
1682 Metadata *TemplateParams, Metadata *Declaration,
1683 Metadata *RetainedNodes, Metadata *ThrownTypes,
1684 StorageType Storage, bool ShouldCreate = true);
1685
1686 TempDISubprogram cloneImpl() const {
1687 return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
1688 getFile(), getLine(), getType(), getScopeLine(),
1689 getContainingType(), getVirtualIndex(),
1690 getThisAdjustment(), getFlags(), getSPFlags(),
1691 getUnit(), getTemplateParams(), getDeclaration(),
1692 getRetainedNodes(), getThrownTypes());
1693 }
1694
1695public:
1696 DEFINE_MDNODE_GET(
1697 DISubprogram,
1698 (DIScope * Scope, StringRef Name, StringRef LinkageName, DIFile *File,
1699 unsigned Line, DISubroutineType *Type, unsigned ScopeLine,
1700 DIType *ContainingType, unsigned VirtualIndex, int ThisAdjustment,
1701 DIFlags Flags, DISPFlags SPFlags, DICompileUnit *Unit,
1702 DITemplateParameterArray TemplateParams = nullptr,
1703 DISubprogram *Declaration = nullptr, DINodeArray RetainedNodes = nullptr,
1704 DITypeArray ThrownTypes = nullptr),
1705 (Scope, Name, LinkageName, File, Line, Type, ScopeLine, ContainingType,
1706 VirtualIndex, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams,
1707 Declaration, RetainedNodes, ThrownTypes))
1708
1709 DEFINE_MDNODE_GET(
1710 DISubprogram,
1711 (Metadata * Scope, MDString *Name, MDString *LinkageName, Metadata *File,
1712 unsigned Line, Metadata *Type, unsigned ScopeLine,
1713 Metadata *ContainingType, unsigned VirtualIndex, int ThisAdjustment,
1714 DIFlags Flags, DISPFlags SPFlags, Metadata *Unit,
1715 Metadata *TemplateParams = nullptr, Metadata *Declaration = nullptr,
1716 Metadata *RetainedNodes = nullptr, Metadata *ThrownTypes = nullptr),
1717 (Scope, Name, LinkageName, File, Line, Type, ScopeLine, ContainingType,
1718 VirtualIndex, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams,
1719 Declaration, RetainedNodes, ThrownTypes))
1720
1721 TempDISubprogram clone() const { return cloneImpl(); }
1722
1723 /// Returns a new temporary DISubprogram with updated Flags
1724 TempDISubprogram cloneWithFlags(DIFlags NewFlags) const {
1725 auto NewSP = clone();
1726 NewSP->Flags = NewFlags;
1727 return NewSP;
1728 }
1729
1730public:
1731 unsigned getLine() const { return Line; }
1732 unsigned getVirtuality() const { return getSPFlags() & SPFlagVirtuality; }
1733 unsigned getVirtualIndex() const { return VirtualIndex; }
1734 int getThisAdjustment() const { return ThisAdjustment; }
1735 unsigned getScopeLine() const { return ScopeLine; }
1736 DIFlags getFlags() const { return Flags; }
1737 DISPFlags getSPFlags() const { return SPFlags; }
1738 bool isLocalToUnit() const { return getSPFlags() & SPFlagLocalToUnit; }
1739 bool isDefinition() const { return getSPFlags() & SPFlagDefinition; }
1740 bool isOptimized() const { return getSPFlags() & SPFlagOptimized; }
1741 bool isMainSubprogram() const { return getSPFlags() & SPFlagMainSubprogram; }
1742
1743 bool isArtificial() const { return getFlags() & FlagArtificial; }
1744 bool isPrivate() const {
1745 return (getFlags() & FlagAccessibility) == FlagPrivate;
1746 }
1747 bool isProtected() const {
1748 return (getFlags() & FlagAccessibility) == FlagProtected;
1749 }
1750 bool isPublic() const {
1751 return (getFlags() & FlagAccessibility) == FlagPublic;
1752 }
1753 bool isExplicit() const { return getFlags() & FlagExplicit; }
1754 bool isPrototyped() const { return getFlags() & FlagPrototyped; }
1755 bool areAllCallsDescribed() const {
1756 return getFlags() & FlagAllCallsDescribed;
1757 }
1758 bool isPure() const { return getSPFlags() & SPFlagPure; }
1759 bool isElemental() const { return getSPFlags() & SPFlagElemental; }
1760 bool isRecursive() const { return getSPFlags() & SPFlagRecursive; }
1761 bool isObjCDirect() const { return getSPFlags() & SPFlagObjCDirect; }
1762
1763 /// Check if this is deleted member function.
1764 ///
1765 /// Return true if this subprogram is a C++11 special
1766 /// member function declared deleted.
1767 bool isDeleted() const { return getSPFlags() & SPFlagDeleted; }
1768
1769 /// Check if this is reference-qualified.
1770 ///
1771 /// Return true if this subprogram is a C++11 reference-qualified non-static
1772 /// member function (void foo() &).
1773 bool isLValueReference() const { return getFlags() & FlagLValueReference; }
1774
1775 /// Check if this is rvalue-reference-qualified.
1776 ///
1777 /// Return true if this subprogram is a C++11 rvalue-reference-qualified
1778 /// non-static member function (void foo() &&).
1779 bool isRValueReference() const { return getFlags() & FlagRValueReference; }
1780
1781 /// Check if this is marked as noreturn.
1782 ///
1783 /// Return true if this subprogram is C++11 noreturn or C11 _Noreturn
1784 bool isNoReturn() const { return getFlags() & FlagNoReturn; }
1785
1786 // Check if this routine is a compiler-generated thunk.
1787 //
1788 // Returns true if this subprogram is a thunk generated by the compiler.
1789 bool isThunk() const { return getFlags() & FlagThunk; }
1790
1791 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
1792
1793 StringRef getName() const { return getStringOperand(2); }
1794 StringRef getLinkageName() const { return getStringOperand(3); }
1795
1796 DISubroutineType *getType() const {
1797 return cast_or_null<DISubroutineType>(getRawType());
1798 }
1799 DIType *getContainingType() const {
1800 return cast_or_null<DIType>(getRawContainingType());
1801 }
1802
1803 DICompileUnit *getUnit() const {
1804 return cast_or_null<DICompileUnit>(getRawUnit());
1805 }
1806 void replaceUnit(DICompileUnit *CU) { replaceOperandWith(5, CU); }
1807 DITemplateParameterArray getTemplateParams() const {
1808 return cast_or_null<MDTuple>(getRawTemplateParams());
1809 }
1810 DISubprogram *getDeclaration() const {
1811 return cast_or_null<DISubprogram>(getRawDeclaration());
1812 }
1813 DINodeArray getRetainedNodes() const {
1814 return cast_or_null<MDTuple>(getRawRetainedNodes());
1815 }
1816 DITypeArray getThrownTypes() const {
1817 return cast_or_null<MDTuple>(getRawThrownTypes());
1818 }
1819
1820 Metadata *getRawScope() const { return getOperand(1); }
1821 MDString *getRawName() const { return getOperandAs<MDString>(2); }
1822 MDString *getRawLinkageName() const { return getOperandAs<MDString>(3); }
1823 Metadata *getRawType() const { return getOperand(4); }
1824 Metadata *getRawUnit() const { return getOperand(5); }
1825 Metadata *getRawDeclaration() const { return getOperand(6); }
1826 Metadata *getRawRetainedNodes() const { return getOperand(7); }
1827 Metadata *getRawContainingType() const {
1828 return getNumOperands() > 8 ? getOperandAs<Metadata>(8) : nullptr;
1829 }
1830 Metadata *getRawTemplateParams() const {
1831 return getNumOperands() > 9 ? getOperandAs<Metadata>(9) : nullptr;
1832 }
1833 Metadata *getRawThrownTypes() const {
1834 return getNumOperands() > 10 ? getOperandAs<Metadata>(10) : nullptr;
1835 }
1836
1837 /// Check if this subprogram describes the given function.
1838 ///
1839 /// FIXME: Should this be looking through bitcasts?
1840 bool describes(const Function *F) const;
1841
1842 static bool classof(const Metadata *MD) {
1843 return MD->getMetadataID() == DISubprogramKind;
1844 }
1845};
1846
1847class DILexicalBlockBase : public DILocalScope {
1848protected:
1849 DILexicalBlockBase(LLVMContext &C, unsigned ID, StorageType Storage,
1850 ArrayRef<Metadata *> Ops)
1851 : DILocalScope(C, ID, Storage, dwarf::DW_TAG_lexical_block, Ops) {}
1852 ~DILexicalBlockBase() = default;
1853
1854public:
1855 DILocalScope *getScope() const { return cast<DILocalScope>(getRawScope()); }
1856
1857 Metadata *getRawScope() const { return getOperand(1); }
1858
1859 static bool classof(const Metadata *MD) {
1860 return MD->getMetadataID() == DILexicalBlockKind ||
1861 MD->getMetadataID() == DILexicalBlockFileKind;
1862 }
1863};
1864
1865class DILexicalBlock : public DILexicalBlockBase {
1866 friend class LLVMContextImpl;
1867 friend class MDNode;
1868
1869 unsigned Line;
1870 uint16_t Column;
1871
1872 DILexicalBlock(LLVMContext &C, StorageType Storage, unsigned Line,
1873 unsigned Column, ArrayRef<Metadata *> Ops)
1874 : DILexicalBlockBase(C, DILexicalBlockKind, Storage, Ops), Line(Line),
1875 Column(Column) {
1876 assert(Column < (1u << 16) && "Expected 16-bit column")((Column < (1u << 16) && "Expected 16-bit column"
) ? static_cast<void> (0) : __assert_fail ("Column < (1u << 16) && \"Expected 16-bit column\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include/llvm/IR/DebugInfoMetadata.h"
, 1876, __PRETTY_FUNCTION__))
;
1877 }
1878 ~DILexicalBlock() = default;
1879
1880 static DILexicalBlock *getImpl(LLVMContext &Context, DILocalScope *Scope,
1881 DIFile *File, unsigned Line, unsigned Column,
1882 StorageType Storage,
1883 bool ShouldCreate = true) {
1884 return getImpl(Context, static_cast<Metadata *>(Scope),
1885 static_cast<Metadata *>(File), Line, Column, Storage,
1886 ShouldCreate);
1887 }
1888
1889 static DILexicalBlock *getImpl(LLVMContext &Context, Metadata *Scope,
1890 Metadata *File, unsigned Line, unsigned Column,
1891 StorageType Storage, bool ShouldCreate = true);
1892
1893 TempDILexicalBlock cloneImpl() const {
1894 return getTemporary(getContext(), getScope(), getFile(), getLine(),
1895 getColumn());
1896 }
1897
1898public:
1899 DEFINE_MDNODE_GET(DILexicalBlock, (DILocalScope * Scope, DIFile *File,
1900 unsigned Line, unsigned Column),
1901 (Scope, File, Line, Column))
1902 DEFINE_MDNODE_GET(DILexicalBlock, (Metadata * Scope, Metadata *File,
1903 unsigned Line, unsigned Column),
1904 (Scope, File, Line, Column))
1905
1906 TempDILexicalBlock clone() const { return cloneImpl(); }
1907
1908 unsigned getLine() const { return Line; }
1909 unsigned getColumn() const { return Column; }
1910
1911 static bool classof(const Metadata *MD) {
1912 return MD->getMetadataID() == DILexicalBlockKind;
1913 }
1914};
1915
1916class DILexicalBlockFile : public DILexicalBlockBase {
1917 friend class LLVMContextImpl;
1918 friend class MDNode;
1919
1920 unsigned Discriminator;
1921
1922 DILexicalBlockFile(LLVMContext &C, StorageType Storage,
1923 unsigned Discriminator, ArrayRef<Metadata *> Ops)
1924 : DILexicalBlockBase(C, DILexicalBlockFileKind, Storage, Ops),
1925 Discriminator(Discriminator) {}
1926 ~DILexicalBlockFile() = default;
1927
1928 static DILexicalBlockFile *getImpl(LLVMContext &Context, DILocalScope *Scope,
1929 DIFile *File, unsigned Discriminator,
1930 StorageType Storage,
1931 bool ShouldCreate = true) {
1932 return getImpl(Context, static_cast<Metadata *>(Scope),
1933 static_cast<Metadata *>(File), Discriminator, Storage,
1934 ShouldCreate);
1935 }
1936
1937 static DILexicalBlockFile *getImpl(LLVMContext &Context, Metadata *Scope,
1938 Metadata *File, unsigned Discriminator,
1939 StorageType Storage,
1940 bool ShouldCreate = true);
1941
1942 TempDILexicalBlockFile cloneImpl() const {
1943 return getTemporary(getContext(), getScope(), getFile(),
1944 getDiscriminator());
1945 }
1946
1947public:
1948 DEFINE_MDNODE_GET(DILexicalBlockFile, (DILocalScope * Scope, DIFile *File,
1949 unsigned Discriminator),
1950 (Scope, File, Discriminator))
1951 DEFINE_MDNODE_GET(DILexicalBlockFile,
1952 (Metadata * Scope, Metadata *File, unsigned Discriminator),
1953 (Scope, File, Discriminator))
1954
1955 TempDILexicalBlockFile clone() const { return cloneImpl(); }
1956
1957 // TODO: Remove these once they're gone from DILexicalBlockBase.
1958 unsigned getLine() const = delete;
1959 unsigned getColumn() const = delete;
1960
1961 unsigned getDiscriminator() const { return Discriminator; }
1962
1963 static bool classof(const Metadata *MD) {
1964 return MD->getMetadataID() == DILexicalBlockFileKind;
1965 }
1966};
1967
1968unsigned DILocation::getDiscriminator() const {
1969 if (auto *F = dyn_cast<DILexicalBlockFile>(getScope()))
1970 return F->getDiscriminator();
1971 return 0;
1972}
1973
1974const DILocation *
1975DILocation::cloneWithDiscriminator(unsigned Discriminator) const {
1976 DIScope *Scope = getScope();
1977 // Skip all parent DILexicalBlockFile that already have a discriminator
1978 // assigned. We do not want to have nested DILexicalBlockFiles that have
1979 // mutliple discriminators because only the leaf DILexicalBlockFile's
1980 // dominator will be used.
1981 for (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope);
1982 LBF && LBF->getDiscriminator() != 0;
1983 LBF = dyn_cast<DILexicalBlockFile>(Scope))
1984 Scope = LBF->getScope();
1985 DILexicalBlockFile *NewScope =
1986 DILexicalBlockFile::get(getContext(), Scope, getFile(), Discriminator);
1987 return DILocation::get(getContext(), getLine(), getColumn(), NewScope,
1988 getInlinedAt());
1989}
1990
1991unsigned DILocation::getBaseDiscriminator() const {
1992 return getBaseDiscriminatorFromDiscriminator(getDiscriminator());
1993}
1994
1995unsigned DILocation::getDuplicationFactor() const {
1996 return getDuplicationFactorFromDiscriminator(getDiscriminator());
1997}
1998
1999unsigned DILocation::getCopyIdentifier() const {
2000 return getCopyIdentifierFromDiscriminator(getDiscriminator());
2001}
2002
2003Optional<const DILocation *> DILocation::cloneWithBaseDiscriminator(unsigned D) const {
2004 unsigned BD, DF, CI;
2005 decodeDiscriminator(getDiscriminator(), BD, DF, CI);
2006 if (D == BD)
2007 return this;
2008 if (Optional<unsigned> Encoded = encodeDiscriminator(D, DF, CI))
2009 return cloneWithDiscriminator(*Encoded);
2010 return None;
2011}
2012
2013Optional<const DILocation *> DILocation::cloneByMultiplyingDuplicationFactor(unsigned DF) const {
2014 DF *= getDuplicationFactor();
2015 if (DF <= 1)
2016 return this;
2017
2018 unsigned BD = getBaseDiscriminator();
2019 unsigned CI = getCopyIdentifier();
2020 if (Optional<unsigned> D = encodeDiscriminator(BD, DF, CI))
2021 return cloneWithDiscriminator(*D);
2022 return None;
2023}
2024
2025class DINamespace : public DIScope {
2026 friend class LLVMContextImpl;
2027 friend class MDNode;
2028
2029 unsigned ExportSymbols : 1;
2030
2031 DINamespace(LLVMContext &Context, StorageType Storage, bool ExportSymbols,
2032 ArrayRef<Metadata *> Ops)
2033 : DIScope(Context, DINamespaceKind, Storage, dwarf::DW_TAG_namespace,
2034 Ops),
2035 ExportSymbols(ExportSymbols) {}
2036 ~DINamespace() = default;
2037
2038 static DINamespace *getImpl(LLVMContext &Context, DIScope *Scope,
2039 StringRef Name, bool ExportSymbols,
2040 StorageType Storage, bool ShouldCreate = true) {
2041 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
2042 ExportSymbols, Storage, ShouldCreate);
2043 }
2044 static DINamespace *getImpl(LLVMContext &Context, Metadata *Scope,
2045 MDString *Name, bool ExportSymbols,
2046 StorageType Storage, bool ShouldCreate = true);
2047
2048 TempDINamespace cloneImpl() const {
2049 return getTemporary(getContext(), getScope(), getName(),
2050 getExportSymbols());
2051 }
2052
2053public:
2054 DEFINE_MDNODE_GET(DINamespace,
2055 (DIScope *Scope, StringRef Name, bool ExportSymbols),
2056 (Scope, Name, ExportSymbols))
2057 DEFINE_MDNODE_GET(DINamespace,
2058 (Metadata *Scope, MDString *Name, bool ExportSymbols),
2059 (Scope, Name, ExportSymbols))
2060
2061 TempDINamespace clone() const { return cloneImpl(); }
2062
2063 bool getExportSymbols() const { return ExportSymbols; }
2064 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
2065 StringRef getName() const { return getStringOperand(2); }
2066
2067 Metadata *getRawScope() const { return getOperand(1); }
2068 MDString *getRawName() const { return getOperandAs<MDString>(2); }
2069
2070 static bool classof(const Metadata *MD) {
2071 return MD->getMetadataID() == DINamespaceKind;
2072 }
2073};
2074
2075/// A (clang) module that has been imported by the compile unit.
2076///
2077class DIModule : public DIScope {
2078 friend class LLVMContextImpl;
2079 friend class MDNode;
2080
2081 DIModule(LLVMContext &Context, StorageType Storage, ArrayRef<Metadata *> Ops)
2082 : DIScope(Context, DIModuleKind, Storage, dwarf::DW_TAG_module, Ops) {}
2083 ~DIModule() = default;
2084
2085 static DIModule *getImpl(LLVMContext &Context, DIScope *Scope,
2086 StringRef Name, StringRef ConfigurationMacros,
2087 StringRef IncludePath, StringRef SysRoot,
2088 StorageType Storage, bool ShouldCreate = true) {
2089 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
2090 getCanonicalMDString(Context, ConfigurationMacros),
2091 getCanonicalMDString(Context, IncludePath),
2092 getCanonicalMDString(Context, SysRoot),
2093 Storage, ShouldCreate);
2094 }
2095 static DIModule *getImpl(LLVMContext &Context, Metadata *Scope,
2096 MDString *Name, MDString *ConfigurationMacros,
2097 MDString *IncludePath, MDString *SysRoot,
2098 StorageType Storage, bool ShouldCreate = true);
2099
2100 TempDIModule cloneImpl() const {
2101 return getTemporary(getContext(), getScope(), getName(),
2102 getConfigurationMacros(), getIncludePath(),
2103 getSysRoot());
2104 }
2105
2106public:
2107 DEFINE_MDNODE_GET(DIModule, (DIScope *Scope, StringRef Name,
2108 StringRef ConfigurationMacros, StringRef IncludePath,
2109 StringRef SysRoot),
2110 (Scope, Name, ConfigurationMacros, IncludePath, SysRoot))
2111 DEFINE_MDNODE_GET(DIModule,
2112 (Metadata *Scope, MDString *Name, MDString *ConfigurationMacros,
2113 MDString *IncludePath, MDString *SysRoot),
2114 (Scope, Name, ConfigurationMacros, IncludePath, SysRoot))
2115
2116 TempDIModule clone() const { return cloneImpl(); }
2117
2118 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
2119 StringRef getName() const { return getStringOperand(1); }
2120 StringRef getConfigurationMacros() const { return getStringOperand(2); }
2121 StringRef getIncludePath() const { return getStringOperand(3); }
2122 StringRef getSysRoot() const { return getStringOperand(4); }
2123
2124 Metadata *getRawScope() const { return getOperand(0); }
2125 MDString *getRawName() const { return getOperandAs<MDString>(1); }
2126 MDString *getRawConfigurationMacros() const { return getOperandAs<MDString>(2); }
2127 MDString *getRawIncludePath() const { return getOperandAs<MDString>(3); }
2128 MDString *getRawSysRoot() const { return getOperandAs<MDString>(4); }
2129
2130 static bool classof(const Metadata *MD) {
2131 return MD->getMetadataID() == DIModuleKind;
2132 }
2133};
2134
2135/// Base class for template parameters.
2136class DITemplateParameter : public DINode {
2137protected:
2138 DITemplateParameter(LLVMContext &Context, unsigned ID, StorageType Storage,
2139 unsigned Tag, ArrayRef<Metadata *> Ops)
2140 : DINode(Context, ID, Storage, Tag, Ops) {}
2141 ~DITemplateParameter() = default;
2142
2143public:
2144 StringRef getName() const { return getStringOperand(0); }
2145 DIType *getType() const { return cast_or_null<DIType>(getRawType()); }
2146
2147 MDString *getRawName() const { return getOperandAs<MDString>(0); }
2148 Metadata *getRawType() const { return getOperand(1); }
2149
2150 static bool classof(const Metadata *MD) {
2151 return MD->getMetadataID() == DITemplateTypeParameterKind ||
2152 MD->getMetadataID() == DITemplateValueParameterKind;
2153 }
2154};
2155
2156class DITemplateTypeParameter : public DITemplateParameter {
2157 friend class LLVMContextImpl;
2158 friend class MDNode;
2159
2160 DITemplateTypeParameter(LLVMContext &Context, StorageType Storage,
2161 ArrayRef<Metadata *> Ops)
2162 : DITemplateParameter(Context, DITemplateTypeParameterKind, Storage,
2163 dwarf::DW_TAG_template_type_parameter, Ops) {}
2164 ~DITemplateTypeParameter() = default;
2165
2166 static DITemplateTypeParameter *getImpl(LLVMContext &Context, StringRef Name,
2167 DIType *Type, StorageType Storage,
2168 bool ShouldCreate = true) {
2169 return getImpl(Context, getCanonicalMDString(Context, Name), Type, Storage,
2170 ShouldCreate);
2171 }
2172 static DITemplateTypeParameter *getImpl(LLVMContext &Context, MDString *Name,
2173 Metadata *Type, StorageType Storage,
2174 bool ShouldCreate = true);
2175
2176 TempDITemplateTypeParameter cloneImpl() const {
2177 return getTemporary(getContext(), getName(), getType());
2178 }
2179
2180public:
2181 DEFINE_MDNODE_GET(DITemplateTypeParameter, (StringRef Name, DIType *Type),
2182 (Name, Type))
2183 DEFINE_MDNODE_GET(DITemplateTypeParameter, (MDString * Name, Metadata *Type),
2184 (Name, Type))
2185
2186 TempDITemplateTypeParameter clone() const { return cloneImpl(); }
2187
2188 static bool classof(const Metadata *MD) {
2189 return MD->getMetadataID() == DITemplateTypeParameterKind;
2190 }
2191};
2192
2193class DITemplateValueParameter : public DITemplateParameter {
2194 friend class LLVMContextImpl;
2195 friend class MDNode;
2196
2197 DITemplateValueParameter(LLVMContext &Context, StorageType Storage,
2198 unsigned Tag, ArrayRef<Metadata *> Ops)
2199 : DITemplateParameter(Context, DITemplateValueParameterKind, Storage, Tag,
2200 Ops) {}
2201 ~DITemplateValueParameter() = default;
2202
2203 static DITemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
2204 StringRef Name, DIType *Type,
2205 Metadata *Value, StorageType Storage,
2206 bool ShouldCreate = true) {
2207 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), Type,
2208 Value, Storage, ShouldCreate);
2209 }
2210 static DITemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
2211 MDString *Name, Metadata *Type,
2212 Metadata *Value, StorageType Storage,
2213 bool ShouldCreate = true);
2214
2215 TempDITemplateValueParameter cloneImpl() const {
2216 return getTemporary(getContext(), getTag(), getName(), getType(),
2217 getValue());
2218 }
2219
2220public:
2221 DEFINE_MDNODE_GET(DITemplateValueParameter,
2222 (unsigned Tag, StringRef Name, DIType *Type,
2223 Metadata *Value),
2224 (Tag, Name, Type, Value))
2225 DEFINE_MDNODE_GET(DITemplateValueParameter, (unsigned Tag, MDString *Name,
2226 Metadata *Type, Metadata *Value),
2227 (Tag, Name, Type, Value))
2228
2229 TempDITemplateValueParameter clone() const { return cloneImpl(); }
2230
2231 Metadata *getValue() const { return getOperand(2); }
2232
2233 static bool classof(const Metadata *MD) {
2234 return MD->getMetadataID() == DITemplateValueParameterKind;
2235 }
2236};
2237
2238/// Base class for variables.
2239class DIVariable : public DINode {
2240 unsigned Line;
2241 uint32_t AlignInBits;
2242
2243protected:
2244 DIVariable(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Line,
2245 ArrayRef<Metadata *> Ops, uint32_t AlignInBits = 0)
2246 : DINode(C, ID, Storage, dwarf::DW_TAG_variable, Ops), Line(Line),
2247 AlignInBits(AlignInBits) {}
2248 ~DIVariable() = default;
2249
2250public:
2251 unsigned getLine() const { return Line; }
2252 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
2253 StringRef getName() const { return getStringOperand(1); }
2254 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
2255 DIType *getType() const { return cast_or_null<DIType>(getRawType()); }
2256 uint32_t getAlignInBits() const { return AlignInBits; }
2257 uint32_t getAlignInBytes() const { return getAlignInBits() / CHAR_BIT8; }
2258 /// Determines the size of the variable's type.
2259 Optional<uint64_t> getSizeInBits() const;
2260
2261 /// Return the signedness of this variable's type, or None if this type is
2262 /// neither signed nor unsigned.
2263 Optional<DIBasicType::Signedness> getSignedness() const {
2264 if (auto *BT = dyn_cast<DIBasicType>(getType()))
2265 return BT->getSignedness();
2266 return None;
2267 }
2268
2269 StringRef getFilename() const {
2270 if (auto *F = getFile())
2271 return F->getFilename();
2272 return "";
2273 }
2274
2275 StringRef getDirectory() const {
2276 if (auto *F = getFile())
2277 return F->getDirectory();
2278 return "";
2279 }
2280
2281 Optional<StringRef> getSource() const {
2282 if (auto *F = getFile())
2283 return F->getSource();
2284 return None;
2285 }
2286
2287 Metadata *getRawScope() const { return getOperand(0); }
2288 MDString *getRawName() const { return getOperandAs<MDString>(1); }
2289 Metadata *getRawFile() const { return getOperand(2); }
2290 Metadata *getRawType() const { return getOperand(3); }
2291
2292 static bool classof(const Metadata *MD) {
2293 return MD->getMetadataID() == DILocalVariableKind ||
2294 MD->getMetadataID() == DIGlobalVariableKind;
2295 }
2296};
2297
2298/// DWARF expression.
2299///
2300/// This is (almost) a DWARF expression that modifies the location of a
2301/// variable, or the location of a single piece of a variable, or (when using
2302/// DW_OP_stack_value) is the constant variable value.
2303///
2304/// TODO: Co-allocate the expression elements.
2305/// TODO: Separate from MDNode, or otherwise drop Distinct and Temporary
2306/// storage types.
2307class DIExpression : public MDNode {
2308 friend class LLVMContextImpl;
2309 friend class MDNode;
2310
2311 std::vector<uint64_t> Elements;
2312
2313 DIExpression(LLVMContext &C, StorageType Storage, ArrayRef<uint64_t> Elements)
2314 : MDNode(C, DIExpressionKind, Storage, None),
2315 Elements(Elements.begin(), Elements.end()) {}
2316 ~DIExpression() = default;
2317
2318 static DIExpression *getImpl(LLVMContext &Context,
2319 ArrayRef<uint64_t> Elements, StorageType Storage,
2320 bool ShouldCreate = true);
2321
2322 TempDIExpression cloneImpl() const {
2323 return getTemporary(getContext(), getElements());
2324 }
2325
2326public:
2327 DEFINE_MDNODE_GET(DIExpression, (ArrayRef<uint64_t> Elements), (Elements))
2328
2329 TempDIExpression clone() const { return cloneImpl(); }
2330
2331 ArrayRef<uint64_t> getElements() const { return Elements; }
2332
2333 unsigned getNumElements() const { return Elements.size(); }
2334
2335 uint64_t getElement(unsigned I) const {
2336 assert(I < Elements.size() && "Index out of range")((I < Elements.size() && "Index out of range") ? static_cast
<void> (0) : __assert_fail ("I < Elements.size() && \"Index out of range\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include/llvm/IR/DebugInfoMetadata.h"
, 2336, __PRETTY_FUNCTION__))
;
2337 return Elements[I];
2338 }
2339
2340 /// Determine whether this represents a standalone constant value.
2341 bool isConstant() const;
2342
2343 using element_iterator = ArrayRef<uint64_t>::iterator;
2344
2345 element_iterator elements_begin() const { return getElements().begin(); }
2346 element_iterator elements_end() const { return getElements().end(); }
2347
2348 /// A lightweight wrapper around an expression operand.
2349 ///
2350 /// TODO: Store arguments directly and change \a DIExpression to store a
2351 /// range of these.
2352 class ExprOperand {
2353 const uint64_t *Op = nullptr;
2354
2355 public:
2356 ExprOperand() = default;
2357 explicit ExprOperand(const uint64_t *Op) : Op(Op) {}
2358
2359 const uint64_t *get() const { return Op; }
2360
2361 /// Get the operand code.
2362 uint64_t getOp() const { return *Op; }
2363
2364 /// Get an argument to the operand.
2365 ///
2366 /// Never returns the operand itself.
2367 uint64_t getArg(unsigned I) const { return Op[I + 1]; }
2368
2369 unsigned getNumArgs() const { return getSize() - 1; }
2370
2371 /// Return the size of the operand.
2372 ///
2373 /// Return the number of elements in the operand (1 + args).
2374 unsigned getSize() const;
2375
2376 /// Append the elements of this operand to \p V.
2377 void appendToVector(SmallVectorImpl<uint64_t> &V) const {
2378 V.append(get(), get() + getSize());
2379 }
2380 };
2381
2382 /// An iterator for expression operands.
2383 class expr_op_iterator
2384 : public std::iterator<std::input_iterator_tag, ExprOperand> {
2385 ExprOperand Op;
2386
2387 public:
2388 expr_op_iterator() = default;
2389 explicit expr_op_iterator(element_iterator I) : Op(I) {}
2390
2391 element_iterator getBase() const { return Op.get(); }
2392 const ExprOperand &operator*() const { return Op; }
2393 const ExprOperand *operator->() const { return &Op; }
2394
2395 expr_op_iterator &operator++() {
2396 increment();
2397 return *this;
2398 }
2399 expr_op_iterator operator++(int) {
2400 expr_op_iterator T(*this);
2401 increment();
2402 return T;
2403 }
2404
2405 /// Get the next iterator.
2406 ///
2407 /// \a std::next() doesn't work because this is technically an
2408 /// input_iterator, but it's a perfectly valid operation. This is an
2409 /// accessor to provide the same functionality.
2410 expr_op_iterator getNext() const { return ++expr_op_iterator(*this); }
2411
2412 bool operator==(const expr_op_iterator &X) const {
2413 return getBase() == X.getBase();
2414 }
2415 bool operator!=(const expr_op_iterator &X) const {
2416 return getBase() != X.getBase();
2417 }
2418
2419 private:
2420 void increment() { Op = ExprOperand(getBase() + Op.getSize()); }
2421 };
2422
2423 /// Visit the elements via ExprOperand wrappers.
2424 ///
2425 /// These range iterators visit elements through \a ExprOperand wrappers.
2426 /// This is not guaranteed to be a valid range unless \a isValid() gives \c
2427 /// true.
2428 ///
2429 /// \pre \a isValid() gives \c true.
2430 /// @{
2431 expr_op_iterator expr_op_begin() const {
2432 return expr_op_iterator(elements_begin());
2433 }
2434 expr_op_iterator expr_op_end() const {
2435 return expr_op_iterator(elements_end());
2436 }
2437 iterator_range<expr_op_iterator> expr_ops() const {
2438 return {expr_op_begin(), expr_op_end()};
2439 }
2440 /// @}
2441
2442 bool isValid() const;
2443
2444 static bool classof(const Metadata *MD) {
2445 return MD->getMetadataID() == DIExpressionKind;
2446 }
2447
2448 /// Return whether the first element a DW_OP_deref.
2449 bool startsWithDeref() const {
2450 return getNumElements() > 0 && getElement(0) == dwarf::DW_OP_deref;
2451 }
2452
2453 /// Holds the characteristics of one fragment of a larger variable.
2454 struct FragmentInfo {
2455 uint64_t SizeInBits;
2456 uint64_t OffsetInBits;
2457 };
2458
2459 /// Retrieve the details of this fragment expression.
2460 static Optional<FragmentInfo> getFragmentInfo(expr_op_iterator Start,
2461 expr_op_iterator End);
2462
2463 /// Retrieve the details of this fragment expression.
2464 Optional<FragmentInfo> getFragmentInfo() const {
2465 return getFragmentInfo(expr_op_begin(), expr_op_end());
2466 }
2467
2468 /// Return whether this is a piece of an aggregate variable.
2469 bool isFragment() const { return getFragmentInfo().hasValue(); }
2470
2471 /// Return whether this is an implicit location description.
2472 bool isImplicit() const;
2473
2474 /// Return whether the location is computed on the expression stack, meaning
2475 /// it cannot be a simple register location.
2476 bool isComplex() const;
2477
2478 /// Append \p Ops with operations to apply the \p Offset.
2479 static void appendOffset(SmallVectorImpl<uint64_t> &Ops, int64_t Offset);
2480
2481 /// If this is a constant offset, extract it. If there is no expression,
2482 /// return true with an offset of zero.
2483 bool extractIfOffset(int64_t &Offset) const;
2484
2485 /// Checks if the last 4 elements of the expression are DW_OP_constu <DWARF
2486 /// Address Space> DW_OP_swap DW_OP_xderef and extracts the <DWARF Address
2487 /// Space>.
2488 static const DIExpression *extractAddressClass(const DIExpression *Expr,
2489 unsigned &AddrClass);
2490
2491 /// Used for DIExpression::prepend.
2492 enum PrependOps : uint8_t {
2493 ApplyOffset = 0,
2494 DerefBefore = 1 << 0,
2495 DerefAfter = 1 << 1,
2496 StackValue = 1 << 2,
2497 EntryValue = 1 << 3
2498 };
2499
2500 /// Prepend \p DIExpr with a deref and offset operation and optionally turn it
2501 /// into a stack value or/and an entry value.
2502 static DIExpression *prepend(const DIExpression *Expr, uint8_t Flags,
2503 int64_t Offset = 0);
2504
2505 /// Prepend \p DIExpr with the given opcodes and optionally turn it into a
2506 /// stack value.
2507 static DIExpression *prependOpcodes(const DIExpression *Expr,
2508 SmallVectorImpl<uint64_t> &Ops,
2509 bool StackValue = false,
2510 bool EntryValue = false);
2511
2512 /// Append the opcodes \p Ops to \p DIExpr. Unlike \ref appendToStack, the
2513 /// returned expression is a stack value only if \p DIExpr is a stack value.
2514 /// If \p DIExpr describes a fragment, the returned expression will describe
2515 /// the same fragment.
2516 static DIExpression *append(const DIExpression *Expr, ArrayRef<uint64_t> Ops);
2517
2518 /// Convert \p DIExpr into a stack value if it isn't one already by appending
2519 /// DW_OP_deref if needed, and appending \p Ops to the resulting expression.
2520 /// If \p DIExpr describes a fragment, the returned expression will describe
2521 /// the same fragment.
2522 static DIExpression *appendToStack(const DIExpression *Expr,
2523 ArrayRef<uint64_t> Ops);
2524
2525 /// Create a DIExpression to describe one part of an aggregate variable that
2526 /// is fragmented across multiple Values. The DW_OP_LLVM_fragment operation
2527 /// will be appended to the elements of \c Expr. If \c Expr already contains
2528 /// a \c DW_OP_LLVM_fragment \c OffsetInBits is interpreted as an offset
2529 /// into the existing fragment.
2530 ///
2531 /// \param OffsetInBits Offset of the piece in bits.
2532 /// \param SizeInBits Size of the piece in bits.
2533 /// \return Creating a fragment expression may fail if \c Expr
2534 /// contains arithmetic operations that would be truncated.
2535 static Optional<DIExpression *>
2536 createFragmentExpression(const DIExpression *Expr, unsigned OffsetInBits,
2537 unsigned SizeInBits);
2538
2539 /// Determine the relative position of the fragments passed in.
2540 /// Returns -1 if this is entirely before Other, 0 if this and Other overlap,
2541 /// 1 if this is entirely after Other.
2542 static int fragmentCmp(const FragmentInfo &A, const FragmentInfo &B) {
2543 uint64_t l1 = A.OffsetInBits;
2544 uint64_t l2 = B.OffsetInBits;
2545 uint64_t r1 = l1 + A.SizeInBits;
2546 uint64_t r2 = l2 + B.SizeInBits;
2547 if (r1 <= l2)
2548 return -1;
2549 else if (r2 <= l1)
2550 return 1;
2551 else
2552 return 0;
2553 }
2554
2555 using ExtOps = std::array<uint64_t, 6>;
2556
2557 /// Returns the ops for a zero- or sign-extension in a DIExpression.
2558 static ExtOps getExtOps(unsigned FromSize, unsigned ToSize, bool Signed);
2559
2560 /// Append a zero- or sign-extension to \p Expr. Converts the expression to a
2561 /// stack value if it isn't one already.
2562 static DIExpression *appendExt(const DIExpression *Expr, unsigned FromSize,
2563 unsigned ToSize, bool Signed);
2564
2565 /// Check if fragments overlap between a pair of FragmentInfos.
2566 static bool fragmentsOverlap(const FragmentInfo &A, const FragmentInfo &B) {
2567 return fragmentCmp(A, B) == 0;
2568 }
2569
2570 /// Determine the relative position of the fragments described by this
2571 /// DIExpression and \p Other. Calls static fragmentCmp implementation.
2572 int fragmentCmp(const DIExpression *Other) const {
2573 auto Fragment1 = *getFragmentInfo();
2574 auto Fragment2 = *Other->getFragmentInfo();
2575 return fragmentCmp(Fragment1, Fragment2);
2576 }
2577
2578 /// Check if fragments overlap between this DIExpression and \p Other.
2579 bool fragmentsOverlap(const DIExpression *Other) const {
2580 if (!isFragment() || !Other->isFragment())
2581 return true;
2582 return fragmentCmp(Other) == 0;
2583 }
2584
2585 /// Check if the expression consists of exactly one entry value operand.
2586 /// (This is the only configuration of entry values that is supported.)
2587 bool isEntryValue() const {
2588 return getNumElements() > 0 &&
2589 getElement(0) == dwarf::DW_OP_LLVM_entry_value;
2590 }
2591};
2592
2593inline bool operator==(const DIExpression::FragmentInfo &A,
2594 const DIExpression::FragmentInfo &B) {
2595 return std::tie(A.SizeInBits, A.OffsetInBits) ==
2596 std::tie(B.SizeInBits, B.OffsetInBits);
2597}
2598
2599inline bool operator<(const DIExpression::FragmentInfo &A,
2600 const DIExpression::FragmentInfo &B) {
2601 return std::tie(A.SizeInBits, A.OffsetInBits) <
2602 std::tie(B.SizeInBits, B.OffsetInBits);
2603}
2604
2605template <> struct DenseMapInfo<DIExpression::FragmentInfo> {
2606 using FragInfo = DIExpression::FragmentInfo;
2607 static const uint64_t MaxVal = std::numeric_limits<uint64_t>::max();
2608
2609 static inline FragInfo getEmptyKey() { return {MaxVal, MaxVal}; }
2610
2611 static inline FragInfo getTombstoneKey() { return {MaxVal - 1, MaxVal - 1}; }
2612
2613 static unsigned getHashValue(const FragInfo &Frag) {
2614 return (Frag.SizeInBits & 0xffff) << 16 | (Frag.OffsetInBits & 0xffff);
2615 }
2616
2617 static bool isEqual(const FragInfo &A, const FragInfo &B) { return A == B; }
2618};
2619
2620/// Global variables.
2621///
2622/// TODO: Remove DisplayName. It's always equal to Name.
2623class DIGlobalVariable : public DIVariable {
2624 friend class LLVMContextImpl;
2625 friend class MDNode;
2626
2627 bool IsLocalToUnit;
2628 bool IsDefinition;
2629
2630 DIGlobalVariable(LLVMContext &C, StorageType Storage, unsigned Line,
2631 bool IsLocalToUnit, bool IsDefinition, uint32_t AlignInBits,
2632 ArrayRef<Metadata *> Ops)
2633 : DIVariable(C, DIGlobalVariableKind, Storage, Line, Ops, AlignInBits),
2634 IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition) {}
2635 ~DIGlobalVariable() = default;
2636
2637 static DIGlobalVariable *
2638 getImpl(LLVMContext &Context, DIScope *Scope, StringRef Name,
2639 StringRef LinkageName, DIFile *File, unsigned Line, DIType *Type,
2640 bool IsLocalToUnit, bool IsDefinition,
2641 DIDerivedType *StaticDataMemberDeclaration, MDTuple *TemplateParams,
2642 uint32_t AlignInBits, StorageType Storage, bool ShouldCreate = true) {
2643 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
2644 getCanonicalMDString(Context, LinkageName), File, Line, Type,
2645 IsLocalToUnit, IsDefinition, StaticDataMemberDeclaration,
2646 cast_or_null<Metadata>(TemplateParams), AlignInBits, Storage,
2647 ShouldCreate);
2648 }
2649 static DIGlobalVariable *
2650 getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
2651 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
2652 bool IsLocalToUnit, bool IsDefinition,
2653 Metadata *StaticDataMemberDeclaration, Metadata *TemplateParams,
2654 uint32_t AlignInBits, StorageType Storage, bool ShouldCreate = true);
2655
2656 TempDIGlobalVariable cloneImpl() const {
2657 return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
2658 getFile(), getLine(), getType(), isLocalToUnit(),
2659 isDefinition(), getStaticDataMemberDeclaration(),
2660 getTemplateParams(), getAlignInBits());
2661 }
2662
2663public:
2664 DEFINE_MDNODE_GET(DIGlobalVariable,
2665 (DIScope * Scope, StringRef Name, StringRef LinkageName,
2666 DIFile *File, unsigned Line, DIType *Type,
2667 bool IsLocalToUnit, bool IsDefinition,
2668 DIDerivedType *StaticDataMemberDeclaration,
2669 MDTuple *TemplateParams, uint32_t AlignInBits),
2670 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
2671 IsDefinition, StaticDataMemberDeclaration, TemplateParams,
2672 AlignInBits))
2673 DEFINE_MDNODE_GET(DIGlobalVariable,
2674 (Metadata * Scope, MDString *Name, MDString *LinkageName,
2675 Metadata *File, unsigned Line, Metadata *Type,
2676 bool IsLocalToUnit, bool IsDefinition,
2677 Metadata *StaticDataMemberDeclaration,
2678 Metadata *TemplateParams, uint32_t AlignInBits),
2679 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
2680 IsDefinition, StaticDataMemberDeclaration, TemplateParams,
2681 AlignInBits))
2682
2683 TempDIGlobalVariable clone() const { return cloneImpl(); }
2684
2685 bool isLocalToUnit() const { return IsLocalToUnit; }
2686 bool isDefinition() const { return IsDefinition; }
2687 StringRef getDisplayName() const { return getStringOperand(4); }
2688 StringRef getLinkageName() const { return getStringOperand(5); }
2689 DIDerivedType *getStaticDataMemberDeclaration() const {
2690 return cast_or_null<DIDerivedType>(getRawStaticDataMemberDeclaration());
2691 }
2692
2693 MDString *getRawLinkageName() const { return getOperandAs<MDString>(5); }
2694 Metadata *getRawStaticDataMemberDeclaration() const { return getOperand(6); }
2695 Metadata *getRawTemplateParams() const { return getOperand(7); }
2696 MDTuple *getTemplateParams() const { return getOperandAs<MDTuple>(7); }
2697
2698 static bool classof(const Metadata *MD) {
2699 return MD->getMetadataID() == DIGlobalVariableKind;
2700 }
2701};
2702
2703class DICommonBlock : public DIScope {
2704 unsigned LineNo;
2705
2706 friend class LLVMContextImpl;
2707 friend class MDNode;
2708
2709 DICommonBlock(LLVMContext &Context, StorageType Storage, unsigned LineNo,
2710 ArrayRef<Metadata *> Ops)
2711 : DIScope(Context, DICommonBlockKind, Storage, dwarf::DW_TAG_common_block,
2712 Ops), LineNo(LineNo) {}
2713
2714 static DICommonBlock *getImpl(LLVMContext &Context, DIScope *Scope,
2715 DIGlobalVariable *Decl, StringRef Name,
2716 DIFile *File, unsigned LineNo,
2717 StorageType Storage,
2718 bool ShouldCreate = true) {
2719 return getImpl(Context, Scope, Decl, getCanonicalMDString(Context, Name),
2720 File, LineNo, Storage, ShouldCreate);
2721 }
2722 static DICommonBlock *getImpl(LLVMContext &Context, Metadata *Scope,
2723 Metadata *Decl, MDString *Name, Metadata *File,
2724 unsigned LineNo,
2725 StorageType Storage, bool ShouldCreate = true);
2726
2727 TempDICommonBlock cloneImpl() const {
2728 return getTemporary(getContext(), getScope(), getDecl(), getName(),
2729 getFile(), getLineNo());
2730 }
2731
2732public:
2733 DEFINE_MDNODE_GET(DICommonBlock,
2734 (DIScope *Scope, DIGlobalVariable *Decl, StringRef Name,
2735 DIFile *File, unsigned LineNo),
2736 (Scope, Decl, Name, File, LineNo))
2737 DEFINE_MDNODE_GET(DICommonBlock,
2738 (Metadata *Scope, Metadata *Decl, MDString *Name,
2739 Metadata *File, unsigned LineNo),
2740 (Scope, Decl, Name, File, LineNo))
2741
2742 TempDICommonBlock clone() const { return cloneImpl(); }
2743
2744 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
2745 DIGlobalVariable *getDecl() const {
2746 return cast_or_null<DIGlobalVariable>(getRawDecl());
2747 }
2748 StringRef getName() const { return getStringOperand(2); }
2749 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
2750 unsigned getLineNo() const { return LineNo; }
2751
2752 Metadata *getRawScope() const { return getOperand(0); }
2753 Metadata *getRawDecl() const { return getOperand(1); }
2754 MDString *getRawName() const { return getOperandAs<MDString>(2); }
2755 Metadata *getRawFile() const { return getOperand(3); }
2756
2757 static bool classof(const Metadata *MD) {
2758 return MD->getMetadataID() == DICommonBlockKind;
2759 }
2760};
2761
2762/// Local variable.
2763///
2764/// TODO: Split up flags.
2765class DILocalVariable : public DIVariable {
2766 friend class LLVMContextImpl;
2767 friend class MDNode;
2768
2769 unsigned Arg : 16;
2770 DIFlags Flags;
2771
2772 DILocalVariable(LLVMContext &C, StorageType Storage, unsigned Line,
2773 unsigned Arg, DIFlags Flags, uint32_t AlignInBits,
2774 ArrayRef<Metadata *> Ops)
2775 : DIVariable(C, DILocalVariableKind, Storage, Line, Ops, AlignInBits),
2776 Arg(Arg), Flags(Flags) {
2777 assert(Arg < (1 << 16) && "DILocalVariable: Arg out of range")((Arg < (1 << 16) && "DILocalVariable: Arg out of range"
) ? static_cast<void> (0) : __assert_fail ("Arg < (1 << 16) && \"DILocalVariable: Arg out of range\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include/llvm/IR/DebugInfoMetadata.h"
, 2777, __PRETTY_FUNCTION__))
;
2778 }
2779 ~DILocalVariable() = default;
2780
2781 static DILocalVariable *getImpl(LLVMContext &Context, DIScope *Scope,
2782 StringRef Name, DIFile *File, unsigned Line,
2783 DIType *Type, unsigned Arg, DIFlags Flags,
2784 uint32_t AlignInBits, StorageType Storage,
2785 bool ShouldCreate = true) {
2786 return getImpl(Context, Scope, getCanonicalMDString(Context, Name), File,
2787 Line, Type, Arg, Flags, AlignInBits, Storage, ShouldCreate);
2788 }
2789 static DILocalVariable *getImpl(LLVMContext &Context, Metadata *Scope,
2790 MDString *Name, Metadata *File, unsigned Line,
2791 Metadata *Type, unsigned Arg, DIFlags Flags,
2792 uint32_t AlignInBits, StorageType Storage,
2793 bool ShouldCreate = true);
2794
2795 TempDILocalVariable cloneImpl() const {
2796 return getTemporary(getContext(), getScope(), getName(), getFile(),
2797 getLine(), getType(), getArg(), getFlags(),
2798 getAlignInBits());
2799 }
2800
2801public:
2802 DEFINE_MDNODE_GET(DILocalVariable,
2803 (DILocalScope * Scope, StringRef Name, DIFile *File,
2804 unsigned Line, DIType *Type, unsigned Arg, DIFlags Flags,
2805 uint32_t AlignInBits),
2806 (Scope, Name, File, Line, Type, Arg, Flags, AlignInBits))
2807 DEFINE_MDNODE_GET(DILocalVariable,
2808 (Metadata * Scope, MDString *Name, Metadata *File,
2809 unsigned Line, Metadata *Type, unsigned Arg,
2810 DIFlags Flags, uint32_t AlignInBits),
2811 (Scope, Name, File, Line, Type, Arg, Flags, AlignInBits))
2812
2813 TempDILocalVariable clone() const { return cloneImpl(); }
2814
2815 /// Get the local scope for this variable.
2816 ///
2817 /// Variables must be defined in a local scope.
2818 DILocalScope *getScope() const {
2819 return cast<DILocalScope>(DIVariable::getScope());
2820 }
2821
2822 bool isParameter() const { return Arg; }
2823 unsigned getArg() const { return Arg; }
2824 DIFlags getFlags() const { return Flags; }
2825
2826 bool isArtificial() const { return getFlags() & FlagArtificial; }
2827 bool isObjectPointer() const { return getFlags() & FlagObjectPointer; }
2828
2829 /// Check that a location is valid for this variable.
2830 ///
2831 /// Check that \c DL exists, is in the same subprogram, and has the same
2832 /// inlined-at location as \c this. (Otherwise, it's not a valid attachment
2833 /// to a \a DbgInfoIntrinsic.)
2834 bool isValidLocationForIntrinsic(const DILocation *DL) const {
2835 return DL && getScope()->getSubprogram() == DL->getScope()->getSubprogram();
2836 }
2837
2838 static bool classof(const Metadata *MD) {
2839 return MD->getMetadataID() == DILocalVariableKind;
2840 }
2841};
2842
2843/// Label.
2844///
2845class DILabel : public DINode {
2846 friend class LLVMContextImpl;
2847 friend class MDNode;
2848
2849 unsigned Line;
2850
2851 DILabel(LLVMContext &C, StorageType Storage, unsigned Line,
2852 ArrayRef<Metadata *> Ops)
2853 : DINode(C, DILabelKind, Storage, dwarf::DW_TAG_label, Ops), Line(Line) {}
2854 ~DILabel() = default;
2855
2856 static DILabel *getImpl(LLVMContext &Context, DIScope *Scope,
2857 StringRef Name, DIFile *File, unsigned Line,
2858 StorageType Storage,
2859 bool ShouldCreate = true) {
2860 return getImpl(Context, Scope, getCanonicalMDString(Context, Name), File,
2861 Line, Storage, ShouldCreate);
2862 }
2863 static DILabel *getImpl(LLVMContext &Context, Metadata *Scope,
2864 MDString *Name, Metadata *File, unsigned Line,
2865 StorageType Storage,
2866 bool ShouldCreate = true);
2867
2868 TempDILabel cloneImpl() const {
2869 return getTemporary(getContext(), getScope(), getName(), getFile(),
2870 getLine());
2871 }
2872
2873public:
2874 DEFINE_MDNODE_GET(DILabel,
2875 (DILocalScope * Scope, StringRef Name, DIFile *File,
2876 unsigned Line),
2877 (Scope, Name, File, Line))
2878 DEFINE_MDNODE_GET(DILabel,
2879 (Metadata * Scope, MDString *Name, Metadata *File,
2880 unsigned Line),
2881 (Scope, Name, File, Line))
2882
2883 TempDILabel clone() const { return cloneImpl(); }
2884
2885 /// Get the local scope for this label.
2886 ///
2887 /// Labels must be defined in a local scope.
2888 DILocalScope *getScope() const {
2889 return cast_or_null<DILocalScope>(getRawScope());
2890 }
2891 unsigned getLine() const { return Line; }
2892 StringRef getName() const { return getStringOperand(1); }
2893 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
2894
2895 Metadata *getRawScope() const { return getOperand(0); }
2896 MDString *getRawName() const { return getOperandAs<MDString>(1); }
2897 Metadata *getRawFile() const { return getOperand(2); }
2898
2899 /// Check that a location is valid for this label.
2900 ///
2901 /// Check that \c DL exists, is in the same subprogram, and has the same
2902 /// inlined-at location as \c this. (Otherwise, it's not a valid attachment
2903 /// to a \a DbgInfoIntrinsic.)
2904 bool isValidLocationForIntrinsic(const DILocation *DL) const {
2905 return DL && getScope()->getSubprogram() == DL->getScope()->getSubprogram();
2906 }
2907
2908 static bool classof(const Metadata *MD) {
2909 return MD->getMetadataID() == DILabelKind;
2910 }
2911};
2912
2913class DIObjCProperty : public DINode {
2914 friend class LLVMContextImpl;
2915 friend class MDNode;
2916
2917 unsigned Line;
2918 unsigned Attributes;
2919
2920 DIObjCProperty(LLVMContext &C, StorageType Storage, unsigned Line,
2921 unsigned Attributes, ArrayRef<Metadata *> Ops)
2922 : DINode(C, DIObjCPropertyKind, Storage, dwarf::DW_TAG_APPLE_property,
2923 Ops),
2924 Line(Line), Attributes(Attributes) {}
2925 ~DIObjCProperty() = default;
2926
2927 static DIObjCProperty *
2928 getImpl(LLVMContext &Context, StringRef Name, DIFile *File, unsigned Line,
2929 StringRef GetterName, StringRef SetterName, unsigned Attributes,
2930 DIType *Type, StorageType Storage, bool ShouldCreate = true) {
2931 return getImpl(Context, getCanonicalMDString(Context, Name), File, Line,
2932 getCanonicalMDString(Context, GetterName),
2933 getCanonicalMDString(Context, SetterName), Attributes, Type,
2934 Storage, ShouldCreate);
2935 }
2936 static DIObjCProperty *getImpl(LLVMContext &Context, MDString *Name,
2937 Metadata *File, unsigned Line,
2938 MDString *GetterName, MDString *SetterName,
2939 unsigned Attributes, Metadata *Type,
2940 StorageType Storage, bool ShouldCreate = true);
2941
2942 TempDIObjCProperty cloneImpl() const {
2943 return getTemporary(getContext(), getName(), getFile(), getLine(),
2944 getGetterName(), getSetterName(), getAttributes(),
2945 getType());
2946 }
2947
2948public:
2949 DEFINE_MDNODE_GET(DIObjCProperty,
2950 (StringRef Name, DIFile *File, unsigned Line,
2951 StringRef GetterName, StringRef SetterName,
2952 unsigned Attributes, DIType *Type),
2953 (Name, File, Line, GetterName, SetterName, Attributes,
2954 Type))
2955 DEFINE_MDNODE_GET(DIObjCProperty,
2956 (MDString * Name, Metadata *File, unsigned Line,
2957 MDString *GetterName, MDString *SetterName,
2958 unsigned Attributes, Metadata *Type),
2959 (Name, File, Line, GetterName, SetterName, Attributes,
2960 Type))
2961
2962 TempDIObjCProperty clone() const { return cloneImpl(); }
2963
2964 unsigned getLine() const { return Line; }
2965 unsigned getAttributes() const { return Attributes; }
2966 StringRef getName() const { return getStringOperand(0); }
2967 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
2968 StringRef getGetterName() const { return getStringOperand(2); }
2969 StringRef getSetterName() const { return getStringOperand(3); }
2970 DIType *getType() const { return cast_or_null<DIType>(getRawType()); }
2971
2972 StringRef getFilename() const {
2973 if (auto *F = getFile())
2974 return F->getFilename();
2975 return "";
2976 }
2977
2978 StringRef getDirectory() const {
2979 if (auto *F = getFile())
2980 return F->getDirectory();
2981 return "";
2982 }
2983
2984 Optional<StringRef> getSource() const {
2985 if (auto *F = getFile())
2986 return F->getSource();
2987 return None;
2988 }
2989
2990 MDString *getRawName() const { return getOperandAs<MDString>(0); }
2991 Metadata *getRawFile() const { return getOperand(1); }
2992 MDString *getRawGetterName() const { return getOperandAs<MDString>(2); }
2993 MDString *getRawSetterName() const { return getOperandAs<MDString>(3); }
2994 Metadata *getRawType() const { return getOperand(4); }
2995
2996 static bool classof(const Metadata *MD) {
2997 return MD->getMetadataID() == DIObjCPropertyKind;
2998 }
2999};
3000
3001/// An imported module (C++ using directive or similar).
3002class DIImportedEntity : public DINode {
3003 friend class LLVMContextImpl;
3004 friend class MDNode;
3005
3006 unsigned Line;
3007
3008 DIImportedEntity(LLVMContext &C, StorageType Storage, unsigned Tag,
3009 unsigned Line, ArrayRef<Metadata *> Ops)
3010 : DINode(C, DIImportedEntityKind, Storage, Tag, Ops), Line(Line) {}
3011 ~DIImportedEntity() = default;
3012
3013 static DIImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
3014 DIScope *Scope, DINode *Entity, DIFile *File,
3015 unsigned Line, StringRef Name,
3016 StorageType Storage,
3017 bool ShouldCreate = true) {
3018 return getImpl(Context, Tag, Scope, Entity, File, Line,
3019 getCanonicalMDString(Context, Name), Storage, ShouldCreate);
3020 }
3021 static DIImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
3022 Metadata *Scope, Metadata *Entity,
3023 Metadata *File, unsigned Line,
3024 MDString *Name, StorageType Storage,
3025 bool ShouldCreate = true);
3026
3027 TempDIImportedEntity cloneImpl() const {
3028 return getTemporary(getContext(), getTag(), getScope(), getEntity(),
3029 getFile(), getLine(), getName());
3030 }
3031
3032public:
3033 DEFINE_MDNODE_GET(DIImportedEntity,
3034 (unsigned Tag, DIScope *Scope, DINode *Entity, DIFile *File,
3035 unsigned Line, StringRef Name = ""),
3036 (Tag, Scope, Entity, File, Line, Name))
3037 DEFINE_MDNODE_GET(DIImportedEntity,
3038 (unsigned Tag, Metadata *Scope, Metadata *Entity,
3039 Metadata *File, unsigned Line, MDString *Name),
3040 (Tag, Scope, Entity, File, Line, Name))
3041
3042 TempDIImportedEntity clone() const { return cloneImpl(); }
3043
3044 unsigned getLine() const { return Line; }
3045 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
3046 DINode *getEntity() const { return cast_or_null<DINode>(getRawEntity()); }
3047 StringRef getName() const { return getStringOperand(2); }
3048 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
3049
3050 Metadata *getRawScope() const { return getOperand(0); }
3051 Metadata *getRawEntity() const { return getOperand(1); }
3052 MDString *getRawName() const { return getOperandAs<MDString>(2); }
3053 Metadata *getRawFile() const { return getOperand(3); }
3054
3055 static bool classof(const Metadata *MD) {
3056 return MD->getMetadataID() == DIImportedEntityKind;
3057 }
3058};
3059
3060/// A pair of DIGlobalVariable and DIExpression.
3061class DIGlobalVariableExpression : public MDNode {
3062 friend class LLVMContextImpl;
3063 friend class MDNode;
3064
3065 DIGlobalVariableExpression(LLVMContext &C, StorageType Storage,
3066 ArrayRef<Metadata *> Ops)
3067 : MDNode(C, DIGlobalVariableExpressionKind, Storage, Ops) {}
3068 ~DIGlobalVariableExpression() = default;
3069
3070 static DIGlobalVariableExpression *
3071 getImpl(LLVMContext &Context, Metadata *Variable, Metadata *Expression,
3072 StorageType Storage, bool ShouldCreate = true);
3073
3074 TempDIGlobalVariableExpression cloneImpl() const {
3075 return getTemporary(getContext(), getVariable(), getExpression());
3076 }
3077
3078public:
3079 DEFINE_MDNODE_GET(DIGlobalVariableExpression,
3080 (Metadata * Variable, Metadata *Expression),
3081 (Variable, Expression))
3082
3083 TempDIGlobalVariableExpression clone() const { return cloneImpl(); }
3084
3085 Metadata *getRawVariable() const { return getOperand(0); }
3086
3087 DIGlobalVariable *getVariable() const {
3088 return cast_or_null<DIGlobalVariable>(getRawVariable());
3089 }
3090
3091 Metadata *getRawExpression() const { return getOperand(1); }
3092
3093 DIExpression *getExpression() const {
3094 return cast<DIExpression>(getRawExpression());
3095 }
3096
3097 static bool classof(const Metadata *MD) {
3098 return MD->getMetadataID() == DIGlobalVariableExpressionKind;
3099 }
3100};
3101
3102/// Macro Info DWARF-like metadata node.
3103///
3104/// A metadata node with a DWARF macro info (i.e., a constant named
3105/// \c DW_MACINFO_*, defined in llvm/BinaryFormat/Dwarf.h). Called \a
3106/// DIMacroNode
3107/// because it's potentially used for non-DWARF output.
3108class DIMacroNode : public MDNode {
3109 friend class LLVMContextImpl;
3110 friend class MDNode;
3111
3112protected:
3113 DIMacroNode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned MIType,
3114 ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None)
3115 : MDNode(C, ID, Storage, Ops1, Ops2) {
3116 assert(MIType < 1u << 16)((MIType < 1u << 16) ? static_cast<void> (0) :
__assert_fail ("MIType < 1u << 16", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include/llvm/IR/DebugInfoMetadata.h"
, 3116, __PRETTY_FUNCTION__))
;
3117 SubclassData16 = MIType;
3118 }
3119 ~DIMacroNode() = default;
3120
3121 template <class Ty> Ty *getOperandAs(unsigned I) const {
3122 return cast_or_null<Ty>(getOperand(I));
3123 }
3124
3125 StringRef getStringOperand(unsigned I) const {
3126 if (auto *S = getOperandAs<MDString>(I))
3127 return S->getString();
3128 return StringRef();
3129 }
3130
3131 static MDString *getCanonicalMDString(LLVMContext &Context, StringRef S) {
3132 if (S.empty())
3133 return nullptr;
3134 return MDString::get(Context, S);
3135 }
3136
3137public:
3138 unsigned getMacinfoType() const { return SubclassData16; }
3139
3140 static bool classof(const Metadata *MD) {
3141 switch (MD->getMetadataID()) {
3142 default:
3143 return false;
3144 case DIMacroKind:
3145 case DIMacroFileKind:
3146 return true;
3147 }
3148 }
3149};
3150
3151class DIMacro : public DIMacroNode {
3152 friend class LLVMContextImpl;
3153 friend class MDNode;
3154
3155 unsigned Line;
3156
3157 DIMacro(LLVMContext &C, StorageType Storage, unsigned MIType, unsigned Line,
3158 ArrayRef<Metadata *> Ops)
3159 : DIMacroNode(C, DIMacroKind, Storage, MIType, Ops), Line(Line) {}
3160 ~DIMacro() = default;
3161
3162 static DIMacro *getImpl(LLVMContext &Context, unsigned MIType, unsigned Line,
3163 StringRef Name, StringRef Value, StorageType Storage,
3164 bool ShouldCreate = true) {
3165 return getImpl(Context, MIType, Line, getCanonicalMDString(Context, Name),
3166 getCanonicalMDString(Context, Value), Storage, ShouldCreate);
3167 }
3168 static DIMacro *getImpl(LLVMContext &Context, unsigned MIType, unsigned Line,
3169 MDString *Name, MDString *Value, StorageType Storage,
3170 bool ShouldCreate = true);
3171
3172 TempDIMacro cloneImpl() const {
3173 return getTemporary(getContext(), getMacinfoType(), getLine(), getName(),
3174 getValue());
3175 }
3176
3177public:
3178 DEFINE_MDNODE_GET(DIMacro, (unsigned MIType, unsigned Line, StringRef Name,
3179 StringRef Value = ""),
3180 (MIType, Line, Name, Value))
3181 DEFINE_MDNODE_GET(DIMacro, (unsigned MIType, unsigned Line, MDString *Name,
3182 MDString *Value),
3183 (MIType, Line, Name, Value))
3184
3185 TempDIMacro clone() const { return cloneImpl(); }
3186
3187 unsigned getLine() const { return Line; }
3188
3189 StringRef getName() const { return getStringOperand(0); }
3190 StringRef getValue() const { return getStringOperand(1); }
3191
3192 MDString *getRawName() const { return getOperandAs<MDString>(0); }
3193 MDString *getRawValue() const { return getOperandAs<MDString>(1); }
3194
3195 static bool classof(const Metadata *MD) {
3196 return MD->getMetadataID() == DIMacroKind;
3197 }
3198};
3199
3200class DIMacroFile : public DIMacroNode {
3201 friend class LLVMContextImpl;
3202 friend class MDNode;
3203
3204 unsigned Line;
3205
3206 DIMacroFile(LLVMContext &C, StorageType Storage, unsigned MIType,
3207 unsigned Line, ArrayRef<Metadata *> Ops)
3208 : DIMacroNode(C, DIMacroFileKind, Storage, MIType, Ops), Line(Line) {}
3209 ~DIMacroFile() = default;
3210
3211 static DIMacroFile *getImpl(LLVMContext &Context, unsigned MIType,
3212 unsigned Line, DIFile *File,
3213 DIMacroNodeArray Elements, StorageType Storage,
3214 bool ShouldCreate = true) {
3215 return getImpl(Context, MIType, Line, static_cast<Metadata *>(File),
3216 Elements.get(), Storage, ShouldCreate);
3217 }
3218
3219 static DIMacroFile *getImpl(LLVMContext &Context, unsigned MIType,
3220 unsigned Line, Metadata *File, Metadata *Elements,
3221 StorageType Storage, bool ShouldCreate = true);
3222
3223 TempDIMacroFile cloneImpl() const {
3224 return getTemporary(getContext(), getMacinfoType(), getLine(), getFile(),
3225 getElements());
3226 }
3227
3228public:
3229 DEFINE_MDNODE_GET(DIMacroFile, (unsigned MIType, unsigned Line, DIFile *File,
3230 DIMacroNodeArray Elements),
3231 (MIType, Line, File, Elements))
3232 DEFINE_MDNODE_GET(DIMacroFile, (unsigned MIType, unsigned Line,
3233 Metadata *File, Metadata *Elements),
3234 (MIType, Line, File, Elements))
3235
3236 TempDIMacroFile clone() const { return cloneImpl(); }
3237
3238 void replaceElements(DIMacroNodeArray Elements) {
3239#ifndef NDEBUG
3240 for (DIMacroNode *Op : getElements())
3241 assert(is_contained(Elements->operands(), Op) &&((is_contained(Elements->operands(), Op) && "Lost a macro node during macro node list replacement"
) ? static_cast<void> (0) : __assert_fail ("is_contained(Elements->operands(), Op) && \"Lost a macro node during macro node list replacement\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include/llvm/IR/DebugInfoMetadata.h"
, 3242, __PRETTY_FUNCTION__))
3242 "Lost a macro node during macro node list replacement")((is_contained(Elements->operands(), Op) && "Lost a macro node during macro node list replacement"
) ? static_cast<void> (0) : __assert_fail ("is_contained(Elements->operands(), Op) && \"Lost a macro node during macro node list replacement\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include/llvm/IR/DebugInfoMetadata.h"
, 3242, __PRETTY_FUNCTION__))
;
3243#endif
3244 replaceOperandWith(1, Elements.get());
3245 }
3246
3247 unsigned getLine() const { return Line; }
3248 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
3249
3250 DIMacroNodeArray getElements() const {
3251 return cast_or_null<MDTuple>(getRawElements());
3252 }
3253
3254 Metadata *getRawFile() const { return getOperand(0); }
3255 Metadata *getRawElements() const { return getOperand(1); }
3256
3257 static bool classof(const Metadata *MD) {
3258 return MD->getMetadataID() == DIMacroFileKind;
3259 }
3260};
3261
3262/// Identifies a unique instance of a variable.
3263///
3264/// Storage for identifying a potentially inlined instance of a variable,
3265/// or a fragment thereof. This guarantees that exactly one variable instance
3266/// may be identified by this class, even when that variable is a fragment of
3267/// an aggregate variable and/or there is another inlined instance of the same
3268/// source code variable nearby.
3269/// This class does not necessarily uniquely identify that variable: it is
3270/// possible that a DebugVariable with different parameters may point to the
3271/// same variable instance, but not that one DebugVariable points to multiple
3272/// variable instances.
3273class DebugVariable {
3274 using FragmentInfo = DIExpression::FragmentInfo;
3275
3276 const DILocalVariable *Variable;
3277 Optional<FragmentInfo> Fragment;
3278 const DILocation *InlinedAt;
3279
3280 /// Fragment that will overlap all other fragments. Used as default when
3281 /// caller demands a fragment.
3282 static const FragmentInfo DefaultFragment;
3283
3284public:
3285 DebugVariable(const DILocalVariable *Var, Optional<FragmentInfo> FragmentInfo,
3286 const DILocation *InlinedAt)
3287 : Variable(Var), Fragment(FragmentInfo), InlinedAt(InlinedAt) {}
3288
3289 DebugVariable(const DILocalVariable *Var, const DIExpression *DIExpr,
3290 const DILocation *InlinedAt)
3291 : Variable(Var),
3292 Fragment(DIExpr ? DIExpr->getFragmentInfo() : NoneType()),
3293 InlinedAt(InlinedAt) {}
3294
3295 const DILocalVariable *getVariable() const { return Variable; }
3296 const Optional<FragmentInfo> getFragment() const { return Fragment; }
3297 const DILocation *getInlinedAt() const { return InlinedAt; }
3298
3299 const FragmentInfo getFragmentOrDefault() const {
3300 return Fragment.getValueOr(DefaultFragment);
3301 }
3302
3303 static bool isDefaultFragment(const FragmentInfo F) {
3304 return F == DefaultFragment;
3305 }
3306
3307 bool operator==(const DebugVariable &Other) const {
3308 return std::tie(Variable, Fragment, InlinedAt) ==
3309 std::tie(Other.Variable, Other.Fragment, Other.InlinedAt);
3310 }
3311
3312 bool operator<(const DebugVariable &Other) const {
3313 return std::tie(Variable, Fragment, InlinedAt) <
3314 std::tie(Other.Variable, Other.Fragment, Other.InlinedAt);
3315 }
3316};
3317
3318template <> struct DenseMapInfo<DebugVariable> {
3319 using FragmentInfo = DIExpression::FragmentInfo;
3320
3321 /// Empty key: no key should be generated that has no DILocalVariable.
3322 static inline DebugVariable getEmptyKey() {
3323 return DebugVariable(nullptr, NoneType(), nullptr);
3324 }
3325
3326 /// Difference in tombstone is that the Optional is meaningful.
3327 static inline DebugVariable getTombstoneKey() {
3328 return DebugVariable(nullptr, {{0, 0}}, nullptr);
3329 }
3330
3331 static unsigned getHashValue(const DebugVariable &D) {
3332 unsigned HV = 0;
3333 const Optional<FragmentInfo> Fragment = D.getFragment();
3334 if (Fragment)
3335 HV = DenseMapInfo<FragmentInfo>::getHashValue(*Fragment);
3336
3337 return hash_combine(D.getVariable(), HV, D.getInlinedAt());
3338 }
3339
3340 static bool isEqual(const DebugVariable &A, const DebugVariable &B) {
3341 return A == B;
3342 }
3343};
3344
3345} // end namespace llvm
3346
3347#undef DEFINE_MDNODE_GET_UNPACK_IMPL
3348#undef DEFINE_MDNODE_GET_UNPACK
3349#undef DEFINE_MDNODE_GET
3350
3351#endif // LLVM_IR_DEBUGINFOMETADATA_H