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) \
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)
60
61 namespace llvm {
62
63 class DITypeRefArray {
64 const MDTuple *N = nullptr;
65
66 public:
67 DITypeRefArray() = default;
DITypeRefArray(const MDTuple * N)68 DITypeRefArray(const MDTuple *N) : N(N) {}
69
70 explicit operator bool() const { return get(); }
71 explicit operator MDTuple *() const { return get(); }
72
get()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.
size()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;
iterator(MDNode::op_iterator I)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.
begin()109 iterator begin() const { return N ? iterator(N->op_begin()) : iterator(); }
end()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.
118 class DINode : public MDNode {
119 friend class LLVMContextImpl;
120 friend class MDNode;
121
122 protected:
123 DINode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
124 ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None)
MDNode(C,ID,Storage,Ops1,Ops2)125 : MDNode(C, ID, Storage, Ops1, Ops2) {
126 assert(Tag < 1u << 16);
127 SubclassData16 = Tag;
128 }
129 ~DINode() = default;
130
getOperandAs(unsigned I)131 template <class Ty> Ty *getOperandAs(unsigned I) const {
132 return cast_or_null<Ty>(getOperand(I));
133 }
134
getStringOperand(unsigned I)135 StringRef getStringOperand(unsigned I) const {
136 if (auto *S = getOperandAs<MDString>(I))
137 return S->getString();
138 return StringRef();
139 }
140
getCanonicalMDString(LLVMContext & Context,StringRef S)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.
setTag(unsigned Tag)148 void setTag(unsigned Tag) { SubclassData16 = Tag; }
149
150 public:
getTag()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)
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
classof(const Metadata * MD)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.
214 class GenericDINode : public DINode {
215 friend class LLVMContextImpl;
216 friend class MDNode;
217
GenericDINode(LLVMContext & C,StorageType Storage,unsigned Hash,unsigned Tag,ArrayRef<Metadata * > Ops1,ArrayRef<Metadata * > Ops2)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 }
~GenericDINode()224 ~GenericDINode() { dropAllReferences(); }
225
setHash(unsigned Hash)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
cloneImpl()240 TempGenericDINode cloneImpl() const {
241 return getTemporary(
242 getContext(), getTag(), getHeader(),
243 SmallVector<Metadata *, 4>(dwarf_op_begin(), dwarf_op_end()));
244 }
245
246 public:
getHash()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.
clone()257 TempGenericDINode clone() const { return cloneImpl(); }
258
getTag()259 unsigned getTag() const { return SubclassData16; }
getHeader()260 StringRef getHeader() const { return getStringOperand(0); }
getRawHeader()261 MDString *getRawHeader() const { return getOperandAs<MDString>(0); }
262
dwarf_op_begin()263 op_iterator dwarf_op_begin() const { return op_begin() + 1; }
dwarf_op_end()264 op_iterator dwarf_op_end() const { return op_end(); }
dwarf_operands()265 op_range dwarf_operands() const {
266 return op_range(dwarf_op_begin(), dwarf_op_end());
267 }
268
getNumDwarfOperands()269 unsigned getNumDwarfOperands() const { return getNumOperands() - 1; }
getDwarfOperand(unsigned I)270 const MDOperand &getDwarfOperand(unsigned I) const {
271 return getOperand(I + 1);
272 }
replaceDwarfOperandWith(unsigned I,Metadata * New)273 void replaceDwarfOperandWith(unsigned I, Metadata *New) {
274 replaceOperandWith(I + 1, New);
275 }
276
classof(const Metadata * MD)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.
286 class DISubrange : public DINode {
287 friend class LLVMContextImpl;
288 friend class MDNode;
289
290 int64_t LowerBound;
291
DISubrange(LLVMContext & C,StorageType Storage,Metadata * Node,int64_t LowerBound,ArrayRef<Metadata * > Ops)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
cloneImpl()307 TempDISubrange cloneImpl() const {
308 return getTemporary(getContext(), getRawCountNode(), getLowerBound());
309 }
310
311 public:
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
clone()318 TempDISubrange clone() const { return cloneImpl(); }
319
getLowerBound()320 int64_t getLowerBound() const { return LowerBound; }
321
getRawCountNode()322 Metadata *getRawCountNode() const {
323 return getOperand(0).get();
324 }
325
326 typedef PointerUnion<ConstantInt*, DIVariable*> CountType;
327
getCount()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
classof(const Metadata * MD)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.
347 class DIEnumerator : public DINode {
348 friend class LLVMContextImpl;
349 friend class MDNode;
350
351 int64_t Value;
DIEnumerator(LLVMContext & C,StorageType Storage,int64_t Value,bool IsUnsigned,ArrayRef<Metadata * > Ops)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
cloneImpl()370 TempDIEnumerator cloneImpl() const {
371 return getTemporary(getContext(), getValue(), isUnsigned(), getName());
372 }
373
374 public:
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
clone()380 TempDIEnumerator clone() const { return cloneImpl(); }
381
getValue()382 int64_t getValue() const { return Value; }
isUnsigned()383 bool isUnsigned() const { return SubclassData32; }
getName()384 StringRef getName() const { return getStringOperand(0); }
385
getRawName()386 MDString *getRawName() const { return getOperandAs<MDString>(0); }
387
classof(const Metadata * MD)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.
399 class DIScope : public DINode {
400 protected:
DIScope(LLVMContext & C,unsigned ID,StorageType Storage,unsigned Tag,ArrayRef<Metadata * > Ops)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
406 public:
getFile()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.
getRawFile()422 Metadata *getRawFile() const {
423 return isa<DIFile>(this) ? const_cast<DIScope *>(this)
424 : static_cast<Metadata *>(getOperand(0));
425 }
426
classof(const Metadata * MD)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.
452 class DIFile : public DIScope {
453 friend class LLVMContextImpl;
454 friend class MDNode;
455
456 public:
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
ChecksumInfoChecksumInfo479 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); }
getKindAsStringChecksumInfo485 StringRef getKindAsString() const { return getChecksumKindAsString(Kind); }
486 };
487
488 private:
489 Optional<ChecksumInfo<MDString *>> Checksum;
490 Optional<MDString *> Source;
491
DIFile(LLVMContext & C,StorageType Storage,Optional<ChecksumInfo<MDString * >> CS,Optional<MDString * > Src,ArrayRef<Metadata * > Ops)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
cloneImpl()518 TempDIFile cloneImpl() const {
519 return getTemporary(getContext(), getFilename(), getDirectory(),
520 getChecksum(), getSource());
521 }
522
523 public:
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
clone()533 TempDIFile clone() const { return cloneImpl(); }
534
getFilename()535 StringRef getFilename() const { return getStringOperand(0); }
getDirectory()536 StringRef getDirectory() const { return getStringOperand(1); }
getChecksum()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 }
getSource()543 Optional<StringRef> getSource() const {
544 return Source ? Optional<StringRef>((*Source)->getString()) : None;
545 }
546
getRawFilename()547 MDString *getRawFilename() const { return getOperandAs<MDString>(0); }
getRawDirectory()548 MDString *getRawDirectory() const { return getOperandAs<MDString>(1); }
getRawChecksum()549 Optional<ChecksumInfo<MDString *>> getRawChecksum() const { return Checksum; }
getRawSource()550 Optional<MDString *> getRawSource() const { return Source; }
551
552 static StringRef getChecksumKindAsString(ChecksumKind CSKind);
553 static Optional<ChecksumKind> getChecksumKind(StringRef CSKindStr);
554
classof(const Metadata * MD)555 static bool classof(const Metadata *MD) {
556 return MD->getMetadataID() == DIFileKind;
557 }
558 };
559
getFilename()560 StringRef DIScope::getFilename() const {
561 if (auto *F = getFile())
562 return F->getFilename();
563 return "";
564 }
565
getDirectory()566 StringRef DIScope::getDirectory() const {
567 if (auto *F = getFile())
568 return F->getDirectory();
569 return "";
570 }
571
getSource()572 Optional<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.
583 class DIType : public DIScope {
584 unsigned Line;
585 DIFlags Flags;
586 uint64_t SizeInBits;
587 uint64_t OffsetInBits;
588 uint32_t AlignInBits;
589
590 protected:
DIType(LLVMContext & C,unsigned ID,StorageType Storage,unsigned Tag,unsigned Line,uint64_t SizeInBits,uint32_t AlignInBits,uint64_t OffsetInBits,DIFlags Flags,ArrayRef<Metadata * > Ops)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
init(unsigned Line,uint64_t SizeInBits,uint32_t AlignInBits,uint64_t OffsetInBits,DIFlags Flags)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.
mutate(unsigned Tag,unsigned Line,uint64_t SizeInBits,uint32_t AlignInBits,uint64_t OffsetInBits,DIFlags Flags)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");
612 setTag(Tag);
613 init(Line, SizeInBits, AlignInBits, OffsetInBits, Flags);
614 }
615
616 public:
clone()617 TempDIType clone() const {
618 return TempDIType(cast<DIType>(MDNode::clone().release()));
619 }
620
getLine()621 unsigned getLine() const { return Line; }
getSizeInBits()622 uint64_t getSizeInBits() const { return SizeInBits; }
getAlignInBits()623 uint32_t getAlignInBits() const { return AlignInBits; }
getAlignInBytes()624 uint32_t getAlignInBytes() const { return getAlignInBits() / CHAR_BIT; }
getOffsetInBits()625 uint64_t getOffsetInBits() const { return OffsetInBits; }
getFlags()626 DIFlags getFlags() const { return Flags; }
627
getScope()628 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
getName()629 StringRef getName() const { return getStringOperand(2); }
630
631
getRawScope()632 Metadata *getRawScope() const { return getOperand(1); }
getRawName()633 MDString *getRawName() const { return getOperandAs<MDString>(2); }
634
635 /// Returns a new temporary DIType with updated Flags
cloneWithFlags(DIFlags NewFlags)636 TempDIType cloneWithFlags(DIFlags NewFlags) const {
637 auto NewTy = clone();
638 NewTy->Flags = NewFlags;
639 return NewTy;
640 }
641
isPrivate()642 bool isPrivate() const {
643 return (getFlags() & FlagAccessibility) == FlagPrivate;
644 }
isProtected()645 bool isProtected() const {
646 return (getFlags() & FlagAccessibility) == FlagProtected;
647 }
isPublic()648 bool isPublic() const {
649 return (getFlags() & FlagAccessibility) == FlagPublic;
650 }
isForwardDecl()651 bool isForwardDecl() const { return getFlags() & FlagFwdDecl; }
isAppleBlockExtension()652 bool isAppleBlockExtension() const { return getFlags() & FlagAppleBlock; }
isBlockByrefStruct()653 bool isBlockByrefStruct() const { return getFlags() & FlagBlockByrefStruct; }
isVirtual()654 bool isVirtual() const { return getFlags() & FlagVirtual; }
isArtificial()655 bool isArtificial() const { return getFlags() & FlagArtificial; }
isObjectPointer()656 bool isObjectPointer() const { return getFlags() & FlagObjectPointer; }
isObjcClassComplete()657 bool isObjcClassComplete() const {
658 return getFlags() & FlagObjcClassComplete;
659 }
isVector()660 bool isVector() const { return getFlags() & FlagVector; }
isBitField()661 bool isBitField() const { return getFlags() & FlagBitField; }
isStaticMember()662 bool isStaticMember() const { return getFlags() & FlagStaticMember; }
isLValueReference()663 bool isLValueReference() const { return getFlags() & FlagLValueReference; }
isRValueReference()664 bool isRValueReference() const { return getFlags() & FlagRValueReference; }
isTypePassByValue()665 bool isTypePassByValue() const { return getFlags() & FlagTypePassByValue; }
isTypePassByReference()666 bool isTypePassByReference() const {
667 return getFlags() & FlagTypePassByReference;
668 }
isBigEndian()669 bool isBigEndian() const { return getFlags() & FlagBigEndian; }
isLittleEndian()670 bool isLittleEndian() const { return getFlags() & FlagLittleEndian; }
671
classof(const Metadata * MD)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.
689 class DIBasicType : public DIType {
690 friend class LLVMContextImpl;
691 friend class MDNode;
692
693 unsigned Encoding;
694
DIBasicType(LLVMContext & C,StorageType Storage,unsigned Tag,uint64_t SizeInBits,uint32_t AlignInBits,unsigned Encoding,DIFlags Flags,ArrayRef<Metadata * > Ops)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
cloneImpl()718 TempDIBasicType cloneImpl() const {
719 return getTemporary(getContext(), getTag(), getName(), getSizeInBits(),
720 getAlignInBits(), getEncoding(), getFlags());
721 }
722
723 public:
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
clone()735 TempDIBasicType clone() const { return cloneImpl(); }
736
getEncoding()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
classof(const Metadata * MD)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.).
756 class 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
DIDerivedType(LLVMContext & C,StorageType Storage,unsigned Tag,unsigned Line,uint64_t SizeInBits,uint32_t AlignInBits,uint64_t OffsetInBits,Optional<unsigned> DWARFAddressSpace,DIFlags Flags,ArrayRef<Metadata * > Ops)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
cloneImpl()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
799 public:
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
clone()820 TempDIDerivedType clone() const { return cloneImpl(); }
821
822 /// Get the base type this is derived from.
getBaseType()823 DIType *getBaseType() const { return cast_or_null<DIType>(getRawBaseType()); }
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.
getDWARFAddressSpace()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).
getExtraData()838 Metadata *getExtraData() const { return getRawExtraData(); }
getRawExtraData()839 Metadata *getRawExtraData() const { return getOperand(4); }
840
841 /// Get casted version of extra data.
842 /// @{
getClassType()843 DIType *getClassType() const {
844 assert(getTag() == dwarf::DW_TAG_ptr_to_member_type);
845 return cast_or_null<DIType>(getExtraData());
846 }
847
getObjCProperty()848 DIObjCProperty *getObjCProperty() const {
849 return dyn_cast_or_null<DIObjCProperty>(getExtraData());
850 }
851
getVBPtrOffset()852 uint32_t getVBPtrOffset() const {
853 assert(getTag() == dwarf::DW_TAG_inheritance);
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
getStorageOffsetInBits()860 Constant *getStorageOffsetInBits() const {
861 assert(getTag() == dwarf::DW_TAG_member && isBitField());
862 if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
863 return C->getValue();
864 return nullptr;
865 }
866
getConstant()867 Constant *getConstant() const {
868 assert(getTag() == dwarf::DW_TAG_member && isStaticMember());
869 if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
870 return C->getValue();
871 return nullptr;
872 }
getDiscriminantValue()873 Constant *getDiscriminantValue() const {
874 assert(getTag() == dwarf::DW_TAG_member && !isStaticMember());
875 if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
876 return C->getValue();
877 return nullptr;
878 }
879 /// @}
880
classof(const Metadata * MD)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.
890 class DICompositeType : public DIType {
891 friend class LLVMContextImpl;
892 friend class MDNode;
893
894 unsigned RuntimeLang;
895
DICompositeType(LLVMContext & C,StorageType Storage,unsigned Tag,unsigned Line,unsigned RuntimeLang,uint64_t SizeInBits,uint32_t AlignInBits,uint64_t OffsetInBits,DIFlags Flags,ArrayRef<Metadata * > Ops)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.
mutate(unsigned Tag,unsigned Line,unsigned RuntimeLang,uint64_t SizeInBits,uint32_t AlignInBits,uint64_t OffsetInBits,DIFlags Flags)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");
910 assert(getRawIdentifier() && "Only ODR-uniqued nodes should mutate");
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
cloneImpl()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
946 public:
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
clone()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
getBaseType()1008 DIType *getBaseType() const { return cast_or_null<DIType>(getRawBaseType()); }
getElements()1009 DINodeArray getElements() const {
1010 return cast_or_null<MDTuple>(getRawElements());
1011 }
getVTableHolder()1012 DIType *getVTableHolder() const {
1013 return cast_or_null<DIType>(getRawVTableHolder());
1014 }
getTemplateParams()1015 DITemplateParameterArray getTemplateParams() const {
1016 return cast_or_null<MDTuple>(getRawTemplateParams());
1017 }
getIdentifier()1018 StringRef getIdentifier() const { return getStringOperand(7); }
getRuntimeLang()1019 unsigned getRuntimeLang() const { return RuntimeLang; }
1020
getRawBaseType()1021 Metadata *getRawBaseType() const { return getOperand(3); }
getRawElements()1022 Metadata *getRawElements() const { return getOperand(4); }
getRawVTableHolder()1023 Metadata *getRawVTableHolder() const { return getOperand(5); }
getRawTemplateParams()1024 Metadata *getRawTemplateParams() const { return getOperand(6); }
getRawIdentifier()1025 MDString *getRawIdentifier() const { return getOperandAs<MDString>(7); }
getRawDiscriminator()1026 Metadata *getRawDiscriminator() const { return getOperand(8); }
getDiscriminator()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 /// @{
replaceElements(DINodeArray Elements)1035 void replaceElements(DINodeArray Elements) {
1036 #ifndef NDEBUG
1037 for (DINode *Op : getElements())
1038 assert(is_contained(Elements->operands(), Op) &&
1039 "Lost a member during member list replacement");
1040 #endif
1041 replaceOperandWith(4, Elements.get());
1042 }
1043
replaceVTableHolder(DIType * VTableHolder)1044 void replaceVTableHolder(DIType *VTableHolder) {
1045 replaceOperandWith(5, VTableHolder);
1046 }
1047
replaceTemplateParams(DITemplateParameterArray TemplateParams)1048 void replaceTemplateParams(DITemplateParameterArray TemplateParams) {
1049 replaceOperandWith(6, TemplateParams.get());
1050 }
1051 /// @}
1052
classof(const Metadata * MD)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.
1061 class 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
DISubroutineType(LLVMContext & C,StorageType Storage,DIFlags Flags,uint8_t CC,ArrayRef<Metadata * > Ops)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
cloneImpl()1087 TempDISubroutineType cloneImpl() const {
1088 return getTemporary(getContext(), getFlags(), getCC(), getTypeArray());
1089 }
1090
1091 public:
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
clone()1099 TempDISubroutineType clone() const { return cloneImpl(); }
1100
getCC()1101 uint8_t getCC() const { return CC; }
1102
getTypeArray()1103 DITypeRefArray getTypeArray() const {
1104 return cast_or_null<MDTuple>(getRawTypeArray());
1105 }
1106
getRawTypeArray()1107 Metadata *getRawTypeArray() const { return getOperand(3); }
1108
classof(const Metadata * MD)1109 static bool classof(const Metadata *MD) {
1110 return MD->getMetadataID() == DISubroutineTypeKind;
1111 }
1112 };
1113
1114 /// Compile unit.
1115 class DICompileUnit : public DIScope {
1116 friend class LLVMContextImpl;
1117 friend class MDNode;
1118
1119 public:
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
1140 private:
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
DICompileUnit(LLVMContext & C,StorageType Storage,unsigned SourceLanguage,bool IsOptimized,unsigned RuntimeVersion,unsigned EmissionKind,uint64_t DWOId,bool SplitDebugInlining,bool DebugInfoForProfiling,unsigned NameTableKind,bool RangesBaseAddress,ArrayRef<Metadata * > Ops)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);
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
cloneImpl()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
1206 public:
1207 static void get() = delete;
1208 static void getIfExists() = delete;
1209
1210 DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(
1211 DICompileUnit,
1212 (unsigned SourceLanguage, DIFile *File, StringRef Producer,
1213 bool IsOptimized, StringRef Flags, unsigned RuntimeVersion,
1214 StringRef SplitDebugFilename, DebugEmissionKind EmissionKind,
1215 DICompositeTypeArray EnumTypes, DIScopeArray RetainedTypes,
1216 DIGlobalVariableExpressionArray GlobalVariables,
1217 DIImportedEntityArray ImportedEntities, DIMacroNodeArray Macros,
1218 uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
1219 DebugNameTableKind NameTableKind, bool RangesBaseAddress),
1220 (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion,
1221 SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
1222 GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining,
1223 DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress))
1224 DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(
1225 DICompileUnit,
1226 (unsigned SourceLanguage, Metadata *File, MDString *Producer,
1227 bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
1228 MDString *SplitDebugFilename, unsigned EmissionKind, Metadata *EnumTypes,
1229 Metadata *RetainedTypes, Metadata *GlobalVariables,
1230 Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId,
1231 bool SplitDebugInlining, bool DebugInfoForProfiling,
1232 unsigned NameTableKind, bool RangesBaseAddress),
1233 (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion,
1234 SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
1235 GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining,
1236 DebugInfoForProfiling, NameTableKind, RangesBaseAddress))
1237
clone()1238 TempDICompileUnit clone() const { return cloneImpl(); }
1239
getSourceLanguage()1240 unsigned getSourceLanguage() const { return SourceLanguage; }
isOptimized()1241 bool isOptimized() const { return IsOptimized; }
getRuntimeVersion()1242 unsigned getRuntimeVersion() const { return RuntimeVersion; }
getEmissionKind()1243 DebugEmissionKind getEmissionKind() const {
1244 return (DebugEmissionKind)EmissionKind;
1245 }
isDebugDirectivesOnly()1246 bool isDebugDirectivesOnly() const {
1247 return EmissionKind == DebugDirectivesOnly;
1248 }
getDebugInfoForProfiling()1249 bool getDebugInfoForProfiling() const { return DebugInfoForProfiling; }
getNameTableKind()1250 DebugNameTableKind getNameTableKind() const {
1251 return (DebugNameTableKind)NameTableKind;
1252 }
getRangesBaseAddress()1253 bool getRangesBaseAddress() const {
1254 return RangesBaseAddress; }
getProducer()1255 StringRef getProducer() const {
1256 return getStringOperand(1); }
getFlags()1257 StringRef getFlags() const {
1258 return getStringOperand(2); }
getSplitDebugFilename()1259 StringRef getSplitDebugFilename() const {
1260 return getStringOperand(3); }
getEnumTypes()1261 DICompositeTypeArray getEnumTypes() const {
1262 return cast_or_null<MDTuple>(getRawEnumTypes());
1263 }
getRetainedTypes()1264 DIScopeArray getRetainedTypes() const {
1265 return cast_or_null<MDTuple>(getRawRetainedTypes());
1266 }
getGlobalVariables()1267 DIGlobalVariableExpressionArray getGlobalVariables() const {
1268 return cast_or_null<MDTuple>(getRawGlobalVariables());
1269 }
getImportedEntities()1270 DIImportedEntityArray getImportedEntities() const {
1271 return cast_or_null<MDTuple>(getRawImportedEntities());
1272 }
getMacros()1273 DIMacroNodeArray getMacros() const {
1274 return cast_or_null<MDTuple>(getRawMacros());
1275 }
getDWOId()1276 uint64_t getDWOId() const { return DWOId; }
setDWOId(uint64_t DwoId)1277 void setDWOId(uint64_t DwoId) { DWOId = DwoId; }
getSplitDebugInlining()1278 bool getSplitDebugInlining() const { return SplitDebugInlining; }
setSplitDebugInlining(bool SplitDebugInlining)1279 void setSplitDebugInlining(bool SplitDebugInlining) {
1280 this->SplitDebugInlining = SplitDebugInlining;
1281 }
1282
getRawProducer()1283 MDString *getRawProducer() const { return getOperandAs<MDString>(1); }
getRawFlags()1284 MDString *getRawFlags() const { return getOperandAs<MDString>(2); }
getRawSplitDebugFilename()1285 MDString *getRawSplitDebugFilename() const {
1286 return getOperandAs<MDString>(3);
1287 }
getRawEnumTypes()1288 Metadata *getRawEnumTypes() const { return getOperand(4); }
getRawRetainedTypes()1289 Metadata *getRawRetainedTypes() const { return getOperand(5); }
getRawGlobalVariables()1290 Metadata *getRawGlobalVariables() const { return getOperand(6); }
getRawImportedEntities()1291 Metadata *getRawImportedEntities() const { return getOperand(7); }
getRawMacros()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 /// @{
replaceEnumTypes(DICompositeTypeArray N)1300 void replaceEnumTypes(DICompositeTypeArray N) {
1301 replaceOperandWith(4, N.get());
1302 }
replaceRetainedTypes(DITypeArray N)1303 void replaceRetainedTypes(DITypeArray N) {
1304 replaceOperandWith(5, N.get());
1305 }
replaceGlobalVariables(DIGlobalVariableExpressionArray N)1306 void replaceGlobalVariables(DIGlobalVariableExpressionArray N) {
1307 replaceOperandWith(6, N.get());
1308 }
replaceImportedEntities(DIImportedEntityArray N)1309 void replaceImportedEntities(DIImportedEntityArray N) {
1310 replaceOperandWith(7, N.get());
1311 }
replaceMacros(DIMacroNodeArray N)1312 void replaceMacros(DIMacroNodeArray N) { replaceOperandWith(8, N.get()); }
1313 /// @}
1314
classof(const Metadata * MD)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.
1325 class DILocalScope : public DIScope {
1326 protected:
DILocalScope(LLVMContext & C,unsigned ID,StorageType Storage,unsigned Tag,ArrayRef<Metadata * > Ops)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
1332 public:
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
classof(const Metadata * MD)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.
1355 class 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);
~DILocation()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
getPrefixEncodingFromUnsigned(unsigned U)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.
getUnsignedFromPrefixEncoding(unsigned U)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.
getNextComponentInDiscriminator(unsigned D)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
cloneImpl()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
encodeComponent(unsigned C)1408 static unsigned encodeComponent(unsigned C) {
1409 return (C == 0) ? 1U : (getPrefixEncodingFromUnsigned(C) << 1);
1410 }
1411
encodingBits(unsigned C)1412 static unsigned encodingBits(unsigned C) {
1413 return (C == 0) ? 1 : (C > 0x1f ? 14 : 7);
1414 }
1415
1416 public:
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.
clone()1431 TempDILocation clone() const { return cloneImpl(); }
1432
getLine()1433 unsigned getLine() const { return SubclassData32; }
getColumn()1434 unsigned getColumn() const { return SubclassData16; }
getScope()1435 DILocalScope *getScope() const { return cast<DILocalScope>(getRawScope()); }
1436
getInlinedAt()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.
isImplicitCode()1447 bool isImplicitCode() const { return ImplicitCode; }
setImplicitCode(bool ImplicitCode)1448 void setImplicitCode(bool ImplicitCode) { this->ImplicitCode = ImplicitCode; }
1449
getFile()1450 DIFile *getFile() const { return getScope()->getFile(); }
getFilename()1451 StringRef getFilename() const { return getScope()->getFilename(); }
getDirectory()1452 StringRef getDirectory() const { return getScope()->getDirectory(); }
getSource()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.
getInlinedAtScope()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.
getBaseDiscriminatorFromDiscriminator(unsigned 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.
getDuplicationFactorFromDiscriminator(unsigned D)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.
getCopyIdentifierFromDiscriminator(unsigned D)1574 static unsigned getCopyIdentifierFromDiscriminator(unsigned D) {
1575 return getUnsignedFromPrefixEncoding(getNextComponentInDiscriminator(
1576 getNextComponentInDiscriminator(D)));
1577 }
1578
1579
getRawScope()1580 Metadata *getRawScope() const { return getOperand(0); }
getRawInlinedAt()1581 Metadata *getRawInlinedAt() const {
1582 if (getNumOperands() == 2)
1583 return getOperand(1);
1584 return nullptr;
1585 }
1586
classof(const Metadata * MD)1587 static bool classof(const Metadata *MD) {
1588 return MD->getMetadataID() == DILocationKind;
1589 }
1590 };
1591
1592 /// Subprogram description.
1593 class 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
1606 public:
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)
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
1645 private:
1646 DIFlags Flags;
1647 DISPFlags SPFlags;
1648
DISubprogram(LLVMContext & C,StorageType Storage,unsigned Line,unsigned ScopeLine,unsigned VirtualIndex,int ThisAdjustment,DIFlags Flags,DISPFlags SPFlags,ArrayRef<Metadata * > Ops)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
cloneImpl()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
1695 public:
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
clone()1721 TempDISubprogram clone() const { return cloneImpl(); }
1722
1723 /// Returns a new temporary DISubprogram with updated Flags
cloneWithFlags(DIFlags NewFlags)1724 TempDISubprogram cloneWithFlags(DIFlags NewFlags) const {
1725 auto NewSP = clone();
1726 NewSP->Flags = NewFlags;
1727 return NewSP;
1728 }
1729
1730 public:
getLine()1731 unsigned getLine() const { return Line; }
getVirtuality()1732 unsigned getVirtuality() const { return getSPFlags() & SPFlagVirtuality; }
getVirtualIndex()1733 unsigned getVirtualIndex() const { return VirtualIndex; }
getThisAdjustment()1734 int getThisAdjustment() const { return ThisAdjustment; }
getScopeLine()1735 unsigned getScopeLine() const { return ScopeLine; }
getFlags()1736 DIFlags getFlags() const { return Flags; }
getSPFlags()1737 DISPFlags getSPFlags() const { return SPFlags; }
isLocalToUnit()1738 bool isLocalToUnit() const { return getSPFlags() & SPFlagLocalToUnit; }
isDefinition()1739 bool isDefinition() const { return getSPFlags() & SPFlagDefinition; }
isOptimized()1740 bool isOptimized() const { return getSPFlags() & SPFlagOptimized; }
isMainSubprogram()1741 bool isMainSubprogram() const { return getSPFlags() & SPFlagMainSubprogram; }
1742
isArtificial()1743 bool isArtificial() const { return getFlags() & FlagArtificial; }
isPrivate()1744 bool isPrivate() const {
1745 return (getFlags() & FlagAccessibility) == FlagPrivate;
1746 }
isProtected()1747 bool isProtected() const {
1748 return (getFlags() & FlagAccessibility) == FlagProtected;
1749 }
isPublic()1750 bool isPublic() const {
1751 return (getFlags() & FlagAccessibility) == FlagPublic;
1752 }
isExplicit()1753 bool isExplicit() const { return getFlags() & FlagExplicit; }
isPrototyped()1754 bool isPrototyped() const { return getFlags() & FlagPrototyped; }
areAllCallsDescribed()1755 bool areAllCallsDescribed() const {
1756 return getFlags() & FlagAllCallsDescribed;
1757 }
isPure()1758 bool isPure() const { return getSPFlags() & SPFlagPure; }
isElemental()1759 bool isElemental() const { return getSPFlags() & SPFlagElemental; }
isRecursive()1760 bool isRecursive() const { return getSPFlags() & SPFlagRecursive; }
1761
1762 /// Check if this is reference-qualified.
1763 ///
1764 /// Return true if this subprogram is a C++11 reference-qualified non-static
1765 /// member function (void foo() &).
isLValueReference()1766 bool isLValueReference() const { return getFlags() & FlagLValueReference; }
1767
1768 /// Check if this is rvalue-reference-qualified.
1769 ///
1770 /// Return true if this subprogram is a C++11 rvalue-reference-qualified
1771 /// non-static member function (void foo() &&).
isRValueReference()1772 bool isRValueReference() const { return getFlags() & FlagRValueReference; }
1773
1774 /// Check if this is marked as noreturn.
1775 ///
1776 /// Return true if this subprogram is C++11 noreturn or C11 _Noreturn
isNoReturn()1777 bool isNoReturn() const { return getFlags() & FlagNoReturn; }
1778
1779 // Check if this routine is a compiler-generated thunk.
1780 //
1781 // Returns true if this subprogram is a thunk generated by the compiler.
isThunk()1782 bool isThunk() const { return getFlags() & FlagThunk; }
1783
getScope()1784 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
1785
getName()1786 StringRef getName() const { return getStringOperand(2); }
getLinkageName()1787 StringRef getLinkageName() const { return getStringOperand(3); }
1788
getType()1789 DISubroutineType *getType() const {
1790 return cast_or_null<DISubroutineType>(getRawType());
1791 }
getContainingType()1792 DIType *getContainingType() const {
1793 return cast_or_null<DIType>(getRawContainingType());
1794 }
1795
getUnit()1796 DICompileUnit *getUnit() const {
1797 return cast_or_null<DICompileUnit>(getRawUnit());
1798 }
replaceUnit(DICompileUnit * CU)1799 void replaceUnit(DICompileUnit *CU) { replaceOperandWith(5, CU); }
getTemplateParams()1800 DITemplateParameterArray getTemplateParams() const {
1801 return cast_or_null<MDTuple>(getRawTemplateParams());
1802 }
getDeclaration()1803 DISubprogram *getDeclaration() const {
1804 return cast_or_null<DISubprogram>(getRawDeclaration());
1805 }
getRetainedNodes()1806 DINodeArray getRetainedNodes() const {
1807 return cast_or_null<MDTuple>(getRawRetainedNodes());
1808 }
getThrownTypes()1809 DITypeArray getThrownTypes() const {
1810 return cast_or_null<MDTuple>(getRawThrownTypes());
1811 }
1812
getRawScope()1813 Metadata *getRawScope() const { return getOperand(1); }
getRawName()1814 MDString *getRawName() const { return getOperandAs<MDString>(2); }
getRawLinkageName()1815 MDString *getRawLinkageName() const { return getOperandAs<MDString>(3); }
getRawType()1816 Metadata *getRawType() const { return getOperand(4); }
getRawUnit()1817 Metadata *getRawUnit() const { return getOperand(5); }
getRawDeclaration()1818 Metadata *getRawDeclaration() const { return getOperand(6); }
getRawRetainedNodes()1819 Metadata *getRawRetainedNodes() const { return getOperand(7); }
getRawContainingType()1820 Metadata *getRawContainingType() const {
1821 return getNumOperands() > 8 ? getOperandAs<Metadata>(8) : nullptr;
1822 }
getRawTemplateParams()1823 Metadata *getRawTemplateParams() const {
1824 return getNumOperands() > 9 ? getOperandAs<Metadata>(9) : nullptr;
1825 }
getRawThrownTypes()1826 Metadata *getRawThrownTypes() const {
1827 return getNumOperands() > 10 ? getOperandAs<Metadata>(10) : nullptr;
1828 }
1829
1830 /// Check if this subprogram describes the given function.
1831 ///
1832 /// FIXME: Should this be looking through bitcasts?
1833 bool describes(const Function *F) const;
1834
classof(const Metadata * MD)1835 static bool classof(const Metadata *MD) {
1836 return MD->getMetadataID() == DISubprogramKind;
1837 }
1838 };
1839
1840 class DILexicalBlockBase : public DILocalScope {
1841 protected:
DILexicalBlockBase(LLVMContext & C,unsigned ID,StorageType Storage,ArrayRef<Metadata * > Ops)1842 DILexicalBlockBase(LLVMContext &C, unsigned ID, StorageType Storage,
1843 ArrayRef<Metadata *> Ops)
1844 : DILocalScope(C, ID, Storage, dwarf::DW_TAG_lexical_block, Ops) {}
1845 ~DILexicalBlockBase() = default;
1846
1847 public:
getScope()1848 DILocalScope *getScope() const { return cast<DILocalScope>(getRawScope()); }
1849
getRawScope()1850 Metadata *getRawScope() const { return getOperand(1); }
1851
classof(const Metadata * MD)1852 static bool classof(const Metadata *MD) {
1853 return MD->getMetadataID() == DILexicalBlockKind ||
1854 MD->getMetadataID() == DILexicalBlockFileKind;
1855 }
1856 };
1857
1858 class DILexicalBlock : public DILexicalBlockBase {
1859 friend class LLVMContextImpl;
1860 friend class MDNode;
1861
1862 unsigned Line;
1863 uint16_t Column;
1864
DILexicalBlock(LLVMContext & C,StorageType Storage,unsigned Line,unsigned Column,ArrayRef<Metadata * > Ops)1865 DILexicalBlock(LLVMContext &C, StorageType Storage, unsigned Line,
1866 unsigned Column, ArrayRef<Metadata *> Ops)
1867 : DILexicalBlockBase(C, DILexicalBlockKind, Storage, Ops), Line(Line),
1868 Column(Column) {
1869 assert(Column < (1u << 16) && "Expected 16-bit column");
1870 }
1871 ~DILexicalBlock() = default;
1872
1873 static DILexicalBlock *getImpl(LLVMContext &Context, DILocalScope *Scope,
1874 DIFile *File, unsigned Line, unsigned Column,
1875 StorageType Storage,
1876 bool ShouldCreate = true) {
1877 return getImpl(Context, static_cast<Metadata *>(Scope),
1878 static_cast<Metadata *>(File), Line, Column, Storage,
1879 ShouldCreate);
1880 }
1881
1882 static DILexicalBlock *getImpl(LLVMContext &Context, Metadata *Scope,
1883 Metadata *File, unsigned Line, unsigned Column,
1884 StorageType Storage, bool ShouldCreate = true);
1885
cloneImpl()1886 TempDILexicalBlock cloneImpl() const {
1887 return getTemporary(getContext(), getScope(), getFile(), getLine(),
1888 getColumn());
1889 }
1890
1891 public:
1892 DEFINE_MDNODE_GET(DILexicalBlock, (DILocalScope * Scope, DIFile *File,
1893 unsigned Line, unsigned Column),
1894 (Scope, File, Line, Column))
1895 DEFINE_MDNODE_GET(DILexicalBlock, (Metadata * Scope, Metadata *File,
1896 unsigned Line, unsigned Column),
1897 (Scope, File, Line, Column))
1898
clone()1899 TempDILexicalBlock clone() const { return cloneImpl(); }
1900
getLine()1901 unsigned getLine() const { return Line; }
getColumn()1902 unsigned getColumn() const { return Column; }
1903
classof(const Metadata * MD)1904 static bool classof(const Metadata *MD) {
1905 return MD->getMetadataID() == DILexicalBlockKind;
1906 }
1907 };
1908
1909 class DILexicalBlockFile : public DILexicalBlockBase {
1910 friend class LLVMContextImpl;
1911 friend class MDNode;
1912
1913 unsigned Discriminator;
1914
DILexicalBlockFile(LLVMContext & C,StorageType Storage,unsigned Discriminator,ArrayRef<Metadata * > Ops)1915 DILexicalBlockFile(LLVMContext &C, StorageType Storage,
1916 unsigned Discriminator, ArrayRef<Metadata *> Ops)
1917 : DILexicalBlockBase(C, DILexicalBlockFileKind, Storage, Ops),
1918 Discriminator(Discriminator) {}
1919 ~DILexicalBlockFile() = default;
1920
1921 static DILexicalBlockFile *getImpl(LLVMContext &Context, DILocalScope *Scope,
1922 DIFile *File, unsigned Discriminator,
1923 StorageType Storage,
1924 bool ShouldCreate = true) {
1925 return getImpl(Context, static_cast<Metadata *>(Scope),
1926 static_cast<Metadata *>(File), Discriminator, Storage,
1927 ShouldCreate);
1928 }
1929
1930 static DILexicalBlockFile *getImpl(LLVMContext &Context, Metadata *Scope,
1931 Metadata *File, unsigned Discriminator,
1932 StorageType Storage,
1933 bool ShouldCreate = true);
1934
cloneImpl()1935 TempDILexicalBlockFile cloneImpl() const {
1936 return getTemporary(getContext(), getScope(), getFile(),
1937 getDiscriminator());
1938 }
1939
1940 public:
1941 DEFINE_MDNODE_GET(DILexicalBlockFile, (DILocalScope * Scope, DIFile *File,
1942 unsigned Discriminator),
1943 (Scope, File, Discriminator))
1944 DEFINE_MDNODE_GET(DILexicalBlockFile,
1945 (Metadata * Scope, Metadata *File, unsigned Discriminator),
1946 (Scope, File, Discriminator))
1947
clone()1948 TempDILexicalBlockFile clone() const { return cloneImpl(); }
1949
1950 // TODO: Remove these once they're gone from DILexicalBlockBase.
1951 unsigned getLine() const = delete;
1952 unsigned getColumn() const = delete;
1953
getDiscriminator()1954 unsigned getDiscriminator() const { return Discriminator; }
1955
classof(const Metadata * MD)1956 static bool classof(const Metadata *MD) {
1957 return MD->getMetadataID() == DILexicalBlockFileKind;
1958 }
1959 };
1960
getDiscriminator()1961 unsigned DILocation::getDiscriminator() const {
1962 if (auto *F = dyn_cast<DILexicalBlockFile>(getScope()))
1963 return F->getDiscriminator();
1964 return 0;
1965 }
1966
1967 const DILocation *
cloneWithDiscriminator(unsigned Discriminator)1968 DILocation::cloneWithDiscriminator(unsigned Discriminator) const {
1969 DIScope *Scope = getScope();
1970 // Skip all parent DILexicalBlockFile that already have a discriminator
1971 // assigned. We do not want to have nested DILexicalBlockFiles that have
1972 // mutliple discriminators because only the leaf DILexicalBlockFile's
1973 // dominator will be used.
1974 for (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope);
1975 LBF && LBF->getDiscriminator() != 0;
1976 LBF = dyn_cast<DILexicalBlockFile>(Scope))
1977 Scope = LBF->getScope();
1978 DILexicalBlockFile *NewScope =
1979 DILexicalBlockFile::get(getContext(), Scope, getFile(), Discriminator);
1980 return DILocation::get(getContext(), getLine(), getColumn(), NewScope,
1981 getInlinedAt());
1982 }
1983
getBaseDiscriminator()1984 unsigned DILocation::getBaseDiscriminator() const {
1985 return getBaseDiscriminatorFromDiscriminator(getDiscriminator());
1986 }
1987
getDuplicationFactor()1988 unsigned DILocation::getDuplicationFactor() const {
1989 return getDuplicationFactorFromDiscriminator(getDiscriminator());
1990 }
1991
getCopyIdentifier()1992 unsigned DILocation::getCopyIdentifier() const {
1993 return getCopyIdentifierFromDiscriminator(getDiscriminator());
1994 }
1995
cloneWithBaseDiscriminator(unsigned D)1996 Optional<const DILocation *> DILocation::cloneWithBaseDiscriminator(unsigned D) const {
1997 unsigned BD, DF, CI;
1998 decodeDiscriminator(getDiscriminator(), BD, DF, CI);
1999 if (D == BD)
2000 return this;
2001 if (Optional<unsigned> Encoded = encodeDiscriminator(D, DF, CI))
2002 return cloneWithDiscriminator(*Encoded);
2003 return None;
2004 }
2005
cloneByMultiplyingDuplicationFactor(unsigned DF)2006 Optional<const DILocation *> DILocation::cloneByMultiplyingDuplicationFactor(unsigned DF) const {
2007 DF *= getDuplicationFactor();
2008 if (DF <= 1)
2009 return this;
2010
2011 unsigned BD = getBaseDiscriminator();
2012 unsigned CI = getCopyIdentifier();
2013 if (Optional<unsigned> D = encodeDiscriminator(BD, DF, CI))
2014 return cloneWithDiscriminator(*D);
2015 return None;
2016 }
2017
2018 class DINamespace : public DIScope {
2019 friend class LLVMContextImpl;
2020 friend class MDNode;
2021
2022 unsigned ExportSymbols : 1;
2023
DINamespace(LLVMContext & Context,StorageType Storage,bool ExportSymbols,ArrayRef<Metadata * > Ops)2024 DINamespace(LLVMContext &Context, StorageType Storage, bool ExportSymbols,
2025 ArrayRef<Metadata *> Ops)
2026 : DIScope(Context, DINamespaceKind, Storage, dwarf::DW_TAG_namespace,
2027 Ops),
2028 ExportSymbols(ExportSymbols) {}
2029 ~DINamespace() = default;
2030
2031 static DINamespace *getImpl(LLVMContext &Context, DIScope *Scope,
2032 StringRef Name, bool ExportSymbols,
2033 StorageType Storage, bool ShouldCreate = true) {
2034 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
2035 ExportSymbols, Storage, ShouldCreate);
2036 }
2037 static DINamespace *getImpl(LLVMContext &Context, Metadata *Scope,
2038 MDString *Name, bool ExportSymbols,
2039 StorageType Storage, bool ShouldCreate = true);
2040
cloneImpl()2041 TempDINamespace cloneImpl() const {
2042 return getTemporary(getContext(), getScope(), getName(),
2043 getExportSymbols());
2044 }
2045
2046 public:
2047 DEFINE_MDNODE_GET(DINamespace,
2048 (DIScope *Scope, StringRef Name, bool ExportSymbols),
2049 (Scope, Name, ExportSymbols))
2050 DEFINE_MDNODE_GET(DINamespace,
2051 (Metadata *Scope, MDString *Name, bool ExportSymbols),
2052 (Scope, Name, ExportSymbols))
2053
clone()2054 TempDINamespace clone() const { return cloneImpl(); }
2055
getExportSymbols()2056 bool getExportSymbols() const { return ExportSymbols; }
getScope()2057 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
getName()2058 StringRef getName() const { return getStringOperand(2); }
2059
getRawScope()2060 Metadata *getRawScope() const { return getOperand(1); }
getRawName()2061 MDString *getRawName() const { return getOperandAs<MDString>(2); }
2062
classof(const Metadata * MD)2063 static bool classof(const Metadata *MD) {
2064 return MD->getMetadataID() == DINamespaceKind;
2065 }
2066 };
2067
2068 /// A (clang) module that has been imported by the compile unit.
2069 ///
2070 class DIModule : public DIScope {
2071 friend class LLVMContextImpl;
2072 friend class MDNode;
2073
DIModule(LLVMContext & Context,StorageType Storage,ArrayRef<Metadata * > Ops)2074 DIModule(LLVMContext &Context, StorageType Storage, ArrayRef<Metadata *> Ops)
2075 : DIScope(Context, DIModuleKind, Storage, dwarf::DW_TAG_module, Ops) {}
2076 ~DIModule() = default;
2077
2078 static DIModule *getImpl(LLVMContext &Context, DIScope *Scope,
2079 StringRef Name, StringRef ConfigurationMacros,
2080 StringRef IncludePath, StringRef ISysRoot,
2081 StorageType Storage, bool ShouldCreate = true) {
2082 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
2083 getCanonicalMDString(Context, ConfigurationMacros),
2084 getCanonicalMDString(Context, IncludePath),
2085 getCanonicalMDString(Context, ISysRoot),
2086 Storage, ShouldCreate);
2087 }
2088 static DIModule *getImpl(LLVMContext &Context, Metadata *Scope,
2089 MDString *Name, MDString *ConfigurationMacros,
2090 MDString *IncludePath, MDString *ISysRoot,
2091 StorageType Storage, bool ShouldCreate = true);
2092
cloneImpl()2093 TempDIModule cloneImpl() const {
2094 return getTemporary(getContext(), getScope(), getName(),
2095 getConfigurationMacros(), getIncludePath(),
2096 getISysRoot());
2097 }
2098
2099 public:
2100 DEFINE_MDNODE_GET(DIModule, (DIScope *Scope, StringRef Name,
2101 StringRef ConfigurationMacros, StringRef IncludePath,
2102 StringRef ISysRoot),
2103 (Scope, Name, ConfigurationMacros, IncludePath, ISysRoot))
2104 DEFINE_MDNODE_GET(DIModule,
2105 (Metadata *Scope, MDString *Name, MDString *ConfigurationMacros,
2106 MDString *IncludePath, MDString *ISysRoot),
2107 (Scope, Name, ConfigurationMacros, IncludePath, ISysRoot))
2108
clone()2109 TempDIModule clone() const { return cloneImpl(); }
2110
getScope()2111 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
getName()2112 StringRef getName() const { return getStringOperand(1); }
getConfigurationMacros()2113 StringRef getConfigurationMacros() const { return getStringOperand(2); }
getIncludePath()2114 StringRef getIncludePath() const { return getStringOperand(3); }
getISysRoot()2115 StringRef getISysRoot() const { return getStringOperand(4); }
2116
getRawScope()2117 Metadata *getRawScope() const { return getOperand(0); }
getRawName()2118 MDString *getRawName() const { return getOperandAs<MDString>(1); }
getRawConfigurationMacros()2119 MDString *getRawConfigurationMacros() const { return getOperandAs<MDString>(2); }
getRawIncludePath()2120 MDString *getRawIncludePath() const { return getOperandAs<MDString>(3); }
getRawISysRoot()2121 MDString *getRawISysRoot() const { return getOperandAs<MDString>(4); }
2122
classof(const Metadata * MD)2123 static bool classof(const Metadata *MD) {
2124 return MD->getMetadataID() == DIModuleKind;
2125 }
2126 };
2127
2128 /// Base class for template parameters.
2129 class DITemplateParameter : public DINode {
2130 protected:
DITemplateParameter(LLVMContext & Context,unsigned ID,StorageType Storage,unsigned Tag,ArrayRef<Metadata * > Ops)2131 DITemplateParameter(LLVMContext &Context, unsigned ID, StorageType Storage,
2132 unsigned Tag, ArrayRef<Metadata *> Ops)
2133 : DINode(Context, ID, Storage, Tag, Ops) {}
2134 ~DITemplateParameter() = default;
2135
2136 public:
getName()2137 StringRef getName() const { return getStringOperand(0); }
getType()2138 DIType *getType() const { return cast_or_null<DIType>(getRawType()); }
2139
getRawName()2140 MDString *getRawName() const { return getOperandAs<MDString>(0); }
getRawType()2141 Metadata *getRawType() const { return getOperand(1); }
2142
classof(const Metadata * MD)2143 static bool classof(const Metadata *MD) {
2144 return MD->getMetadataID() == DITemplateTypeParameterKind ||
2145 MD->getMetadataID() == DITemplateValueParameterKind;
2146 }
2147 };
2148
2149 class DITemplateTypeParameter : public DITemplateParameter {
2150 friend class LLVMContextImpl;
2151 friend class MDNode;
2152
DITemplateTypeParameter(LLVMContext & Context,StorageType Storage,ArrayRef<Metadata * > Ops)2153 DITemplateTypeParameter(LLVMContext &Context, StorageType Storage,
2154 ArrayRef<Metadata *> Ops)
2155 : DITemplateParameter(Context, DITemplateTypeParameterKind, Storage,
2156 dwarf::DW_TAG_template_type_parameter, Ops) {}
2157 ~DITemplateTypeParameter() = default;
2158
2159 static DITemplateTypeParameter *getImpl(LLVMContext &Context, StringRef Name,
2160 DIType *Type, StorageType Storage,
2161 bool ShouldCreate = true) {
2162 return getImpl(Context, getCanonicalMDString(Context, Name), Type, Storage,
2163 ShouldCreate);
2164 }
2165 static DITemplateTypeParameter *getImpl(LLVMContext &Context, MDString *Name,
2166 Metadata *Type, StorageType Storage,
2167 bool ShouldCreate = true);
2168
cloneImpl()2169 TempDITemplateTypeParameter cloneImpl() const {
2170 return getTemporary(getContext(), getName(), getType());
2171 }
2172
2173 public:
2174 DEFINE_MDNODE_GET(DITemplateTypeParameter, (StringRef Name, DIType *Type),
2175 (Name, Type))
2176 DEFINE_MDNODE_GET(DITemplateTypeParameter, (MDString * Name, Metadata *Type),
2177 (Name, Type))
2178
clone()2179 TempDITemplateTypeParameter clone() const { return cloneImpl(); }
2180
classof(const Metadata * MD)2181 static bool classof(const Metadata *MD) {
2182 return MD->getMetadataID() == DITemplateTypeParameterKind;
2183 }
2184 };
2185
2186 class DITemplateValueParameter : public DITemplateParameter {
2187 friend class LLVMContextImpl;
2188 friend class MDNode;
2189
DITemplateValueParameter(LLVMContext & Context,StorageType Storage,unsigned Tag,ArrayRef<Metadata * > Ops)2190 DITemplateValueParameter(LLVMContext &Context, StorageType Storage,
2191 unsigned Tag, ArrayRef<Metadata *> Ops)
2192 : DITemplateParameter(Context, DITemplateValueParameterKind, Storage, Tag,
2193 Ops) {}
2194 ~DITemplateValueParameter() = default;
2195
2196 static DITemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
2197 StringRef Name, DIType *Type,
2198 Metadata *Value, StorageType Storage,
2199 bool ShouldCreate = true) {
2200 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), Type,
2201 Value, Storage, ShouldCreate);
2202 }
2203 static DITemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
2204 MDString *Name, Metadata *Type,
2205 Metadata *Value, StorageType Storage,
2206 bool ShouldCreate = true);
2207
cloneImpl()2208 TempDITemplateValueParameter cloneImpl() const {
2209 return getTemporary(getContext(), getTag(), getName(), getType(),
2210 getValue());
2211 }
2212
2213 public:
2214 DEFINE_MDNODE_GET(DITemplateValueParameter,
2215 (unsigned Tag, StringRef Name, DIType *Type,
2216 Metadata *Value),
2217 (Tag, Name, Type, Value))
2218 DEFINE_MDNODE_GET(DITemplateValueParameter, (unsigned Tag, MDString *Name,
2219 Metadata *Type, Metadata *Value),
2220 (Tag, Name, Type, Value))
2221
clone()2222 TempDITemplateValueParameter clone() const { return cloneImpl(); }
2223
getValue()2224 Metadata *getValue() const { return getOperand(2); }
2225
classof(const Metadata * MD)2226 static bool classof(const Metadata *MD) {
2227 return MD->getMetadataID() == DITemplateValueParameterKind;
2228 }
2229 };
2230
2231 /// Base class for variables.
2232 class DIVariable : public DINode {
2233 unsigned Line;
2234 uint32_t AlignInBits;
2235
2236 protected:
2237 DIVariable(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Line,
2238 ArrayRef<Metadata *> Ops, uint32_t AlignInBits = 0)
DINode(C,ID,Storage,dwarf::DW_TAG_variable,Ops)2239 : DINode(C, ID, Storage, dwarf::DW_TAG_variable, Ops), Line(Line),
2240 AlignInBits(AlignInBits) {}
2241 ~DIVariable() = default;
2242
2243 public:
getLine()2244 unsigned getLine() const { return Line; }
getScope()2245 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
getName()2246 StringRef getName() const { return getStringOperand(1); }
getFile()2247 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
getType()2248 DIType *getType() const { return cast_or_null<DIType>(getRawType()); }
getAlignInBits()2249 uint32_t getAlignInBits() const { return AlignInBits; }
getAlignInBytes()2250 uint32_t getAlignInBytes() const { return getAlignInBits() / CHAR_BIT; }
2251 /// Determines the size of the variable's type.
2252 Optional<uint64_t> getSizeInBits() const;
2253
2254 /// Return the signedness of this variable's type, or None if this type is
2255 /// neither signed nor unsigned.
getSignedness()2256 Optional<DIBasicType::Signedness> getSignedness() const {
2257 if (auto *BT = dyn_cast<DIBasicType>(getType()))
2258 return BT->getSignedness();
2259 return None;
2260 }
2261
getFilename()2262 StringRef getFilename() const {
2263 if (auto *F = getFile())
2264 return F->getFilename();
2265 return "";
2266 }
2267
getDirectory()2268 StringRef getDirectory() const {
2269 if (auto *F = getFile())
2270 return F->getDirectory();
2271 return "";
2272 }
2273
getSource()2274 Optional<StringRef> getSource() const {
2275 if (auto *F = getFile())
2276 return F->getSource();
2277 return None;
2278 }
2279
getRawScope()2280 Metadata *getRawScope() const { return getOperand(0); }
getRawName()2281 MDString *getRawName() const { return getOperandAs<MDString>(1); }
getRawFile()2282 Metadata *getRawFile() const { return getOperand(2); }
getRawType()2283 Metadata *getRawType() const { return getOperand(3); }
2284
classof(const Metadata * MD)2285 static bool classof(const Metadata *MD) {
2286 return MD->getMetadataID() == DILocalVariableKind ||
2287 MD->getMetadataID() == DIGlobalVariableKind;
2288 }
2289 };
2290
2291 /// DWARF expression.
2292 ///
2293 /// This is (almost) a DWARF expression that modifies the location of a
2294 /// variable, or the location of a single piece of a variable, or (when using
2295 /// DW_OP_stack_value) is the constant variable value.
2296 ///
2297 /// TODO: Co-allocate the expression elements.
2298 /// TODO: Separate from MDNode, or otherwise drop Distinct and Temporary
2299 /// storage types.
2300 class DIExpression : public MDNode {
2301 friend class LLVMContextImpl;
2302 friend class MDNode;
2303
2304 std::vector<uint64_t> Elements;
2305
DIExpression(LLVMContext & C,StorageType Storage,ArrayRef<uint64_t> Elements)2306 DIExpression(LLVMContext &C, StorageType Storage, ArrayRef<uint64_t> Elements)
2307 : MDNode(C, DIExpressionKind, Storage, None),
2308 Elements(Elements.begin(), Elements.end()) {}
2309 ~DIExpression() = default;
2310
2311 static DIExpression *getImpl(LLVMContext &Context,
2312 ArrayRef<uint64_t> Elements, StorageType Storage,
2313 bool ShouldCreate = true);
2314
cloneImpl()2315 TempDIExpression cloneImpl() const {
2316 return getTemporary(getContext(), getElements());
2317 }
2318
2319 public:
2320 DEFINE_MDNODE_GET(DIExpression, (ArrayRef<uint64_t> Elements), (Elements))
2321
clone()2322 TempDIExpression clone() const { return cloneImpl(); }
2323
getElements()2324 ArrayRef<uint64_t> getElements() const { return Elements; }
2325
getNumElements()2326 unsigned getNumElements() const { return Elements.size(); }
2327
getElement(unsigned I)2328 uint64_t getElement(unsigned I) const {
2329 assert(I < Elements.size() && "Index out of range");
2330 return Elements[I];
2331 }
2332
2333 /// Determine whether this represents a standalone constant value.
2334 bool isConstant() const;
2335
2336 using element_iterator = ArrayRef<uint64_t>::iterator;
2337
elements_begin()2338 element_iterator elements_begin() const { return getElements().begin(); }
elements_end()2339 element_iterator elements_end() const { return getElements().end(); }
2340
2341 /// A lightweight wrapper around an expression operand.
2342 ///
2343 /// TODO: Store arguments directly and change \a DIExpression to store a
2344 /// range of these.
2345 class ExprOperand {
2346 const uint64_t *Op = nullptr;
2347
2348 public:
2349 ExprOperand() = default;
ExprOperand(const uint64_t * Op)2350 explicit ExprOperand(const uint64_t *Op) : Op(Op) {}
2351
get()2352 const uint64_t *get() const { return Op; }
2353
2354 /// Get the operand code.
getOp()2355 uint64_t getOp() const { return *Op; }
2356
2357 /// Get an argument to the operand.
2358 ///
2359 /// Never returns the operand itself.
getArg(unsigned I)2360 uint64_t getArg(unsigned I) const { return Op[I + 1]; }
2361
getNumArgs()2362 unsigned getNumArgs() const { return getSize() - 1; }
2363
2364 /// Return the size of the operand.
2365 ///
2366 /// Return the number of elements in the operand (1 + args).
2367 unsigned getSize() const;
2368
2369 /// Append the elements of this operand to \p V.
appendToVector(SmallVectorImpl<uint64_t> & V)2370 void appendToVector(SmallVectorImpl<uint64_t> &V) const {
2371 V.append(get(), get() + getSize());
2372 }
2373 };
2374
2375 /// An iterator for expression operands.
2376 class expr_op_iterator
2377 : public std::iterator<std::input_iterator_tag, ExprOperand> {
2378 ExprOperand Op;
2379
2380 public:
2381 expr_op_iterator() = default;
expr_op_iterator(element_iterator I)2382 explicit expr_op_iterator(element_iterator I) : Op(I) {}
2383
getBase()2384 element_iterator getBase() const { return Op.get(); }
2385 const ExprOperand &operator*() const { return Op; }
2386 const ExprOperand *operator->() const { return &Op; }
2387
2388 expr_op_iterator &operator++() {
2389 increment();
2390 return *this;
2391 }
2392 expr_op_iterator operator++(int) {
2393 expr_op_iterator T(*this);
2394 increment();
2395 return T;
2396 }
2397
2398 /// Get the next iterator.
2399 ///
2400 /// \a std::next() doesn't work because this is technically an
2401 /// input_iterator, but it's a perfectly valid operation. This is an
2402 /// accessor to provide the same functionality.
getNext()2403 expr_op_iterator getNext() const { return ++expr_op_iterator(*this); }
2404
2405 bool operator==(const expr_op_iterator &X) const {
2406 return getBase() == X.getBase();
2407 }
2408 bool operator!=(const expr_op_iterator &X) const {
2409 return getBase() != X.getBase();
2410 }
2411
2412 private:
increment()2413 void increment() { Op = ExprOperand(getBase() + Op.getSize()); }
2414 };
2415
2416 /// Visit the elements via ExprOperand wrappers.
2417 ///
2418 /// These range iterators visit elements through \a ExprOperand wrappers.
2419 /// This is not guaranteed to be a valid range unless \a isValid() gives \c
2420 /// true.
2421 ///
2422 /// \pre \a isValid() gives \c true.
2423 /// @{
expr_op_begin()2424 expr_op_iterator expr_op_begin() const {
2425 return expr_op_iterator(elements_begin());
2426 }
expr_op_end()2427 expr_op_iterator expr_op_end() const {
2428 return expr_op_iterator(elements_end());
2429 }
expr_ops()2430 iterator_range<expr_op_iterator> expr_ops() const {
2431 return {expr_op_begin(), expr_op_end()};
2432 }
2433 /// @}
2434
2435 bool isValid() const;
2436
classof(const Metadata * MD)2437 static bool classof(const Metadata *MD) {
2438 return MD->getMetadataID() == DIExpressionKind;
2439 }
2440
2441 /// Return whether the first element a DW_OP_deref.
startsWithDeref()2442 bool startsWithDeref() const {
2443 return getNumElements() > 0 && getElement(0) == dwarf::DW_OP_deref;
2444 }
2445
2446 /// Holds the characteristics of one fragment of a larger variable.
2447 struct FragmentInfo {
2448 uint64_t SizeInBits;
2449 uint64_t OffsetInBits;
2450 };
2451
2452 /// Retrieve the details of this fragment expression.
2453 static Optional<FragmentInfo> getFragmentInfo(expr_op_iterator Start,
2454 expr_op_iterator End);
2455
2456 /// Retrieve the details of this fragment expression.
getFragmentInfo()2457 Optional<FragmentInfo> getFragmentInfo() const {
2458 return getFragmentInfo(expr_op_begin(), expr_op_end());
2459 }
2460
2461 /// Return whether this is a piece of an aggregate variable.
isFragment()2462 bool isFragment() const { return getFragmentInfo().hasValue(); }
2463
2464 /// Return whether this is an implicit location description.
2465 bool isImplicit() const;
2466
2467 /// Return whether the location is computed on the expression stack, meaning
2468 /// it cannot be a simple register location.
2469 bool isComplex() const;
2470
2471 /// Append \p Ops with operations to apply the \p Offset.
2472 static void appendOffset(SmallVectorImpl<uint64_t> &Ops, int64_t Offset);
2473
2474 /// If this is a constant offset, extract it. If there is no expression,
2475 /// return true with an offset of zero.
2476 bool extractIfOffset(int64_t &Offset) const;
2477
2478 /// Checks if the last 4 elements of the expression are DW_OP_constu <DWARF
2479 /// Address Space> DW_OP_swap DW_OP_xderef and extracts the <DWARF Address
2480 /// Space>.
2481 static const DIExpression *extractAddressClass(const DIExpression *Expr,
2482 unsigned &AddrClass);
2483
2484 /// Used for DIExpression::prepend.
2485 enum PrependOps : uint8_t {
2486 ApplyOffset = 0,
2487 DerefBefore = 1 << 0,
2488 DerefAfter = 1 << 1,
2489 StackValue = 1 << 2,
2490 EntryValue = 1 << 3
2491 };
2492
2493 /// Prepend \p DIExpr with a deref and offset operation and optionally turn it
2494 /// into a stack value or/and an entry value.
2495 static DIExpression *prepend(const DIExpression *Expr, uint8_t Flags,
2496 int64_t Offset = 0);
2497
2498 /// Prepend \p DIExpr with the given opcodes and optionally turn it into a
2499 /// stack value.
2500 static DIExpression *prependOpcodes(const DIExpression *Expr,
2501 SmallVectorImpl<uint64_t> &Ops,
2502 bool StackValue = false,
2503 bool EntryValue = false);
2504
2505 /// Append the opcodes \p Ops to \p DIExpr. Unlike \ref appendToStack, the
2506 /// returned expression is a stack value only if \p DIExpr is a stack value.
2507 /// If \p DIExpr describes a fragment, the returned expression will describe
2508 /// the same fragment.
2509 static DIExpression *append(const DIExpression *Expr, ArrayRef<uint64_t> Ops);
2510
2511 /// Convert \p DIExpr into a stack value if it isn't one already by appending
2512 /// DW_OP_deref if needed, and appending \p Ops to the resulting expression.
2513 /// If \p DIExpr describes a fragment, the returned expression will describe
2514 /// the same fragment.
2515 static DIExpression *appendToStack(const DIExpression *Expr,
2516 ArrayRef<uint64_t> Ops);
2517
2518 /// Create a DIExpression to describe one part of an aggregate variable that
2519 /// is fragmented across multiple Values. The DW_OP_LLVM_fragment operation
2520 /// will be appended to the elements of \c Expr. If \c Expr already contains
2521 /// a \c DW_OP_LLVM_fragment \c OffsetInBits is interpreted as an offset
2522 /// into the existing fragment.
2523 ///
2524 /// \param OffsetInBits Offset of the piece in bits.
2525 /// \param SizeInBits Size of the piece in bits.
2526 /// \return Creating a fragment expression may fail if \c Expr
2527 /// contains arithmetic operations that would be truncated.
2528 static Optional<DIExpression *>
2529 createFragmentExpression(const DIExpression *Expr, unsigned OffsetInBits,
2530 unsigned SizeInBits);
2531
2532 /// Determine the relative position of the fragments passed in.
2533 /// Returns -1 if this is entirely before Other, 0 if this and Other overlap,
2534 /// 1 if this is entirely after Other.
fragmentCmp(const FragmentInfo & A,const FragmentInfo & B)2535 static int fragmentCmp(const FragmentInfo &A, const FragmentInfo &B) {
2536 uint64_t l1 = A.OffsetInBits;
2537 uint64_t l2 = B.OffsetInBits;
2538 uint64_t r1 = l1 + A.SizeInBits;
2539 uint64_t r2 = l2 + B.SizeInBits;
2540 if (r1 <= l2)
2541 return -1;
2542 else if (r2 <= l1)
2543 return 1;
2544 else
2545 return 0;
2546 }
2547
2548 /// Check if fragments overlap between a pair of FragmentInfos.
fragmentsOverlap(const FragmentInfo & A,const FragmentInfo & B)2549 static bool fragmentsOverlap(const FragmentInfo &A, const FragmentInfo &B) {
2550 return fragmentCmp(A, B) == 0;
2551 }
2552
2553 /// Determine the relative position of the fragments described by this
2554 /// DIExpression and \p Other. Calls static fragmentCmp implementation.
fragmentCmp(const DIExpression * Other)2555 int fragmentCmp(const DIExpression *Other) const {
2556 auto Fragment1 = *getFragmentInfo();
2557 auto Fragment2 = *Other->getFragmentInfo();
2558 return fragmentCmp(Fragment1, Fragment2);
2559 }
2560
2561 /// Check if fragments overlap between this DIExpression and \p Other.
fragmentsOverlap(const DIExpression * Other)2562 bool fragmentsOverlap(const DIExpression *Other) const {
2563 if (!isFragment() || !Other->isFragment())
2564 return true;
2565 return fragmentCmp(Other) == 0;
2566 }
2567
2568 /// Check if the expression consists of exactly one entry value operand.
2569 /// (This is the only configuration of entry values that is supported.)
isEntryValue()2570 bool isEntryValue() const {
2571 return getNumElements() > 0 &&
2572 getElement(0) == dwarf::DW_OP_entry_value;
2573 }
2574 };
2575
2576 inline bool operator==(const DIExpression::FragmentInfo &A,
2577 const DIExpression::FragmentInfo &B) {
2578 return std::tie(A.SizeInBits, A.OffsetInBits) ==
2579 std::tie(B.SizeInBits, B.OffsetInBits);
2580 }
2581
2582 inline bool operator<(const DIExpression::FragmentInfo &A,
2583 const DIExpression::FragmentInfo &B) {
2584 return std::tie(A.SizeInBits, A.OffsetInBits) <
2585 std::tie(B.SizeInBits, B.OffsetInBits);
2586 }
2587
2588 template <> struct DenseMapInfo<DIExpression::FragmentInfo> {
2589 using FragInfo = DIExpression::FragmentInfo;
2590 static const uint64_t MaxVal = std::numeric_limits<uint64_t>::max();
2591
2592 static inline FragInfo getEmptyKey() { return {MaxVal, MaxVal}; }
2593
2594 static inline FragInfo getTombstoneKey() { return {MaxVal - 1, MaxVal - 1}; }
2595
2596 static unsigned getHashValue(const FragInfo &Frag) {
2597 return (Frag.SizeInBits & 0xffff) << 16 | (Frag.OffsetInBits & 0xffff);
2598 }
2599
2600 static bool isEqual(const FragInfo &A, const FragInfo &B) { return A == B; }
2601 };
2602
2603 /// Global variables.
2604 ///
2605 /// TODO: Remove DisplayName. It's always equal to Name.
2606 class DIGlobalVariable : public DIVariable {
2607 friend class LLVMContextImpl;
2608 friend class MDNode;
2609
2610 bool IsLocalToUnit;
2611 bool IsDefinition;
2612
2613 DIGlobalVariable(LLVMContext &C, StorageType Storage, unsigned Line,
2614 bool IsLocalToUnit, bool IsDefinition, uint32_t AlignInBits,
2615 ArrayRef<Metadata *> Ops)
2616 : DIVariable(C, DIGlobalVariableKind, Storage, Line, Ops, AlignInBits),
2617 IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition) {}
2618 ~DIGlobalVariable() = default;
2619
2620 static DIGlobalVariable *
2621 getImpl(LLVMContext &Context, DIScope *Scope, StringRef Name,
2622 StringRef LinkageName, DIFile *File, unsigned Line, DIType *Type,
2623 bool IsLocalToUnit, bool IsDefinition,
2624 DIDerivedType *StaticDataMemberDeclaration, MDTuple *TemplateParams,
2625 uint32_t AlignInBits, StorageType Storage, bool ShouldCreate = true) {
2626 return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
2627 getCanonicalMDString(Context, LinkageName), File, Line, Type,
2628 IsLocalToUnit, IsDefinition, StaticDataMemberDeclaration,
2629 cast_or_null<Metadata>(TemplateParams), AlignInBits, Storage,
2630 ShouldCreate);
2631 }
2632 static DIGlobalVariable *
2633 getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
2634 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
2635 bool IsLocalToUnit, bool IsDefinition,
2636 Metadata *StaticDataMemberDeclaration, Metadata *TemplateParams,
2637 uint32_t AlignInBits, StorageType Storage, bool ShouldCreate = true);
2638
2639 TempDIGlobalVariable cloneImpl() const {
2640 return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
2641 getFile(), getLine(), getType(), isLocalToUnit(),
2642 isDefinition(), getStaticDataMemberDeclaration(),
2643 getTemplateParams(), getAlignInBits());
2644 }
2645
2646 public:
2647 DEFINE_MDNODE_GET(DIGlobalVariable,
2648 (DIScope * Scope, StringRef Name, StringRef LinkageName,
2649 DIFile *File, unsigned Line, DIType *Type,
2650 bool IsLocalToUnit, bool IsDefinition,
2651 DIDerivedType *StaticDataMemberDeclaration,
2652 MDTuple *TemplateParams, uint32_t AlignInBits),
2653 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
2654 IsDefinition, StaticDataMemberDeclaration, TemplateParams,
2655 AlignInBits))
2656 DEFINE_MDNODE_GET(DIGlobalVariable,
2657 (Metadata * Scope, MDString *Name, MDString *LinkageName,
2658 Metadata *File, unsigned Line, Metadata *Type,
2659 bool IsLocalToUnit, bool IsDefinition,
2660 Metadata *StaticDataMemberDeclaration,
2661 Metadata *TemplateParams, uint32_t AlignInBits),
2662 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
2663 IsDefinition, StaticDataMemberDeclaration, TemplateParams,
2664 AlignInBits))
2665
2666 TempDIGlobalVariable clone() const { return cloneImpl(); }
2667
2668 bool isLocalToUnit() const { return IsLocalToUnit; }
2669 bool isDefinition() const { return IsDefinition; }
2670 StringRef getDisplayName() const { return getStringOperand(4); }
2671 StringRef getLinkageName() const { return getStringOperand(5); }
2672 DIDerivedType *getStaticDataMemberDeclaration() const {
2673 return cast_or_null<DIDerivedType>(getRawStaticDataMemberDeclaration());
2674 }
2675
2676 MDString *getRawLinkageName() const { return getOperandAs<MDString>(5); }
2677 Metadata *getRawStaticDataMemberDeclaration() const { return getOperand(6); }
2678 Metadata *getRawTemplateParams() const { return getOperand(7); }
2679 MDTuple *getTemplateParams() const { return getOperandAs<MDTuple>(7); }
2680
2681 static bool classof(const Metadata *MD) {
2682 return MD->getMetadataID() == DIGlobalVariableKind;
2683 }
2684 };
2685
2686 class DICommonBlock : public DIScope {
2687 unsigned LineNo;
2688
2689 friend class LLVMContextImpl;
2690 friend class MDNode;
2691
2692 DICommonBlock(LLVMContext &Context, StorageType Storage, unsigned LineNo,
2693 ArrayRef<Metadata *> Ops)
2694 : DIScope(Context, DICommonBlockKind, Storage, dwarf::DW_TAG_common_block,
2695 Ops), LineNo(LineNo) {}
2696
2697 static DICommonBlock *getImpl(LLVMContext &Context, DIScope *Scope,
2698 DIGlobalVariable *Decl, StringRef Name,
2699 DIFile *File, unsigned LineNo,
2700 StorageType Storage,
2701 bool ShouldCreate = true) {
2702 return getImpl(Context, Scope, Decl, getCanonicalMDString(Context, Name),
2703 File, LineNo, Storage, ShouldCreate);
2704 }
2705 static DICommonBlock *getImpl(LLVMContext &Context, Metadata *Scope,
2706 Metadata *Decl, MDString *Name, Metadata *File,
2707 unsigned LineNo,
2708 StorageType Storage, bool ShouldCreate = true);
2709
2710 TempDICommonBlock cloneImpl() const {
2711 return getTemporary(getContext(), getScope(), getDecl(), getName(),
2712 getFile(), getLineNo());
2713 }
2714
2715 public:
2716 DEFINE_MDNODE_GET(DICommonBlock,
2717 (DIScope *Scope, DIGlobalVariable *Decl, StringRef Name,
2718 DIFile *File, unsigned LineNo),
2719 (Scope, Decl, Name, File, LineNo))
2720 DEFINE_MDNODE_GET(DICommonBlock,
2721 (Metadata *Scope, Metadata *Decl, MDString *Name,
2722 Metadata *File, unsigned LineNo),
2723 (Scope, Decl, Name, File, LineNo))
2724
2725 TempDICommonBlock clone() const { return cloneImpl(); }
2726
2727 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
2728 DIGlobalVariable *getDecl() const {
2729 return cast_or_null<DIGlobalVariable>(getRawDecl());
2730 }
2731 StringRef getName() const { return getStringOperand(2); }
2732 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
2733 unsigned getLineNo() const { return LineNo; }
2734
2735 Metadata *getRawScope() const { return getOperand(0); }
2736 Metadata *getRawDecl() const { return getOperand(1); }
2737 MDString *getRawName() const { return getOperandAs<MDString>(2); }
2738 Metadata *getRawFile() const { return getOperand(3); }
2739
2740 static bool classof(const Metadata *MD) {
2741 return MD->getMetadataID() == DICommonBlockKind;
2742 }
2743 };
2744
2745 /// Local variable.
2746 ///
2747 /// TODO: Split up flags.
2748 class DILocalVariable : public DIVariable {
2749 friend class LLVMContextImpl;
2750 friend class MDNode;
2751
2752 unsigned Arg : 16;
2753 DIFlags Flags;
2754
2755 DILocalVariable(LLVMContext &C, StorageType Storage, unsigned Line,
2756 unsigned Arg, DIFlags Flags, uint32_t AlignInBits,
2757 ArrayRef<Metadata *> Ops)
2758 : DIVariable(C, DILocalVariableKind, Storage, Line, Ops, AlignInBits),
2759 Arg(Arg), Flags(Flags) {
2760 assert(Arg < (1 << 16) && "DILocalVariable: Arg out of range");
2761 }
2762 ~DILocalVariable() = default;
2763
2764 static DILocalVariable *getImpl(LLVMContext &Context, DIScope *Scope,
2765 StringRef Name, DIFile *File, unsigned Line,
2766 DIType *Type, unsigned Arg, DIFlags Flags,
2767 uint32_t AlignInBits, StorageType Storage,
2768 bool ShouldCreate = true) {
2769 return getImpl(Context, Scope, getCanonicalMDString(Context, Name), File,
2770 Line, Type, Arg, Flags, AlignInBits, Storage, ShouldCreate);
2771 }
2772 static DILocalVariable *getImpl(LLVMContext &Context, Metadata *Scope,
2773 MDString *Name, Metadata *File, unsigned Line,
2774 Metadata *Type, unsigned Arg, DIFlags Flags,
2775 uint32_t AlignInBits, StorageType Storage,
2776 bool ShouldCreate = true);
2777
2778 TempDILocalVariable cloneImpl() const {
2779 return getTemporary(getContext(), getScope(), getName(), getFile(),
2780 getLine(), getType(), getArg(), getFlags(),
2781 getAlignInBits());
2782 }
2783
2784 public:
2785 DEFINE_MDNODE_GET(DILocalVariable,
2786 (DILocalScope * Scope, StringRef Name, DIFile *File,
2787 unsigned Line, DIType *Type, unsigned Arg, DIFlags Flags,
2788 uint32_t AlignInBits),
2789 (Scope, Name, File, Line, Type, Arg, Flags, AlignInBits))
2790 DEFINE_MDNODE_GET(DILocalVariable,
2791 (Metadata * Scope, MDString *Name, Metadata *File,
2792 unsigned Line, Metadata *Type, unsigned Arg,
2793 DIFlags Flags, uint32_t AlignInBits),
2794 (Scope, Name, File, Line, Type, Arg, Flags, AlignInBits))
2795
2796 TempDILocalVariable clone() const { return cloneImpl(); }
2797
2798 /// Get the local scope for this variable.
2799 ///
2800 /// Variables must be defined in a local scope.
2801 DILocalScope *getScope() const {
2802 return cast<DILocalScope>(DIVariable::getScope());
2803 }
2804
2805 bool isParameter() const { return Arg; }
2806 unsigned getArg() const { return Arg; }
2807 DIFlags getFlags() const { return Flags; }
2808
2809 bool isArtificial() const { return getFlags() & FlagArtificial; }
2810 bool isObjectPointer() const { return getFlags() & FlagObjectPointer; }
2811
2812 /// Check that an argument is unmodified.
2813 bool isNotModified() const { return getFlags() & FlagArgumentNotModified; }
2814 /// Set the flag if an argument is unmodified.
2815 void setIsNotModified() { Flags |= FlagArgumentNotModified; }
2816
2817 /// Check that a location is valid for this variable.
2818 ///
2819 /// Check that \c DL exists, is in the same subprogram, and has the same
2820 /// inlined-at location as \c this. (Otherwise, it's not a valid attachment
2821 /// to a \a DbgInfoIntrinsic.)
2822 bool isValidLocationForIntrinsic(const DILocation *DL) const {
2823 return DL && getScope()->getSubprogram() == DL->getScope()->getSubprogram();
2824 }
2825
2826 static bool classof(const Metadata *MD) {
2827 return MD->getMetadataID() == DILocalVariableKind;
2828 }
2829 };
2830
2831 /// Label.
2832 ///
2833 class DILabel : public DINode {
2834 friend class LLVMContextImpl;
2835 friend class MDNode;
2836
2837 unsigned Line;
2838
2839 DILabel(LLVMContext &C, StorageType Storage, unsigned Line,
2840 ArrayRef<Metadata *> Ops)
2841 : DINode(C, DILabelKind, Storage, dwarf::DW_TAG_label, Ops), Line(Line) {}
2842 ~DILabel() = default;
2843
2844 static DILabel *getImpl(LLVMContext &Context, DIScope *Scope,
2845 StringRef Name, DIFile *File, unsigned Line,
2846 StorageType Storage,
2847 bool ShouldCreate = true) {
2848 return getImpl(Context, Scope, getCanonicalMDString(Context, Name), File,
2849 Line, Storage, ShouldCreate);
2850 }
2851 static DILabel *getImpl(LLVMContext &Context, Metadata *Scope,
2852 MDString *Name, Metadata *File, unsigned Line,
2853 StorageType Storage,
2854 bool ShouldCreate = true);
2855
2856 TempDILabel cloneImpl() const {
2857 return getTemporary(getContext(), getScope(), getName(), getFile(),
2858 getLine());
2859 }
2860
2861 public:
2862 DEFINE_MDNODE_GET(DILabel,
2863 (DILocalScope * Scope, StringRef Name, DIFile *File,
2864 unsigned Line),
2865 (Scope, Name, File, Line))
2866 DEFINE_MDNODE_GET(DILabel,
2867 (Metadata * Scope, MDString *Name, Metadata *File,
2868 unsigned Line),
2869 (Scope, Name, File, Line))
2870
2871 TempDILabel clone() const { return cloneImpl(); }
2872
2873 /// Get the local scope for this label.
2874 ///
2875 /// Labels must be defined in a local scope.
2876 DILocalScope *getScope() const {
2877 return cast_or_null<DILocalScope>(getRawScope());
2878 }
2879 unsigned getLine() const { return Line; }
2880 StringRef getName() const { return getStringOperand(1); }
2881 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
2882
2883 Metadata *getRawScope() const { return getOperand(0); }
2884 MDString *getRawName() const { return getOperandAs<MDString>(1); }
2885 Metadata *getRawFile() const { return getOperand(2); }
2886
2887 /// Check that a location is valid for this label.
2888 ///
2889 /// Check that \c DL exists, is in the same subprogram, and has the same
2890 /// inlined-at location as \c this. (Otherwise, it's not a valid attachment
2891 /// to a \a DbgInfoIntrinsic.)
2892 bool isValidLocationForIntrinsic(const DILocation *DL) const {
2893 return DL && getScope()->getSubprogram() == DL->getScope()->getSubprogram();
2894 }
2895
2896 static bool classof(const Metadata *MD) {
2897 return MD->getMetadataID() == DILabelKind;
2898 }
2899 };
2900
2901 class DIObjCProperty : public DINode {
2902 friend class LLVMContextImpl;
2903 friend class MDNode;
2904
2905 unsigned Line;
2906 unsigned Attributes;
2907
2908 DIObjCProperty(LLVMContext &C, StorageType Storage, unsigned Line,
2909 unsigned Attributes, ArrayRef<Metadata *> Ops)
2910 : DINode(C, DIObjCPropertyKind, Storage, dwarf::DW_TAG_APPLE_property,
2911 Ops),
2912 Line(Line), Attributes(Attributes) {}
2913 ~DIObjCProperty() = default;
2914
2915 static DIObjCProperty *
2916 getImpl(LLVMContext &Context, StringRef Name, DIFile *File, unsigned Line,
2917 StringRef GetterName, StringRef SetterName, unsigned Attributes,
2918 DIType *Type, StorageType Storage, bool ShouldCreate = true) {
2919 return getImpl(Context, getCanonicalMDString(Context, Name), File, Line,
2920 getCanonicalMDString(Context, GetterName),
2921 getCanonicalMDString(Context, SetterName), Attributes, Type,
2922 Storage, ShouldCreate);
2923 }
2924 static DIObjCProperty *getImpl(LLVMContext &Context, MDString *Name,
2925 Metadata *File, unsigned Line,
2926 MDString *GetterName, MDString *SetterName,
2927 unsigned Attributes, Metadata *Type,
2928 StorageType Storage, bool ShouldCreate = true);
2929
2930 TempDIObjCProperty cloneImpl() const {
2931 return getTemporary(getContext(), getName(), getFile(), getLine(),
2932 getGetterName(), getSetterName(), getAttributes(),
2933 getType());
2934 }
2935
2936 public:
2937 DEFINE_MDNODE_GET(DIObjCProperty,
2938 (StringRef Name, DIFile *File, unsigned Line,
2939 StringRef GetterName, StringRef SetterName,
2940 unsigned Attributes, DIType *Type),
2941 (Name, File, Line, GetterName, SetterName, Attributes,
2942 Type))
2943 DEFINE_MDNODE_GET(DIObjCProperty,
2944 (MDString * Name, Metadata *File, unsigned Line,
2945 MDString *GetterName, MDString *SetterName,
2946 unsigned Attributes, Metadata *Type),
2947 (Name, File, Line, GetterName, SetterName, Attributes,
2948 Type))
2949
2950 TempDIObjCProperty clone() const { return cloneImpl(); }
2951
2952 unsigned getLine() const { return Line; }
2953 unsigned getAttributes() const { return Attributes; }
2954 StringRef getName() const { return getStringOperand(0); }
2955 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
2956 StringRef getGetterName() const { return getStringOperand(2); }
2957 StringRef getSetterName() const { return getStringOperand(3); }
2958 DIType *getType() const { return cast_or_null<DIType>(getRawType()); }
2959
2960 StringRef getFilename() const {
2961 if (auto *F = getFile())
2962 return F->getFilename();
2963 return "";
2964 }
2965
2966 StringRef getDirectory() const {
2967 if (auto *F = getFile())
2968 return F->getDirectory();
2969 return "";
2970 }
2971
2972 Optional<StringRef> getSource() const {
2973 if (auto *F = getFile())
2974 return F->getSource();
2975 return None;
2976 }
2977
2978 MDString *getRawName() const { return getOperandAs<MDString>(0); }
2979 Metadata *getRawFile() const { return getOperand(1); }
2980 MDString *getRawGetterName() const { return getOperandAs<MDString>(2); }
2981 MDString *getRawSetterName() const { return getOperandAs<MDString>(3); }
2982 Metadata *getRawType() const { return getOperand(4); }
2983
2984 static bool classof(const Metadata *MD) {
2985 return MD->getMetadataID() == DIObjCPropertyKind;
2986 }
2987 };
2988
2989 /// An imported module (C++ using directive or similar).
2990 class DIImportedEntity : public DINode {
2991 friend class LLVMContextImpl;
2992 friend class MDNode;
2993
2994 unsigned Line;
2995
2996 DIImportedEntity(LLVMContext &C, StorageType Storage, unsigned Tag,
2997 unsigned Line, ArrayRef<Metadata *> Ops)
2998 : DINode(C, DIImportedEntityKind, Storage, Tag, Ops), Line(Line) {}
2999 ~DIImportedEntity() = default;
3000
3001 static DIImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
3002 DIScope *Scope, DINode *Entity, DIFile *File,
3003 unsigned Line, StringRef Name,
3004 StorageType Storage,
3005 bool ShouldCreate = true) {
3006 return getImpl(Context, Tag, Scope, Entity, File, Line,
3007 getCanonicalMDString(Context, Name), Storage, ShouldCreate);
3008 }
3009 static DIImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
3010 Metadata *Scope, Metadata *Entity,
3011 Metadata *File, unsigned Line,
3012 MDString *Name, StorageType Storage,
3013 bool ShouldCreate = true);
3014
3015 TempDIImportedEntity cloneImpl() const {
3016 return getTemporary(getContext(), getTag(), getScope(), getEntity(),
3017 getFile(), getLine(), getName());
3018 }
3019
3020 public:
3021 DEFINE_MDNODE_GET(DIImportedEntity,
3022 (unsigned Tag, DIScope *Scope, DINode *Entity, DIFile *File,
3023 unsigned Line, StringRef Name = ""),
3024 (Tag, Scope, Entity, File, Line, Name))
3025 DEFINE_MDNODE_GET(DIImportedEntity,
3026 (unsigned Tag, Metadata *Scope, Metadata *Entity,
3027 Metadata *File, unsigned Line, MDString *Name),
3028 (Tag, Scope, Entity, File, Line, Name))
3029
3030 TempDIImportedEntity clone() const { return cloneImpl(); }
3031
3032 unsigned getLine() const { return Line; }
3033 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
3034 DINode *getEntity() const { return cast_or_null<DINode>(getRawEntity()); }
3035 StringRef getName() const { return getStringOperand(2); }
3036 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
3037
3038 Metadata *getRawScope() const { return getOperand(0); }
3039 Metadata *getRawEntity() const { return getOperand(1); }
3040 MDString *getRawName() const { return getOperandAs<MDString>(2); }
3041 Metadata *getRawFile() const { return getOperand(3); }
3042
3043 static bool classof(const Metadata *MD) {
3044 return MD->getMetadataID() == DIImportedEntityKind;
3045 }
3046 };
3047
3048 /// A pair of DIGlobalVariable and DIExpression.
3049 class DIGlobalVariableExpression : public MDNode {
3050 friend class LLVMContextImpl;
3051 friend class MDNode;
3052
3053 DIGlobalVariableExpression(LLVMContext &C, StorageType Storage,
3054 ArrayRef<Metadata *> Ops)
3055 : MDNode(C, DIGlobalVariableExpressionKind, Storage, Ops) {}
3056 ~DIGlobalVariableExpression() = default;
3057
3058 static DIGlobalVariableExpression *
3059 getImpl(LLVMContext &Context, Metadata *Variable, Metadata *Expression,
3060 StorageType Storage, bool ShouldCreate = true);
3061
3062 TempDIGlobalVariableExpression cloneImpl() const {
3063 return getTemporary(getContext(), getVariable(), getExpression());
3064 }
3065
3066 public:
3067 DEFINE_MDNODE_GET(DIGlobalVariableExpression,
3068 (Metadata * Variable, Metadata *Expression),
3069 (Variable, Expression))
3070
3071 TempDIGlobalVariableExpression clone() const { return cloneImpl(); }
3072
3073 Metadata *getRawVariable() const { return getOperand(0); }
3074
3075 DIGlobalVariable *getVariable() const {
3076 return cast_or_null<DIGlobalVariable>(getRawVariable());
3077 }
3078
3079 Metadata *getRawExpression() const { return getOperand(1); }
3080
3081 DIExpression *getExpression() const {
3082 return cast<DIExpression>(getRawExpression());
3083 }
3084
3085 static bool classof(const Metadata *MD) {
3086 return MD->getMetadataID() == DIGlobalVariableExpressionKind;
3087 }
3088 };
3089
3090 /// Macro Info DWARF-like metadata node.
3091 ///
3092 /// A metadata node with a DWARF macro info (i.e., a constant named
3093 /// \c DW_MACINFO_*, defined in llvm/BinaryFormat/Dwarf.h). Called \a
3094 /// DIMacroNode
3095 /// because it's potentially used for non-DWARF output.
3096 class DIMacroNode : public MDNode {
3097 friend class LLVMContextImpl;
3098 friend class MDNode;
3099
3100 protected:
3101 DIMacroNode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned MIType,
3102 ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None)
3103 : MDNode(C, ID, Storage, Ops1, Ops2) {
3104 assert(MIType < 1u << 16);
3105 SubclassData16 = MIType;
3106 }
3107 ~DIMacroNode() = default;
3108
3109 template <class Ty> Ty *getOperandAs(unsigned I) const {
3110 return cast_or_null<Ty>(getOperand(I));
3111 }
3112
3113 StringRef getStringOperand(unsigned I) const {
3114 if (auto *S = getOperandAs<MDString>(I))
3115 return S->getString();
3116 return StringRef();
3117 }
3118
3119 static MDString *getCanonicalMDString(LLVMContext &Context, StringRef S) {
3120 if (S.empty())
3121 return nullptr;
3122 return MDString::get(Context, S);
3123 }
3124
3125 public:
3126 unsigned getMacinfoType() const { return SubclassData16; }
3127
3128 static bool classof(const Metadata *MD) {
3129 switch (MD->getMetadataID()) {
3130 default:
3131 return false;
3132 case DIMacroKind:
3133 case DIMacroFileKind:
3134 return true;
3135 }
3136 }
3137 };
3138
3139 class DIMacro : public DIMacroNode {
3140 friend class LLVMContextImpl;
3141 friend class MDNode;
3142
3143 unsigned Line;
3144
3145 DIMacro(LLVMContext &C, StorageType Storage, unsigned MIType, unsigned Line,
3146 ArrayRef<Metadata *> Ops)
3147 : DIMacroNode(C, DIMacroKind, Storage, MIType, Ops), Line(Line) {}
3148 ~DIMacro() = default;
3149
3150 static DIMacro *getImpl(LLVMContext &Context, unsigned MIType, unsigned Line,
3151 StringRef Name, StringRef Value, StorageType Storage,
3152 bool ShouldCreate = true) {
3153 return getImpl(Context, MIType, Line, getCanonicalMDString(Context, Name),
3154 getCanonicalMDString(Context, Value), Storage, ShouldCreate);
3155 }
3156 static DIMacro *getImpl(LLVMContext &Context, unsigned MIType, unsigned Line,
3157 MDString *Name, MDString *Value, StorageType Storage,
3158 bool ShouldCreate = true);
3159
3160 TempDIMacro cloneImpl() const {
3161 return getTemporary(getContext(), getMacinfoType(), getLine(), getName(),
3162 getValue());
3163 }
3164
3165 public:
3166 DEFINE_MDNODE_GET(DIMacro, (unsigned MIType, unsigned Line, StringRef Name,
3167 StringRef Value = ""),
3168 (MIType, Line, Name, Value))
3169 DEFINE_MDNODE_GET(DIMacro, (unsigned MIType, unsigned Line, MDString *Name,
3170 MDString *Value),
3171 (MIType, Line, Name, Value))
3172
3173 TempDIMacro clone() const { return cloneImpl(); }
3174
3175 unsigned getLine() const { return Line; }
3176
3177 StringRef getName() const { return getStringOperand(0); }
3178 StringRef getValue() const { return getStringOperand(1); }
3179
3180 MDString *getRawName() const { return getOperandAs<MDString>(0); }
3181 MDString *getRawValue() const { return getOperandAs<MDString>(1); }
3182
3183 static bool classof(const Metadata *MD) {
3184 return MD->getMetadataID() == DIMacroKind;
3185 }
3186 };
3187
3188 class DIMacroFile : public DIMacroNode {
3189 friend class LLVMContextImpl;
3190 friend class MDNode;
3191
3192 unsigned Line;
3193
3194 DIMacroFile(LLVMContext &C, StorageType Storage, unsigned MIType,
3195 unsigned Line, ArrayRef<Metadata *> Ops)
3196 : DIMacroNode(C, DIMacroFileKind, Storage, MIType, Ops), Line(Line) {}
3197 ~DIMacroFile() = default;
3198
3199 static DIMacroFile *getImpl(LLVMContext &Context, unsigned MIType,
3200 unsigned Line, DIFile *File,
3201 DIMacroNodeArray Elements, StorageType Storage,
3202 bool ShouldCreate = true) {
3203 return getImpl(Context, MIType, Line, static_cast<Metadata *>(File),
3204 Elements.get(), Storage, ShouldCreate);
3205 }
3206
3207 static DIMacroFile *getImpl(LLVMContext &Context, unsigned MIType,
3208 unsigned Line, Metadata *File, Metadata *Elements,
3209 StorageType Storage, bool ShouldCreate = true);
3210
3211 TempDIMacroFile cloneImpl() const {
3212 return getTemporary(getContext(), getMacinfoType(), getLine(), getFile(),
3213 getElements());
3214 }
3215
3216 public:
3217 DEFINE_MDNODE_GET(DIMacroFile, (unsigned MIType, unsigned Line, DIFile *File,
3218 DIMacroNodeArray Elements),
3219 (MIType, Line, File, Elements))
3220 DEFINE_MDNODE_GET(DIMacroFile, (unsigned MIType, unsigned Line,
3221 Metadata *File, Metadata *Elements),
3222 (MIType, Line, File, Elements))
3223
3224 TempDIMacroFile clone() const { return cloneImpl(); }
3225
3226 void replaceElements(DIMacroNodeArray Elements) {
3227 #ifndef NDEBUG
3228 for (DIMacroNode *Op : getElements())
3229 assert(is_contained(Elements->operands(), Op) &&
3230 "Lost a macro node during macro node list replacement");
3231 #endif
3232 replaceOperandWith(1, Elements.get());
3233 }
3234
3235 unsigned getLine() const { return Line; }
3236 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
3237
3238 DIMacroNodeArray getElements() const {
3239 return cast_or_null<MDTuple>(getRawElements());
3240 }
3241
3242 Metadata *getRawFile() const { return getOperand(0); }
3243 Metadata *getRawElements() const { return getOperand(1); }
3244
3245 static bool classof(const Metadata *MD) {
3246 return MD->getMetadataID() == DIMacroFileKind;
3247 }
3248 };
3249
3250 } // end namespace llvm
3251
3252 #undef DEFINE_MDNODE_GET_UNPACK_IMPL
3253 #undef DEFINE_MDNODE_GET_UNPACK
3254 #undef DEFINE_MDNODE_GET
3255
3256 #endif // LLVM_IR_DEBUGINFOMETADATA_H
3257