WebSVN – QNX 8.QNX8 LLVM/Clang compiler suite – Blame – /llvm-build/x86_64/include/llvm/IR/DebugInfoMetadata.h

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

Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

QNX 8.QNX8 LLVM/Clang compiler suite/llvm-build/x86_64/include/llvm/IR/DebugInfoMetadata.h – Rev 14