Bug Summary

File:lib/IR/DebugInfoMetadata.cpp
Warning:line 808, column 28
Called C++ object pointer is null

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-eagerly-assume -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 -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn325874/build-llvm/lib/IR -I /build/llvm-toolchain-snapshot-7~svn325874/lib/IR -I /build/llvm-toolchain-snapshot-7~svn325874/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn325874/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.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++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn325874/build-llvm/lib/IR -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-02-23-163436-368-1 -x c++ /build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp
1//===- DebugInfoMetadata.cpp - Implement debug info metadata --------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the debug info Metadata classes.
11//
12//===----------------------------------------------------------------------===//
13
14#include "llvm/IR/DebugInfoMetadata.h"
15#include "LLVMContextImpl.h"
16#include "MetadataImpl.h"
17#include "llvm/ADT/SmallPtrSet.h"
18#include "llvm/ADT/StringSwitch.h"
19#include "llvm/IR/DIBuilder.h"
20#include "llvm/IR/Function.h"
21#include "llvm/IR/Instructions.h"
22
23using namespace llvm;
24
25DILocation::DILocation(LLVMContext &C, StorageType Storage, unsigned Line,
26 unsigned Column, ArrayRef<Metadata *> MDs)
27 : MDNode(C, DILocationKind, Storage, MDs) {
28 assert((MDs.size() == 1 || MDs.size() == 2) &&(static_cast <bool> ((MDs.size() == 1 || MDs.size() == 2
) && "Expected a scope and optional inlined-at") ? void
(0) : __assert_fail ("(MDs.size() == 1 || MDs.size() == 2) && \"Expected a scope and optional inlined-at\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 29, __extension__ __PRETTY_FUNCTION__))
29 "Expected a scope and optional inlined-at")(static_cast <bool> ((MDs.size() == 1 || MDs.size() == 2
) && "Expected a scope and optional inlined-at") ? void
(0) : __assert_fail ("(MDs.size() == 1 || MDs.size() == 2) && \"Expected a scope and optional inlined-at\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 29, __extension__ __PRETTY_FUNCTION__))
;
30
31 // Set line and column.
32 assert(Column < (1u << 16) && "Expected 16-bit column")(static_cast <bool> (Column < (1u << 16) &&
"Expected 16-bit column") ? void (0) : __assert_fail ("Column < (1u << 16) && \"Expected 16-bit column\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 32, __extension__ __PRETTY_FUNCTION__))
;
33
34 SubclassData32 = Line;
35 SubclassData16 = Column;
36}
37
38static void adjustColumn(unsigned &Column) {
39 // Set to unknown on overflow. We only have 16 bits to play with here.
40 if (Column >= (1u << 16))
41 Column = 0;
42}
43
44DILocation *DILocation::getImpl(LLVMContext &Context, unsigned Line,
45 unsigned Column, Metadata *Scope,
46 Metadata *InlinedAt, StorageType Storage,
47 bool ShouldCreate) {
48 // Fixup column.
49 adjustColumn(Column);
50
51 if (Storage == Uniqued) {
52 if (auto *N =
53 getUniqued(Context.pImpl->DILocations,
54 DILocationInfo::KeyTy(Line, Column, Scope, InlinedAt)))
55 return N;
56 if (!ShouldCreate)
57 return nullptr;
58 } else {
59 assert(ShouldCreate && "Expected non-uniqued nodes to always be created")(static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 59, __extension__ __PRETTY_FUNCTION__))
;
60 }
61
62 SmallVector<Metadata *, 2> Ops;
63 Ops.push_back(Scope);
64 if (InlinedAt)
65 Ops.push_back(InlinedAt);
66 return storeImpl(new (Ops.size())
67 DILocation(Context, Storage, Line, Column, Ops),
68 Storage, Context.pImpl->DILocations);
69}
70
71const DILocation *
72DILocation::getMergedLocation(const DILocation *LocA, const DILocation *LocB,
73 const Instruction *ForInst) {
74 if (!LocA || !LocB)
75 return nullptr;
76
77 if (LocA == LocB || !LocA->canDiscriminate(*LocB))
78 return LocA;
79
80 if (!dyn_cast_or_null<CallInst>(ForInst))
81 return nullptr;
82
83 SmallPtrSet<DILocation *, 5> InlinedLocationsA;
84 for (DILocation *L = LocA->getInlinedAt(); L; L = L->getInlinedAt())
85 InlinedLocationsA.insert(L);
86 const DILocation *Result = LocB;
87 for (DILocation *L = LocB->getInlinedAt(); L; L = L->getInlinedAt()) {
88 Result = L;
89 if (InlinedLocationsA.count(L))
90 break;
91 }
92 return DILocation::get(Result->getContext(), 0, 0, Result->getScope(),
93 Result->getInlinedAt());
94}
95
96DINode::DIFlags DINode::getFlag(StringRef Flag) {
97 return StringSwitch<DIFlags>(Flag)
98#define HANDLE_DI_FLAG(ID, NAME) .Case("DIFlag" #NAME, Flag##NAME)
99#include "llvm/IR/DebugInfoFlags.def"
100 .Default(DINode::FlagZero);
101}
102
103StringRef DINode::getFlagString(DIFlags Flag) {
104 switch (Flag) {
105#define HANDLE_DI_FLAG(ID, NAME) \
106 case Flag##NAME: \
107 return "DIFlag" #NAME;
108#include "llvm/IR/DebugInfoFlags.def"
109 }
110 return "";
111}
112
113DINode::DIFlags DINode::splitFlags(DIFlags Flags,
114 SmallVectorImpl<DIFlags> &SplitFlags) {
115 // Flags that are packed together need to be specially handled, so
116 // that, for example, we emit "DIFlagPublic" and not
117 // "DIFlagPrivate | DIFlagProtected".
118 if (DIFlags A = Flags & FlagAccessibility) {
119 if (A == FlagPrivate)
120 SplitFlags.push_back(FlagPrivate);
121 else if (A == FlagProtected)
122 SplitFlags.push_back(FlagProtected);
123 else
124 SplitFlags.push_back(FlagPublic);
125 Flags &= ~A;
126 }
127 if (DIFlags R = Flags & FlagPtrToMemberRep) {
128 if (R == FlagSingleInheritance)
129 SplitFlags.push_back(FlagSingleInheritance);
130 else if (R == FlagMultipleInheritance)
131 SplitFlags.push_back(FlagMultipleInheritance);
132 else
133 SplitFlags.push_back(FlagVirtualInheritance);
134 Flags &= ~R;
135 }
136 if ((Flags & FlagIndirectVirtualBase) == FlagIndirectVirtualBase) {
137 Flags &= ~FlagIndirectVirtualBase;
138 SplitFlags.push_back(FlagIndirectVirtualBase);
139 }
140
141#define HANDLE_DI_FLAG(ID, NAME) \
142 if (DIFlags Bit = Flags & Flag##NAME) { \
143 SplitFlags.push_back(Bit); \
144 Flags &= ~Bit; \
145 }
146#include "llvm/IR/DebugInfoFlags.def"
147 return Flags;
148}
149
150DIScopeRef DIScope::getScope() const {
151 if (auto *T = dyn_cast<DIType>(this))
152 return T->getScope();
153
154 if (auto *SP = dyn_cast<DISubprogram>(this))
155 return SP->getScope();
156
157 if (auto *LB = dyn_cast<DILexicalBlockBase>(this))
158 return LB->getScope();
159
160 if (auto *NS = dyn_cast<DINamespace>(this))
161 return NS->getScope();
162
163 if (auto *M = dyn_cast<DIModule>(this))
164 return M->getScope();
165
166 assert((isa<DIFile>(this) || isa<DICompileUnit>(this)) &&(static_cast <bool> ((isa<DIFile>(this) || isa<
DICompileUnit>(this)) && "Unhandled type of scope."
) ? void (0) : __assert_fail ("(isa<DIFile>(this) || isa<DICompileUnit>(this)) && \"Unhandled type of scope.\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 167, __extension__ __PRETTY_FUNCTION__))
167 "Unhandled type of scope.")(static_cast <bool> ((isa<DIFile>(this) || isa<
DICompileUnit>(this)) && "Unhandled type of scope."
) ? void (0) : __assert_fail ("(isa<DIFile>(this) || isa<DICompileUnit>(this)) && \"Unhandled type of scope.\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 167, __extension__ __PRETTY_FUNCTION__))
;
168 return nullptr;
169}
170
171StringRef DIScope::getName() const {
172 if (auto *T = dyn_cast<DIType>(this))
173 return T->getName();
174 if (auto *SP = dyn_cast<DISubprogram>(this))
175 return SP->getName();
176 if (auto *NS = dyn_cast<DINamespace>(this))
177 return NS->getName();
178 if (auto *M = dyn_cast<DIModule>(this))
179 return M->getName();
180 assert((isa<DILexicalBlockBase>(this) || isa<DIFile>(this) ||(static_cast <bool> ((isa<DILexicalBlockBase>(this
) || isa<DIFile>(this) || isa<DICompileUnit>(this
)) && "Unhandled type of scope.") ? void (0) : __assert_fail
("(isa<DILexicalBlockBase>(this) || isa<DIFile>(this) || isa<DICompileUnit>(this)) && \"Unhandled type of scope.\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 182, __extension__ __PRETTY_FUNCTION__))
181 isa<DICompileUnit>(this)) &&(static_cast <bool> ((isa<DILexicalBlockBase>(this
) || isa<DIFile>(this) || isa<DICompileUnit>(this
)) && "Unhandled type of scope.") ? void (0) : __assert_fail
("(isa<DILexicalBlockBase>(this) || isa<DIFile>(this) || isa<DICompileUnit>(this)) && \"Unhandled type of scope.\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 182, __extension__ __PRETTY_FUNCTION__))
182 "Unhandled type of scope.")(static_cast <bool> ((isa<DILexicalBlockBase>(this
) || isa<DIFile>(this) || isa<DICompileUnit>(this
)) && "Unhandled type of scope.") ? void (0) : __assert_fail
("(isa<DILexicalBlockBase>(this) || isa<DIFile>(this) || isa<DICompileUnit>(this)) && \"Unhandled type of scope.\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 182, __extension__ __PRETTY_FUNCTION__))
;
183 return "";
184}
185
186#ifndef NDEBUG
187static bool isCanonical(const MDString *S) {
188 return !S || !S->getString().empty();
189}
190#endif
191
192GenericDINode *GenericDINode::getImpl(LLVMContext &Context, unsigned Tag,
193 MDString *Header,
194 ArrayRef<Metadata *> DwarfOps,
195 StorageType Storage, bool ShouldCreate) {
196 unsigned Hash = 0;
197 if (Storage == Uniqued) {
198 GenericDINodeInfo::KeyTy Key(Tag, Header, DwarfOps);
199 if (auto *N = getUniqued(Context.pImpl->GenericDINodes, Key))
200 return N;
201 if (!ShouldCreate)
202 return nullptr;
203 Hash = Key.getHash();
204 } else {
205 assert(ShouldCreate && "Expected non-uniqued nodes to always be created")(static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 205, __extension__ __PRETTY_FUNCTION__))
;
206 }
207
208 // Use a nullptr for empty headers.
209 assert(isCanonical(Header) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Header) && "Expected canonical MDString"
) ? void (0) : __assert_fail ("isCanonical(Header) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 209, __extension__ __PRETTY_FUNCTION__))
;
210 Metadata *PreOps[] = {Header};
211 return storeImpl(new (DwarfOps.size() + 1) GenericDINode(
212 Context, Storage, Hash, Tag, PreOps, DwarfOps),
213 Storage, Context.pImpl->GenericDINodes);
214}
215
216void GenericDINode::recalculateHash() {
217 setHash(GenericDINodeInfo::KeyTy::calculateHash(this));
218}
219
220#define UNWRAP_ARGS_IMPL(...)... __VA_ARGS__
221#define UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS UNWRAP_ARGS_IMPL ARGS
222#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 { (static_cast <
bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 222, __extension__ __PRETTY_FUNCTION__)); } } while (false)
\
223 do { \
224 if (Storage == Uniqued) { \
225 if (auto *N = getUniqued(Context.pImpl->CLASS##s, \
226 CLASS##Info::KeyTy(UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS))) \
227 return N; \
228 if (!ShouldCreate) \
229 return nullptr; \
230 } else { \
231 assert(ShouldCreate && \(static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 232, __extension__ __PRETTY_FUNCTION__))
232 "Expected non-uniqued nodes to always be created")(static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 232, __extension__ __PRETTY_FUNCTION__))
; \
233 } \
234 } while (false)
235#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
)
\
236 return storeImpl(new (array_lengthof(OPS)) \
237 CLASS(Context, Storage, UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS, OPS), \
238 Storage, Context.pImpl->CLASS##s)
239#define DEFINE_GETIMPL_STORE_NO_OPS(CLASS, ARGS)return storeImpl(new (0u) CLASS(Context, Storage, UNWRAP_ARGS_IMPL
ARGS), Storage, Context.pImpl->CLASSs)
\
240 return storeImpl(new (0u) CLASS(Context, Storage, UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS), \
241 Storage, Context.pImpl->CLASS##s)
242#define DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(CLASS, OPS)return storeImpl(new (array_lengthof(OPS)) CLASS(Context, Storage
, OPS), Storage, Context.pImpl->CLASSs)
\
243 return storeImpl(new (array_lengthof(OPS)) CLASS(Context, Storage, OPS), \
244 Storage, Context.pImpl->CLASS##s)
245#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)
\
246 return storeImpl(new (NUM_OPS) \
247 CLASS(Context, Storage, UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS, OPS), \
248 Storage, Context.pImpl->CLASS##s)
249
250DISubrange *DISubrange::getImpl(LLVMContext &Context, int64_t Count, int64_t Lo,
251 StorageType Storage, bool ShouldCreate) {
252 auto *CountNode = ConstantAsMetadata::get(
253 ConstantInt::getSigned(Type::getInt64Ty(Context), Count));
254 return getImpl(Context, CountNode, Lo, Storage, ShouldCreate);
255}
256
257DISubrange *DISubrange::getImpl(LLVMContext &Context, Metadata *CountNode,
258 int64_t Lo, StorageType Storage,
259 bool ShouldCreate) {
260 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 { (static_cast
<bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 260, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
261 Metadata *Ops[] = { CountNode };
262 DEFINE_GETIMPL_STORE(DISubrange, (CountNode, Lo), Ops)return storeImpl(new (array_lengthof(Ops)) DISubrange(Context
, Storage, CountNode, Lo, Ops), Storage, Context.pImpl->DISubranges
)
;
263}
264
265DIEnumerator *DIEnumerator::getImpl(LLVMContext &Context, int64_t Value,
266 bool IsUnsigned, MDString *Name,
267 StorageType Storage, bool ShouldCreate) {
268 assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString"
) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 268, __extension__ __PRETTY_FUNCTION__))
;
269 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
{ (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 269, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
270 Metadata *Ops[] = {Name};
271 DEFINE_GETIMPL_STORE(DIEnumerator, (Value, IsUnsigned), Ops)return storeImpl(new (array_lengthof(Ops)) DIEnumerator(Context
, Storage, Value, IsUnsigned, Ops), Storage, Context.pImpl->
DIEnumerators)
;
272}
273
274DIBasicType *DIBasicType::getImpl(LLVMContext &Context, unsigned Tag,
275 MDString *Name, uint64_t SizeInBits,
276 uint32_t AlignInBits, unsigned Encoding,
277 StorageType Storage, bool ShouldCreate) {
278 assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString"
) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 278, __extension__ __PRETTY_FUNCTION__))
;
279 DEFINE_GETIMPL_LOOKUP(DIBasicType,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIBasicTypes, DIBasicTypeInfo::KeyTy(Tag, Name, SizeInBits
, AlignInBits, Encoding))) return N; if (!ShouldCreate) return
nullptr; } else { (static_cast <bool> (ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? void (0
) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 280, __extension__ __PRETTY_FUNCTION__)); } } while (false)
280 (Tag, Name, SizeInBits, AlignInBits, Encoding))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIBasicTypes, DIBasicTypeInfo::KeyTy(Tag, Name, SizeInBits
, AlignInBits, Encoding))) return N; if (!ShouldCreate) return
nullptr; } else { (static_cast <bool> (ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? void (0
) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 280, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
281 Metadata *Ops[] = {nullptr, nullptr, Name};
282 DEFINE_GETIMPL_STORE(DIBasicType, (Tag, SizeInBits, AlignInBits, Encoding),return storeImpl(new (array_lengthof(Ops)) DIBasicType(Context
, Storage, Tag, SizeInBits, AlignInBits, Encoding, Ops), Storage
, Context.pImpl->DIBasicTypes)
283 Ops)return storeImpl(new (array_lengthof(Ops)) DIBasicType(Context
, Storage, Tag, SizeInBits, AlignInBits, Encoding, Ops), Storage
, Context.pImpl->DIBasicTypes)
;
284}
285
286DIDerivedType *DIDerivedType::getImpl(
287 LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
288 unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
289 uint32_t AlignInBits, uint64_t OffsetInBits,
290 Optional<unsigned> DWARFAddressSpace, DIFlags Flags, Metadata *ExtraData,
291 StorageType Storage, bool ShouldCreate) {
292 assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString"
) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 292, __extension__ __PRETTY_FUNCTION__))
;
293 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 { (static_cast <bool> (ShouldCreate
&& "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 296, __extension__ __PRETTY_FUNCTION__)); } } while (false)
294 (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 { (static_cast <bool> (ShouldCreate
&& "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 296, __extension__ __PRETTY_FUNCTION__)); } } while (false)
295 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 { (static_cast <bool> (ShouldCreate
&& "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 296, __extension__ __PRETTY_FUNCTION__)); } } while (false)
296 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 { (static_cast <bool> (ShouldCreate
&& "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 296, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
297 Metadata *Ops[] = {File, Scope, Name, BaseType, ExtraData};
298 DEFINE_GETIMPL_STORE(return storeImpl(new (array_lengthof(Ops)) DIDerivedType(Context
, Storage, Tag, Line, SizeInBits, AlignInBits, OffsetInBits, DWARFAddressSpace
, Flags, Ops), Storage, Context.pImpl->DIDerivedTypes)
299 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)
300 DWARFAddressSpace, Flags), Ops)return storeImpl(new (array_lengthof(Ops)) DIDerivedType(Context
, Storage, Tag, Line, SizeInBits, AlignInBits, OffsetInBits, DWARFAddressSpace
, Flags, Ops), Storage, Context.pImpl->DIDerivedTypes)
;
301}
302
303DICompositeType *DICompositeType::getImpl(
304 LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
305 unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
306 uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
307 Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder,
308 Metadata *TemplateParams, MDString *Identifier, Metadata *Discriminator,
309 StorageType Storage, bool ShouldCreate) {
310 assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString"
) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 310, __extension__ __PRETTY_FUNCTION__))
;
311
312 // Keep this in sync with buildODRType.
313 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 { (static_cast <bool> (ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? void (0
) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 316, __extension__ __PRETTY_FUNCTION__)); } } while (false)
314 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 { (static_cast <bool> (ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? void (0
) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 316, __extension__ __PRETTY_FUNCTION__)); } } while (false)
315 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 { (static_cast <bool> (ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? void (0
) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 316, __extension__ __PRETTY_FUNCTION__)); } } while (false)
316 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 { (static_cast <bool> (ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? void (0
) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 316, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
317 Metadata *Ops[] = {File, Scope, Name, BaseType,
318 Elements, VTableHolder, TemplateParams, Identifier,
319 Discriminator};
320 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)
321 AlignInBits, OffsetInBits, Flags),return storeImpl(new (array_lengthof(Ops)) DICompositeType(Context
, Storage, Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits
, Flags, Ops), Storage, Context.pImpl->DICompositeTypes)
322 Ops)return storeImpl(new (array_lengthof(Ops)) DICompositeType(Context
, Storage, Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits
, Flags, Ops), Storage, Context.pImpl->DICompositeTypes)
;
323}
324
325DICompositeType *DICompositeType::buildODRType(
326 LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name,
327 Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType,
328 uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
329 DIFlags Flags, Metadata *Elements, unsigned RuntimeLang,
330 Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator) {
331 assert(!Identifier.getString().empty() && "Expected valid identifier")(static_cast <bool> (!Identifier.getString().empty() &&
"Expected valid identifier") ? void (0) : __assert_fail ("!Identifier.getString().empty() && \"Expected valid identifier\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 331, __extension__ __PRETTY_FUNCTION__))
;
332 if (!Context.isODRUniquingDebugTypes())
333 return nullptr;
334 auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier];
335 if (!CT)
336 return CT = DICompositeType::getDistinct(
337 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
338 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
339 VTableHolder, TemplateParams, &Identifier, Discriminator);
340
341 // Only mutate CT if it's a forward declaration and the new operands aren't.
342 assert(CT->getRawIdentifier() == &Identifier && "Wrong ODR identifier?")(static_cast <bool> (CT->getRawIdentifier() == &
Identifier && "Wrong ODR identifier?") ? void (0) : __assert_fail
("CT->getRawIdentifier() == &Identifier && \"Wrong ODR identifier?\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 342, __extension__ __PRETTY_FUNCTION__))
;
343 if (!CT->isForwardDecl() || (Flags & DINode::FlagFwdDecl))
344 return CT;
345
346 // Mutate CT in place. Keep this in sync with getImpl.
347 CT->mutate(Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits,
348 Flags);
349 Metadata *Ops[] = {File, Scope, Name, BaseType,
350 Elements, VTableHolder, TemplateParams, &Identifier,
351 Discriminator};
352 assert((std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands() &&(static_cast <bool> ((std::end(Ops) - std::begin(Ops)) ==
(int)CT->getNumOperands() && "Mismatched number of operands"
) ? void (0) : __assert_fail ("(std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands() && \"Mismatched number of operands\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 353, __extension__ __PRETTY_FUNCTION__))
353 "Mismatched number of operands")(static_cast <bool> ((std::end(Ops) - std::begin(Ops)) ==
(int)CT->getNumOperands() && "Mismatched number of operands"
) ? void (0) : __assert_fail ("(std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands() && \"Mismatched number of operands\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 353, __extension__ __PRETTY_FUNCTION__))
;
354 for (unsigned I = 0, E = CT->getNumOperands(); I != E; ++I)
355 if (Ops[I] != CT->getOperand(I))
356 CT->setOperand(I, Ops[I]);
357 return CT;
358}
359
360DICompositeType *DICompositeType::getODRType(
361 LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name,
362 Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType,
363 uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
364 DIFlags Flags, Metadata *Elements, unsigned RuntimeLang,
365 Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator) {
366 assert(!Identifier.getString().empty() && "Expected valid identifier")(static_cast <bool> (!Identifier.getString().empty() &&
"Expected valid identifier") ? void (0) : __assert_fail ("!Identifier.getString().empty() && \"Expected valid identifier\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 366, __extension__ __PRETTY_FUNCTION__))
;
367 if (!Context.isODRUniquingDebugTypes())
368 return nullptr;
369 auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier];
370 if (!CT)
371 CT = DICompositeType::getDistinct(
372 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
373 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, VTableHolder,
374 TemplateParams, &Identifier, Discriminator);
375 return CT;
376}
377
378DICompositeType *DICompositeType::getODRTypeIfExists(LLVMContext &Context,
379 MDString &Identifier) {
380 assert(!Identifier.getString().empty() && "Expected valid identifier")(static_cast <bool> (!Identifier.getString().empty() &&
"Expected valid identifier") ? void (0) : __assert_fail ("!Identifier.getString().empty() && \"Expected valid identifier\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 380, __extension__ __PRETTY_FUNCTION__))
;
381 if (!Context.isODRUniquingDebugTypes())
382 return nullptr;
383 return Context.pImpl->DITypeMap->lookup(&Identifier);
384}
385
386DISubroutineType *DISubroutineType::getImpl(LLVMContext &Context, DIFlags Flags,
387 uint8_t CC, Metadata *TypeArray,
388 StorageType Storage,
389 bool ShouldCreate) {
390 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 { (static_cast <bool> (ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? void (0
) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 390, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
391 Metadata *Ops[] = {nullptr, nullptr, nullptr, TypeArray};
392 DEFINE_GETIMPL_STORE(DISubroutineType, (Flags, CC), Ops)return storeImpl(new (array_lengthof(Ops)) DISubroutineType(Context
, Storage, Flags, CC, Ops), Storage, Context.pImpl->DISubroutineTypes
)
;
393}
394
395// FIXME: Implement this string-enum correspondence with a .def file and macros,
396// so that the association is explicit rather than implied.
397static const char *ChecksumKindName[DIFile::CSK_Last] = {
398 "CSK_MD5",
399 "CSK_SHA1"
400};
401
402StringRef DIFile::getChecksumKindAsString(ChecksumKind CSKind) {
403 assert(CSKind <= DIFile::CSK_Last && "Invalid checksum kind")(static_cast <bool> (CSKind <= DIFile::CSK_Last &&
"Invalid checksum kind") ? void (0) : __assert_fail ("CSKind <= DIFile::CSK_Last && \"Invalid checksum kind\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 403, __extension__ __PRETTY_FUNCTION__))
;
404 // The first space was originally the CSK_None variant, which is now
405 // obsolete, but the space is still reserved in ChecksumKind, so we account
406 // for it here.
407 return ChecksumKindName[CSKind - 1];
408}
409
410Optional<DIFile::ChecksumKind> DIFile::getChecksumKind(StringRef CSKindStr) {
411 return StringSwitch<Optional<DIFile::ChecksumKind>>(CSKindStr)
412 .Case("CSK_MD5", DIFile::CSK_MD5)
413 .Case("CSK_SHA1", DIFile::CSK_SHA1)
414 .Default(None);
415}
416
417DIFile *DIFile::getImpl(LLVMContext &Context, MDString *Filename,
418 MDString *Directory,
419 Optional<DIFile::ChecksumInfo<MDString *>> CS,
420 StorageType Storage, bool ShouldCreate) {
421 assert(isCanonical(Filename) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Filename) && "Expected canonical MDString"
) ? void (0) : __assert_fail ("isCanonical(Filename) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 421, __extension__ __PRETTY_FUNCTION__))
;
422 assert(isCanonical(Directory) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Directory) && "Expected canonical MDString"
) ? void (0) : __assert_fail ("isCanonical(Directory) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 422, __extension__ __PRETTY_FUNCTION__))
;
423 assert((!CS || isCanonical(CS->Value)) && "Expected canonical MDString")(static_cast <bool> ((!CS || isCanonical(CS->Value))
&& "Expected canonical MDString") ? void (0) : __assert_fail
("(!CS || isCanonical(CS->Value)) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 423, __extension__ __PRETTY_FUNCTION__))
;
424 DEFINE_GETIMPL_LOOKUP(DIFile, (Filename, Directory, CS))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIFiles, DIFileInfo::KeyTy(Filename, Directory, CS
))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast
<bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 424, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
425 Metadata *Ops[] = {Filename, Directory, CS ? CS->Value : nullptr};
426 DEFINE_GETIMPL_STORE(DIFile, (CS), Ops)return storeImpl(new (array_lengthof(Ops)) DIFile(Context, Storage
, CS, Ops), Storage, Context.pImpl->DIFiles)
;
427}
428
429DICompileUnit *DICompileUnit::getImpl(
430 LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
431 MDString *Producer, bool IsOptimized, MDString *Flags,
432 unsigned RuntimeVersion, MDString *SplitDebugFilename,
433 unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
434 Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata *Macros,
435 uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
436 bool GnuPubnames, StorageType Storage, bool ShouldCreate) {
437 assert(Storage != Uniqued && "Cannot unique DICompileUnit")(static_cast <bool> (Storage != Uniqued && "Cannot unique DICompileUnit"
) ? void (0) : __assert_fail ("Storage != Uniqued && \"Cannot unique DICompileUnit\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 437, __extension__ __PRETTY_FUNCTION__))
;
438 assert(isCanonical(Producer) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Producer) && "Expected canonical MDString"
) ? void (0) : __assert_fail ("isCanonical(Producer) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 438, __extension__ __PRETTY_FUNCTION__))
;
439 assert(isCanonical(Flags) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Flags) && "Expected canonical MDString"
) ? void (0) : __assert_fail ("isCanonical(Flags) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 439, __extension__ __PRETTY_FUNCTION__))
;
440 assert(isCanonical(SplitDebugFilename) && "Expected canonical MDString")(static_cast <bool> (isCanonical(SplitDebugFilename) &&
"Expected canonical MDString") ? void (0) : __assert_fail ("isCanonical(SplitDebugFilename) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 440, __extension__ __PRETTY_FUNCTION__))
;
441
442 Metadata *Ops[] = {
443 File, Producer, Flags, SplitDebugFilename,
444 EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities,
445 Macros};
446 return storeImpl(new (array_lengthof(Ops)) DICompileUnit(
447 Context, Storage, SourceLanguage, IsOptimized,
448 RuntimeVersion, EmissionKind, DWOId, SplitDebugInlining,
449 DebugInfoForProfiling, GnuPubnames, Ops),
450 Storage);
451}
452
453Optional<DICompileUnit::DebugEmissionKind>
454DICompileUnit::getEmissionKind(StringRef Str) {
455 return StringSwitch<Optional<DebugEmissionKind>>(Str)
456 .Case("NoDebug", NoDebug)
457 .Case("FullDebug", FullDebug)
458 .Case("LineTablesOnly", LineTablesOnly)
459 .Default(None);
460}
461
462const char *DICompileUnit::EmissionKindString(DebugEmissionKind EK) {
463 switch (EK) {
464 case NoDebug: return "NoDebug";
465 case FullDebug: return "FullDebug";
466 case LineTablesOnly: return "LineTablesOnly";
467 }
468 return nullptr;
469}
470
471DISubprogram *DILocalScope::getSubprogram() const {
472 if (auto *Block = dyn_cast<DILexicalBlockBase>(this))
473 return Block->getScope()->getSubprogram();
474 return const_cast<DISubprogram *>(cast<DISubprogram>(this));
475}
476
477DILocalScope *DILocalScope::getNonLexicalBlockFileScope() const {
478 if (auto *File = dyn_cast<DILexicalBlockFile>(this))
479 return File->getScope()->getNonLexicalBlockFileScope();
480 return const_cast<DILocalScope *>(this);
481}
482
483DISubprogram *DISubprogram::getImpl(
484 LLVMContext &Context, Metadata *Scope, MDString *Name,
485 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
486 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
487 Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex,
488 int ThisAdjustment, DIFlags Flags, bool IsOptimized, Metadata *Unit,
489 Metadata *TemplateParams, Metadata *Declaration, Metadata *Variables,
490 Metadata *ThrownTypes, StorageType Storage, bool ShouldCreate) {
491 assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString"
) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 491, __extension__ __PRETTY_FUNCTION__))
;
492 assert(isCanonical(LinkageName) && "Expected canonical MDString")(static_cast <bool> (isCanonical(LinkageName) &&
"Expected canonical MDString") ? void (0) : __assert_fail ("isCanonical(LinkageName) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 492, __extension__ __PRETTY_FUNCTION__))
;
493 DEFINE_GETIMPL_LOOKUP(do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name
, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
ScopeLine, ContainingType, Virtuality, VirtualIndex, ThisAdjustment
, Flags, IsOptimized, Unit, TemplateParams, Declaration, Variables
, ThrownTypes))) return N; if (!ShouldCreate) return nullptr;
} else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 497, __extension__ __PRETTY_FUNCTION__)); } } while (false)
494 DISubprogram, (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name
, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
ScopeLine, ContainingType, Virtuality, VirtualIndex, ThisAdjustment
, Flags, IsOptimized, Unit, TemplateParams, Declaration, Variables
, ThrownTypes))) return N; if (!ShouldCreate) return nullptr;
} else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 497, __extension__ __PRETTY_FUNCTION__)); } } while (false)
495 IsDefinition, ScopeLine, ContainingType, Virtuality,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name
, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
ScopeLine, ContainingType, Virtuality, VirtualIndex, ThisAdjustment
, Flags, IsOptimized, Unit, TemplateParams, Declaration, Variables
, ThrownTypes))) return N; if (!ShouldCreate) return nullptr;
} else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 497, __extension__ __PRETTY_FUNCTION__)); } } while (false)
496 VirtualIndex, ThisAdjustment, Flags, IsOptimized, Unit,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name
, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
ScopeLine, ContainingType, Virtuality, VirtualIndex, ThisAdjustment
, Flags, IsOptimized, Unit, TemplateParams, Declaration, Variables
, ThrownTypes))) return N; if (!ShouldCreate) return nullptr;
} else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 497, __extension__ __PRETTY_FUNCTION__)); } } while (false)
497 TemplateParams, Declaration, Variables, ThrownTypes))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name
, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
ScopeLine, ContainingType, Virtuality, VirtualIndex, ThisAdjustment
, Flags, IsOptimized, Unit, TemplateParams, Declaration, Variables
, ThrownTypes))) return N; if (!ShouldCreate) return nullptr;
} else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 497, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
498 SmallVector<Metadata *, 11> Ops = {
499 File, Scope, Name, LinkageName, Type, Unit,
500 Declaration, Variables, ContainingType, TemplateParams, ThrownTypes};
501 if (!ThrownTypes) {
502 Ops.pop_back();
503 if (!TemplateParams) {
504 Ops.pop_back();
505 if (!ContainingType)
506 Ops.pop_back();
507 }
508 }
509 DEFINE_GETIMPL_STORE_N(DISubprogram,return storeImpl(new (Ops.size()) DISubprogram(Context, Storage
, Line, ScopeLine, Virtuality, VirtualIndex, ThisAdjustment, Flags
, IsLocalToUnit, IsDefinition, IsOptimized, Ops), Storage, Context
.pImpl->DISubprograms)
510 (Line, ScopeLine, Virtuality, VirtualIndex,return storeImpl(new (Ops.size()) DISubprogram(Context, Storage
, Line, ScopeLine, Virtuality, VirtualIndex, ThisAdjustment, Flags
, IsLocalToUnit, IsDefinition, IsOptimized, Ops), Storage, Context
.pImpl->DISubprograms)
511 ThisAdjustment, Flags, IsLocalToUnit, IsDefinition,return storeImpl(new (Ops.size()) DISubprogram(Context, Storage
, Line, ScopeLine, Virtuality, VirtualIndex, ThisAdjustment, Flags
, IsLocalToUnit, IsDefinition, IsOptimized, Ops), Storage, Context
.pImpl->DISubprograms)
512 IsOptimized),return storeImpl(new (Ops.size()) DISubprogram(Context, Storage
, Line, ScopeLine, Virtuality, VirtualIndex, ThisAdjustment, Flags
, IsLocalToUnit, IsDefinition, IsOptimized, Ops), Storage, Context
.pImpl->DISubprograms)
513 Ops, Ops.size())return storeImpl(new (Ops.size()) DISubprogram(Context, Storage
, Line, ScopeLine, Virtuality, VirtualIndex, ThisAdjustment, Flags
, IsLocalToUnit, IsDefinition, IsOptimized, Ops), Storage, Context
.pImpl->DISubprograms)
;
514}
515
516bool DISubprogram::describes(const Function *F) const {
517 assert(F && "Invalid function")(static_cast <bool> (F && "Invalid function") ?
void (0) : __assert_fail ("F && \"Invalid function\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 517, __extension__ __PRETTY_FUNCTION__))
;
518 if (F->getSubprogram() == this)
519 return true;
520 StringRef Name = getLinkageName();
521 if (Name.empty())
522 Name = getName();
523 return F->getName() == Name;
524}
525
526DILexicalBlock *DILexicalBlock::getImpl(LLVMContext &Context, Metadata *Scope,
527 Metadata *File, unsigned Line,
528 unsigned Column, StorageType Storage,
529 bool ShouldCreate) {
530 // Fixup column.
531 adjustColumn(Column);
532
533 assert(Scope && "Expected scope")(static_cast <bool> (Scope && "Expected scope")
? void (0) : __assert_fail ("Scope && \"Expected scope\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 533, __extension__ __PRETTY_FUNCTION__))
;
534 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 { (static_cast <bool> (ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? void (0
) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 534, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
535 Metadata *Ops[] = {File, Scope};
536 DEFINE_GETIMPL_STORE(DILexicalBlock, (Line, Column), Ops)return storeImpl(new (array_lengthof(Ops)) DILexicalBlock(Context
, Storage, Line, Column, Ops), Storage, Context.pImpl->DILexicalBlocks
)
;
537}
538
539DILexicalBlockFile *DILexicalBlockFile::getImpl(LLVMContext &Context,
540 Metadata *Scope, Metadata *File,
541 unsigned Discriminator,
542 StorageType Storage,
543 bool ShouldCreate) {
544 assert(Scope && "Expected scope")(static_cast <bool> (Scope && "Expected scope")
? void (0) : __assert_fail ("Scope && \"Expected scope\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 544, __extension__ __PRETTY_FUNCTION__))
;
545 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 { (static_cast <bool> (ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? void (0
) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 545, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
546 Metadata *Ops[] = {File, Scope};
547 DEFINE_GETIMPL_STORE(DILexicalBlockFile, (Discriminator), Ops)return storeImpl(new (array_lengthof(Ops)) DILexicalBlockFile
(Context, Storage, Discriminator, Ops), Storage, Context.pImpl
->DILexicalBlockFiles)
;
548}
549
550DINamespace *DINamespace::getImpl(LLVMContext &Context, Metadata *Scope,
551 MDString *Name, bool ExportSymbols,
552 StorageType Storage, bool ShouldCreate) {
553 assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString"
) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 553, __extension__ __PRETTY_FUNCTION__))
;
554 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 { (static_cast
<bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 554, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
555 // The nullptr is for DIScope's File operand. This should be refactored.
556 Metadata *Ops[] = {nullptr, Scope, Name};
557 DEFINE_GETIMPL_STORE(DINamespace, (ExportSymbols), Ops)return storeImpl(new (array_lengthof(Ops)) DINamespace(Context
, Storage, ExportSymbols, Ops), Storage, Context.pImpl->DINamespaces
)
;
558}
559
560DIModule *DIModule::getImpl(LLVMContext &Context, Metadata *Scope,
561 MDString *Name, MDString *ConfigurationMacros,
562 MDString *IncludePath, MDString *ISysRoot,
563 StorageType Storage, bool ShouldCreate) {
564 assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString"
) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 564, __extension__ __PRETTY_FUNCTION__))
;
565 DEFINE_GETIMPL_LOOKUP(do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIModules, DIModuleInfo::KeyTy(Scope, Name, ConfigurationMacros
, IncludePath, ISysRoot))) return N; if (!ShouldCreate) return
nullptr; } else { (static_cast <bool> (ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? void (0
) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 566, __extension__ __PRETTY_FUNCTION__)); } } while (false)
566 DIModule, (Scope, Name, ConfigurationMacros, IncludePath, ISysRoot))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIModules, DIModuleInfo::KeyTy(Scope, Name, ConfigurationMacros
, IncludePath, ISysRoot))) return N; if (!ShouldCreate) return
nullptr; } else { (static_cast <bool> (ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? void (0
) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 566, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
567 Metadata *Ops[] = {Scope, Name, ConfigurationMacros, IncludePath, ISysRoot};
568 DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIModule, Ops)return storeImpl(new (array_lengthof(Ops)) DIModule(Context, Storage
, Ops), Storage, Context.pImpl->DIModules)
;
569}
570
571DITemplateTypeParameter *DITemplateTypeParameter::getImpl(LLVMContext &Context,
572 MDString *Name,
573 Metadata *Type,
574 StorageType Storage,
575 bool ShouldCreate) {
576 assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString"
) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 576, __extension__ __PRETTY_FUNCTION__))
;
577 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 { (static_cast <bool> (ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? void (0
) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 577, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
578 Metadata *Ops[] = {Name, Type};
579 DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DITemplateTypeParameter, Ops)return storeImpl(new (array_lengthof(Ops)) DITemplateTypeParameter
(Context, Storage, Ops), Storage, Context.pImpl->DITemplateTypeParameters
)
;
580}
581
582DITemplateValueParameter *DITemplateValueParameter::getImpl(
583 LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *Type,
584 Metadata *Value, StorageType Storage, bool ShouldCreate) {
585 assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString"
) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 585, __extension__ __PRETTY_FUNCTION__))
;
586 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 { (static_cast <bool> (ShouldCreate
&& "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 586, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
587 Metadata *Ops[] = {Name, Type, Value};
588 DEFINE_GETIMPL_STORE(DITemplateValueParameter, (Tag), Ops)return storeImpl(new (array_lengthof(Ops)) DITemplateValueParameter
(Context, Storage, Tag, Ops), Storage, Context.pImpl->DITemplateValueParameters
)
;
589}
590
591DIGlobalVariable *
592DIGlobalVariable::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
593 MDString *LinkageName, Metadata *File, unsigned Line,
594 Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
595 Metadata *StaticDataMemberDeclaration,
596 uint32_t AlignInBits, StorageType Storage,
597 bool ShouldCreate) {
598 assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString"
) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 598, __extension__ __PRETTY_FUNCTION__))
;
599 assert(isCanonical(LinkageName) && "Expected canonical MDString")(static_cast <bool> (isCanonical(LinkageName) &&
"Expected canonical MDString") ? void (0) : __assert_fail ("isCanonical(LinkageName) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 599, __extension__ __PRETTY_FUNCTION__))
;
600 DEFINE_GETIMPL_LOOKUP(DIGlobalVariable,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIGlobalVariables, DIGlobalVariableInfo::KeyTy(Scope
, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition
, StaticDataMemberDeclaration, AlignInBits))) return N; if (!
ShouldCreate) return nullptr; } else { (static_cast <bool>
(ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 603, __extension__ __PRETTY_FUNCTION__)); } } while (false)
601 (Scope, Name, LinkageName, File, Line, Type,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIGlobalVariables, DIGlobalVariableInfo::KeyTy(Scope
, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition
, StaticDataMemberDeclaration, AlignInBits))) return N; if (!
ShouldCreate) return nullptr; } else { (static_cast <bool>
(ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 603, __extension__ __PRETTY_FUNCTION__)); } } while (false)
602 IsLocalToUnit, IsDefinition,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIGlobalVariables, DIGlobalVariableInfo::KeyTy(Scope
, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition
, StaticDataMemberDeclaration, AlignInBits))) return N; if (!
ShouldCreate) return nullptr; } else { (static_cast <bool>
(ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 603, __extension__ __PRETTY_FUNCTION__)); } } while (false)
603 StaticDataMemberDeclaration, AlignInBits))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIGlobalVariables, DIGlobalVariableInfo::KeyTy(Scope
, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition
, StaticDataMemberDeclaration, AlignInBits))) return N; if (!
ShouldCreate) return nullptr; } else { (static_cast <bool>
(ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 603, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
604 Metadata *Ops[] = {
605 Scope, Name, File, Type, Name, LinkageName, StaticDataMemberDeclaration};
606 DEFINE_GETIMPL_STORE(DIGlobalVariable,return storeImpl(new (array_lengthof(Ops)) DIGlobalVariable(Context
, Storage, Line, IsLocalToUnit, IsDefinition, AlignInBits, Ops
), Storage, Context.pImpl->DIGlobalVariables)
607 (Line, IsLocalToUnit, IsDefinition, AlignInBits),return storeImpl(new (array_lengthof(Ops)) DIGlobalVariable(Context
, Storage, Line, IsLocalToUnit, IsDefinition, AlignInBits, Ops
), Storage, Context.pImpl->DIGlobalVariables)
608 Ops)return storeImpl(new (array_lengthof(Ops)) DIGlobalVariable(Context
, Storage, Line, IsLocalToUnit, IsDefinition, AlignInBits, Ops
), Storage, Context.pImpl->DIGlobalVariables)
;
609}
610
611DILocalVariable *DILocalVariable::getImpl(LLVMContext &Context, Metadata *Scope,
612 MDString *Name, Metadata *File,
613 unsigned Line, Metadata *Type,
614 unsigned Arg, DIFlags Flags,
615 uint32_t AlignInBits,
616 StorageType Storage,
617 bool ShouldCreate) {
618 // 64K ought to be enough for any frontend.
619 assert(Arg <= UINT16_MAX && "Expected argument number to fit in 16-bits")(static_cast <bool> (Arg <= (65535) && "Expected argument number to fit in 16-bits"
) ? void (0) : __assert_fail ("Arg <= UINT16_MAX && \"Expected argument number to fit in 16-bits\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 619, __extension__ __PRETTY_FUNCTION__))
;
620
621 assert(Scope && "Expected scope")(static_cast <bool> (Scope && "Expected scope")
? void (0) : __assert_fail ("Scope && \"Expected scope\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 621, __extension__ __PRETTY_FUNCTION__))
;
622 assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString"
) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 622, __extension__ __PRETTY_FUNCTION__))
;
623 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 { (static_cast <
bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 625, __extension__ __PRETTY_FUNCTION__)); } } while (false)
624 (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 { (static_cast <
bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 625, __extension__ __PRETTY_FUNCTION__)); } } while (false)
625 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 { (static_cast <
bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 625, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
626 Metadata *Ops[] = {Scope, Name, File, Type};
627 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)
;
628}
629
630Optional<uint64_t> DIVariable::getSizeInBits() const {
631 // This is used by the Verifier so be mindful of broken types.
632 const Metadata *RawType = getRawType();
633 while (RawType) {
634 // Try to get the size directly.
635 if (auto *T = dyn_cast<DIType>(RawType))
636 if (uint64_t Size = T->getSizeInBits())
637 return Size;
638
639 if (auto *DT = dyn_cast<DIDerivedType>(RawType)) {
640 // Look at the base type.
641 RawType = DT->getRawBaseType();
642 continue;
643 }
644
645 // Missing type or size.
646 break;
647 }
648
649 // Fail gracefully.
650 return None;
651}
652
653DIExpression *DIExpression::getImpl(LLVMContext &Context,
654 ArrayRef<uint64_t> Elements,
655 StorageType Storage, bool ShouldCreate) {
656 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 { (static_cast
<bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 656, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
657 DEFINE_GETIMPL_STORE_NO_OPS(DIExpression, (Elements))return storeImpl(new (0u) DIExpression(Context, Storage, Elements
), Storage, Context.pImpl->DIExpressions)
;
658}
659
660unsigned DIExpression::ExprOperand::getSize() const {
661 switch (getOp()) {
662 case dwarf::DW_OP_LLVM_fragment:
663 return 3;
664 case dwarf::DW_OP_constu:
665 case dwarf::DW_OP_plus_uconst:
666 return 2;
667 default:
668 return 1;
669 }
670}
671
672bool DIExpression::isValid() const {
673 for (auto I = expr_op_begin(), E = expr_op_end(); I != E; ++I) {
674 // Check that there's space for the operand.
675 if (I->get() + I->getSize() > E->get())
676 return false;
677
678 // Check that the operand is valid.
679 switch (I->getOp()) {
680 default:
681 return false;
682 case dwarf::DW_OP_LLVM_fragment:
683 // A fragment operator must appear at the end.
684 return I->get() + I->getSize() == E->get();
685 case dwarf::DW_OP_stack_value: {
686 // Must be the last one or followed by a DW_OP_LLVM_fragment.
687 if (I->get() + I->getSize() == E->get())
688 break;
689 auto J = I;
690 if ((++J)->getOp() != dwarf::DW_OP_LLVM_fragment)
691 return false;
692 break;
693 }
694 case dwarf::DW_OP_swap: {
695 // Must be more than one implicit element on the stack.
696
697 // FIXME: A better way to implement this would be to add a local variable
698 // that keeps track of the stack depth and introduce something like a
699 // DW_LLVM_OP_implicit_location as a placeholder for the location this
700 // DIExpression is attached to, or else pass the number of implicit stack
701 // elements into isValid.
702 if (getNumElements() == 1)
703 return false;
704 break;
705 }
706 case dwarf::DW_OP_constu:
707 case dwarf::DW_OP_plus_uconst:
708 case dwarf::DW_OP_plus:
709 case dwarf::DW_OP_minus:
710 case dwarf::DW_OP_mul:
711 case dwarf::DW_OP_div:
712 case dwarf::DW_OP_mod:
713 case dwarf::DW_OP_or:
714 case dwarf::DW_OP_and:
715 case dwarf::DW_OP_xor:
716 case dwarf::DW_OP_shl:
717 case dwarf::DW_OP_shr:
718 case dwarf::DW_OP_shra:
719 case dwarf::DW_OP_deref:
720 case dwarf::DW_OP_xderef:
721 break;
722 }
723 }
724 return true;
725}
726
727Optional<DIExpression::FragmentInfo>
728DIExpression::getFragmentInfo(expr_op_iterator Start, expr_op_iterator End) {
729 for (auto I = Start; I != End; ++I)
730 if (I->getOp() == dwarf::DW_OP_LLVM_fragment) {
731 DIExpression::FragmentInfo Info = {I->getArg(1), I->getArg(0)};
732 return Info;
733 }
734 return None;
735}
736
737void DIExpression::appendOffset(SmallVectorImpl<uint64_t> &Ops,
738 int64_t Offset) {
739 if (Offset > 0) {
740 Ops.push_back(dwarf::DW_OP_plus_uconst);
741 Ops.push_back(Offset);
742 } else if (Offset < 0) {
743 Ops.push_back(dwarf::DW_OP_constu);
744 Ops.push_back(-Offset);
745 Ops.push_back(dwarf::DW_OP_minus);
746 }
747}
748
749bool DIExpression::extractIfOffset(int64_t &Offset) const {
750 if (getNumElements() == 0) {
751 Offset = 0;
752 return true;
753 }
754
755 if (getNumElements() == 2 && Elements[0] == dwarf::DW_OP_plus_uconst) {
756 Offset = Elements[1];
757 return true;
758 }
759
760 if (getNumElements() == 3 && Elements[0] == dwarf::DW_OP_constu) {
761 if (Elements[2] == dwarf::DW_OP_plus) {
762 Offset = Elements[1];
763 return true;
764 }
765 if (Elements[2] == dwarf::DW_OP_minus) {
766 Offset = -Elements[1];
767 return true;
768 }
769 }
770
771 return false;
772}
773
774DIExpression *DIExpression::prepend(const DIExpression *Expr, bool DerefBefore,
775 int64_t Offset, bool DerefAfter,
776 bool StackValue) {
777 SmallVector<uint64_t, 8> Ops;
778 if (DerefBefore)
1
Assuming 'DerefBefore' is 0
2
Taking false branch
779 Ops.push_back(dwarf::DW_OP_deref);
780
781 appendOffset(Ops, Offset);
782 if (DerefAfter)
3
Assuming 'DerefAfter' is 0
4
Taking false branch
783 Ops.push_back(dwarf::DW_OP_deref);
784
785 return doPrepend(Expr, Ops, StackValue);
5
Passing value via 1st parameter 'Expr'
6
Calling 'DIExpression::doPrepend'
786}
787
788DIExpression *DIExpression::doPrepend(const DIExpression *Expr,
789 SmallVectorImpl<uint64_t> &Ops,
790 bool StackValue) {
791 if (Expr)
7
Assuming 'Expr' is null
8
Taking false branch
792 for (auto Op : Expr->expr_ops()) {
793 // A DW_OP_stack_value comes at the end, but before a DW_OP_LLVM_fragment.
794 if (StackValue) {
795 if (Op.getOp() == dwarf::DW_OP_stack_value)
796 StackValue = false;
797 else if (Op.getOp() == dwarf::DW_OP_LLVM_fragment) {
798 Ops.push_back(dwarf::DW_OP_stack_value);
799 StackValue = false;
800 }
801 }
802 Ops.push_back(Op.getOp());
803 for (unsigned I = 0; I < Op.getNumArgs(); ++I)
804 Ops.push_back(Op.getArg(I));
805 }
806 if (StackValue)
9
Assuming 'StackValue' is 0
10
Taking false branch
807 Ops.push_back(dwarf::DW_OP_stack_value);
808 return DIExpression::get(Expr->getContext(), Ops);
11
Called C++ object pointer is null
809}
810
811Optional<DIExpression *> DIExpression::createFragmentExpression(
812 const DIExpression *Expr, unsigned OffsetInBits, unsigned SizeInBits) {
813 SmallVector<uint64_t, 8> Ops;
814 // Copy over the expression, but leave off any trailing DW_OP_LLVM_fragment.
815 if (Expr) {
816 for (auto Op : Expr->expr_ops()) {
817 switch (Op.getOp()) {
818 default: break;
819 case dwarf::DW_OP_plus:
820 case dwarf::DW_OP_minus:
821 // We can't safely split arithmetic into multiple fragments because we
822 // can't express carry-over between fragments.
823 //
824 // FIXME: We *could* preserve the lowest fragment of a constant offset
825 // operation if the offset fits into SizeInBits.
826 return None;
827 case dwarf::DW_OP_LLVM_fragment: {
828 // Make the new offset point into the existing fragment.
829 uint64_t FragmentOffsetInBits = Op.getArg(0);
830 // Op.getArg(0) is FragmentOffsetInBits.
831 // Op.getArg(1) is FragmentSizeInBits.
832 assert((OffsetInBits + SizeInBits <= Op.getArg(0) + Op.getArg(1)) &&(static_cast <bool> ((OffsetInBits + SizeInBits <= Op
.getArg(0) + Op.getArg(1)) && "new fragment outside of original fragment"
) ? void (0) : __assert_fail ("(OffsetInBits + SizeInBits <= Op.getArg(0) + Op.getArg(1)) && \"new fragment outside of original fragment\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 833, __extension__ __PRETTY_FUNCTION__))
833 "new fragment outside of original fragment")(static_cast <bool> ((OffsetInBits + SizeInBits <= Op
.getArg(0) + Op.getArg(1)) && "new fragment outside of original fragment"
) ? void (0) : __assert_fail ("(OffsetInBits + SizeInBits <= Op.getArg(0) + Op.getArg(1)) && \"new fragment outside of original fragment\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 833, __extension__ __PRETTY_FUNCTION__))
;
834 OffsetInBits += FragmentOffsetInBits;
835 continue;
836 }
837 }
838 Ops.push_back(Op.getOp());
839 for (unsigned I = 0; I < Op.getNumArgs(); ++I)
840 Ops.push_back(Op.getArg(I));
841 }
842 }
843 Ops.push_back(dwarf::DW_OP_LLVM_fragment);
844 Ops.push_back(OffsetInBits);
845 Ops.push_back(SizeInBits);
846 return DIExpression::get(Expr->getContext(), Ops);
847}
848
849bool DIExpression::isConstant() const {
850 // Recognize DW_OP_constu C DW_OP_stack_value (DW_OP_LLVM_fragment Len Ofs)?.
851 if (getNumElements() != 3 && getNumElements() != 6)
852 return false;
853 if (getElement(0) != dwarf::DW_OP_constu ||
854 getElement(2) != dwarf::DW_OP_stack_value)
855 return false;
856 if (getNumElements() == 6 && getElement(3) != dwarf::DW_OP_LLVM_fragment)
857 return false;
858 return true;
859}
860
861DIGlobalVariableExpression *
862DIGlobalVariableExpression::getImpl(LLVMContext &Context, Metadata *Variable,
863 Metadata *Expression, StorageType Storage,
864 bool ShouldCreate) {
865 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 { (static_cast <bool> (ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? void (0
) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 865, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
866 Metadata *Ops[] = {Variable, Expression};
867 DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIGlobalVariableExpression, Ops)return storeImpl(new (array_lengthof(Ops)) DIGlobalVariableExpression
(Context, Storage, Ops), Storage, Context.pImpl->DIGlobalVariableExpressions
)
;
868}
869
870DIObjCProperty *DIObjCProperty::getImpl(
871 LLVMContext &Context, MDString *Name, Metadata *File, unsigned Line,
872 MDString *GetterName, MDString *SetterName, unsigned Attributes,
873 Metadata *Type, StorageType Storage, bool ShouldCreate) {
874 assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString"
) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 874, __extension__ __PRETTY_FUNCTION__))
;
875 assert(isCanonical(GetterName) && "Expected canonical MDString")(static_cast <bool> (isCanonical(GetterName) &&
"Expected canonical MDString") ? void (0) : __assert_fail ("isCanonical(GetterName) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 875, __extension__ __PRETTY_FUNCTION__))
;
876 assert(isCanonical(SetterName) && "Expected canonical MDString")(static_cast <bool> (isCanonical(SetterName) &&
"Expected canonical MDString") ? void (0) : __assert_fail ("isCanonical(SetterName) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 876, __extension__ __PRETTY_FUNCTION__))
;
877 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 { (static_cast <
bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 878, __extension__ __PRETTY_FUNCTION__)); } } while (false)
878 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 { (static_cast <
bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 878, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
879 Metadata *Ops[] = {Name, File, GetterName, SetterName, Type};
880 DEFINE_GETIMPL_STORE(DIObjCProperty, (Line, Attributes), Ops)return storeImpl(new (array_lengthof(Ops)) DIObjCProperty(Context
, Storage, Line, Attributes, Ops), Storage, Context.pImpl->
DIObjCPropertys)
;
881}
882
883DIImportedEntity *DIImportedEntity::getImpl(LLVMContext &Context, unsigned Tag,
884 Metadata *Scope, Metadata *Entity,
885 Metadata *File, unsigned Line,
886 MDString *Name, StorageType Storage,
887 bool ShouldCreate) {
888 assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString"
) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 888, __extension__ __PRETTY_FUNCTION__))
;
889 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 { (static_cast <bool> (ShouldCreate
&& "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 890, __extension__ __PRETTY_FUNCTION__)); } } while (false)
890 (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 { (static_cast <bool> (ShouldCreate
&& "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 890, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
891 Metadata *Ops[] = {Scope, Entity, Name, File};
892 DEFINE_GETIMPL_STORE(DIImportedEntity, (Tag, Line), Ops)return storeImpl(new (array_lengthof(Ops)) DIImportedEntity(Context
, Storage, Tag, Line, Ops), Storage, Context.pImpl->DIImportedEntitys
)
;
893}
894
895DIMacro *DIMacro::getImpl(LLVMContext &Context, unsigned MIType,
896 unsigned Line, MDString *Name, MDString *Value,
897 StorageType Storage, bool ShouldCreate) {
898 assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString"
) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 898, __extension__ __PRETTY_FUNCTION__))
;
899 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 { (static_cast
<bool> (ShouldCreate && "Expected non-uniqued nodes to always be created"
) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 899, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
900 Metadata *Ops[] = { Name, Value };
901 DEFINE_GETIMPL_STORE(DIMacro, (MIType, Line), Ops)return storeImpl(new (array_lengthof(Ops)) DIMacro(Context, Storage
, MIType, Line, Ops), Storage, Context.pImpl->DIMacros)
;
902}
903
904DIMacroFile *DIMacroFile::getImpl(LLVMContext &Context, unsigned MIType,
905 unsigned Line, Metadata *File,
906 Metadata *Elements, StorageType Storage,
907 bool ShouldCreate) {
908 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 { (static_cast <bool> (ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? void (0
) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 909, __extension__ __PRETTY_FUNCTION__)); } } while (false)
909 (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 { (static_cast <bool> (ShouldCreate &&
"Expected non-uniqued nodes to always be created") ? void (0
) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\""
, "/build/llvm-toolchain-snapshot-7~svn325874/lib/IR/DebugInfoMetadata.cpp"
, 909, __extension__ __PRETTY_FUNCTION__)); } } while (false)
;
910 Metadata *Ops[] = { File, Elements };
911 DEFINE_GETIMPL_STORE(DIMacroFile, (MIType, Line), Ops)return storeImpl(new (array_lengthof(Ops)) DIMacroFile(Context
, Storage, MIType, Line, Ops), Storage, Context.pImpl->DIMacroFiles
)
;
912}