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

Rev	Author	Line No.	Line
14	pmbaty	1	//===-- llvm/BinaryFormat/Dwarf.h ---Dwarf Constants-------------- 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	/// \file
		10	/// This file contains constants used for implementing Dwarf
		11	/// debug support.
		12	///
		13	/// For details on the Dwarf specfication see the latest DWARF Debugging
		14	/// Information Format standard document on http://www.dwarfstd.org. This
		15	/// file often includes support for non-released standard features.
		16	//
		17	//===----------------------------------------------------------------------===//
		18
		19	#ifndef LLVM_BINARYFORMAT_DWARF_H
		20	#define LLVM_BINARYFORMAT_DWARF_H
		21
		22	#include "llvm/Support/Compiler.h"
		23	#include "llvm/Support/DataTypes.h"
		24	#include "llvm/Support/ErrorHandling.h"
		25	#include "llvm/Support/Format.h"
		26	#include "llvm/Support/FormatVariadicDetails.h"
		27	#include "llvm/ADT/Triple.h"
		28
		29	#include <limits>
		30
		31	namespace llvm {
		32	class StringRef;
		33
		34	namespace dwarf {
		35
		36	//===----------------------------------------------------------------------===//
		37	// DWARF constants as gleaned from the DWARF Debugging Information Format V.5
		38	// reference manual http://www.dwarfstd.org/.
		39	//
		40
		41	// Do not mix the following two enumerations sets. DW_TAG_invalid changes the
		42	// enumeration base type.
		43
		44	enum LLVMConstants : uint32_t {
		45	/// LLVM mock tags (see also llvm/BinaryFormat/Dwarf.def).
		46	/// \{
		47	DW_TAG_invalid = ~0U, ///< Tag for invalid results.
		48	DW_VIRTUALITY_invalid = ~0U, ///< Virtuality for invalid results.
		49	DW_MACINFO_invalid = ~0U, ///< Macinfo type for invalid results.
		50	/// \}
		51
		52	/// Special values for an initial length field.
		53	/// \{
		54	DW_LENGTH_lo_reserved = 0xfffffff0, ///< Lower bound of the reserved range.
		55	DW_LENGTH_DWARF64 = 0xffffffff, ///< Indicator of 64-bit DWARF format.
		56	DW_LENGTH_hi_reserved = 0xffffffff, ///< Upper bound of the reserved range.
		57	/// \}
		58
		59	/// Other constants.
		60	/// \{
		61	DWARF_VERSION = 4, ///< Default dwarf version we output.
		62	DW_PUBTYPES_VERSION = 2, ///< Section version number for .debug_pubtypes.
		63	DW_PUBNAMES_VERSION = 2, ///< Section version number for .debug_pubnames.
		64	DW_ARANGES_VERSION = 2, ///< Section version number for .debug_aranges.
		65	/// \}
		66
		67	/// Identifiers we use to distinguish vendor extensions.
		68	/// \{
		69	DWARF_VENDOR_DWARF = 0, ///< Defined in v2 or later of the DWARF standard.
		70	DWARF_VENDOR_APPLE = 1,
		71	DWARF_VENDOR_BORLAND = 2,
		72	DWARF_VENDOR_GNU = 3,
		73	DWARF_VENDOR_GOOGLE = 4,
		74	DWARF_VENDOR_LLVM = 5,
		75	DWARF_VENDOR_MIPS = 6,
		76	DWARF_VENDOR_WASM = 7,
		77	DWARF_VENDOR_ALTIUM,
		78	DWARF_VENDOR_COMPAQ,
		79	DWARF_VENDOR_GHS,
		80	DWARF_VENDOR_GO,
		81	DWARF_VENDOR_HP,
		82	DWARF_VENDOR_IBM,
		83	DWARF_VENDOR_INTEL,
		84	DWARF_VENDOR_PGI,
		85	DWARF_VENDOR_SUN,
		86	DWARF_VENDOR_UPC,
		87	///\}
		88	};
		89
		90	/// Constants that define the DWARF format as 32 or 64 bit.
		91	enum DwarfFormat : uint8_t { DWARF32, DWARF64 };
		92
		93	/// Special ID values that distinguish a CIE from a FDE in DWARF CFI.
		94	/// Not inside an enum because a 64-bit value is needed.
		95	/// @{
		96	const uint32_t DW_CIE_ID = UINT32_MAX;
		97	const uint64_t DW64_CIE_ID = UINT64_MAX;
		98	/// @}
		99
		100	/// Identifier of an invalid DIE offset in the .debug_info section.
		101	const uint32_t DW_INVALID_OFFSET = UINT32_MAX;
		102
		103	enum Tag : uint16_t {
		104	#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND) DW_TAG_##NAME = ID,
		105	#include "llvm/BinaryFormat/Dwarf.def"
		106	DW_TAG_lo_user = 0x4080,
		107	DW_TAG_hi_user = 0xffff,
		108	DW_TAG_user_base = 0x1000 ///< Recommended base for user tags.
		109	};
		110
		111	inline bool isType(Tag T) {
		112	switch (T) {
		113	default:
		114	return false;
		115	#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND) \
		116	case DW_TAG_##NAME: \
		117	return (KIND == DW_KIND_TYPE);
		118	#include "llvm/BinaryFormat/Dwarf.def"
		119	}
		120	}
		121
		122	/// Attributes.
		123	enum Attribute : uint16_t {
		124	#define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR) DW_AT_##NAME = ID,
		125	#include "llvm/BinaryFormat/Dwarf.def"
		126	DW_AT_lo_user = 0x2000,
		127	DW_AT_hi_user = 0x3fff,
		128	};
		129
		130	enum Form : uint16_t {
		131	#define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR) DW_FORM_##NAME = ID,
		132	#include "llvm/BinaryFormat/Dwarf.def"
		133	DW_FORM_lo_user = 0x1f00, ///< Not specified by DWARF.
		134	};
		135
		136	enum LocationAtom {
		137	#define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) DW_OP_##NAME = ID,
		138	#include "llvm/BinaryFormat/Dwarf.def"
		139	DW_OP_lo_user = 0xe0,
		140	DW_OP_hi_user = 0xff,
		141	DW_OP_LLVM_fragment = 0x1000, ///< Only used in LLVM metadata.
		142	DW_OP_LLVM_convert = 0x1001, ///< Only used in LLVM metadata.
		143	DW_OP_LLVM_tag_offset = 0x1002, ///< Only used in LLVM metadata.
		144	DW_OP_LLVM_entry_value = 0x1003, ///< Only used in LLVM metadata.
		145	DW_OP_LLVM_implicit_pointer = 0x1004, ///< Only used in LLVM metadata.
		146	DW_OP_LLVM_arg = 0x1005, ///< Only used in LLVM metadata.
		147	};
		148
		149	enum TypeKind : uint8_t {
		150	#define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) DW_ATE_##NAME = ID,
		151	#include "llvm/BinaryFormat/Dwarf.def"
		152	DW_ATE_lo_user = 0x80,
		153	DW_ATE_hi_user = 0xff
		154	};
		155
		156	enum DecimalSignEncoding {
		157	// Decimal sign attribute values
		158	DW_DS_unsigned = 0x01,
		159	DW_DS_leading_overpunch = 0x02,
		160	DW_DS_trailing_overpunch = 0x03,
		161	DW_DS_leading_separate = 0x04,
		162	DW_DS_trailing_separate = 0x05
		163	};
		164
		165	enum EndianityEncoding {
		166	// Endianity attribute values
		167	#define HANDLE_DW_END(ID, NAME) DW_END_##NAME = ID,
		168	#include "llvm/BinaryFormat/Dwarf.def"
		169	DW_END_lo_user = 0x40,
		170	DW_END_hi_user = 0xff
		171	};
		172
		173	enum AccessAttribute {
		174	// Accessibility codes
		175	DW_ACCESS_public = 0x01,
		176	DW_ACCESS_protected = 0x02,
		177	DW_ACCESS_private = 0x03
		178	};
		179
		180	enum VisibilityAttribute {
		181	// Visibility codes
		182	DW_VIS_local = 0x01,
		183	DW_VIS_exported = 0x02,
		184	DW_VIS_qualified = 0x03
		185	};
		186
		187	enum VirtualityAttribute {
		188	#define HANDLE_DW_VIRTUALITY(ID, NAME) DW_VIRTUALITY_##NAME = ID,
		189	#include "llvm/BinaryFormat/Dwarf.def"
		190	DW_VIRTUALITY_max = 0x02
		191	};
		192
		193	enum DefaultedMemberAttribute {
		194	#define HANDLE_DW_DEFAULTED(ID, NAME) DW_DEFAULTED_##NAME = ID,
		195	#include "llvm/BinaryFormat/Dwarf.def"
		196	DW_DEFAULTED_max = 0x02
		197	};
		198
		199	enum SourceLanguage {
		200	#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \
		201	DW_LANG_##NAME = ID,
		202	#include "llvm/BinaryFormat/Dwarf.def"
		203	DW_LANG_lo_user = 0x8000,
		204	DW_LANG_hi_user = 0xffff
		205	};
		206
		207	inline bool isCPlusPlus(SourceLanguage S) {
		208	bool result = false;
		209	// Deliberately enumerate all the language options so we get a warning when
		210	// new language options are added (-Wswitch) that'll hopefully help keep this
		211	// switch up-to-date when new C++ versions are added.
		212	switch (S) {
		213	case DW_LANG_C_plus_plus:
		214	case DW_LANG_C_plus_plus_03:
		215	case DW_LANG_C_plus_plus_11:
		216	case DW_LANG_C_plus_plus_14:
		217	case DW_LANG_C_plus_plus_17:
		218	case DW_LANG_C_plus_plus_20:
		219	result = true;
		220	break;
		221	case DW_LANG_C89:
		222	case DW_LANG_C:
		223	case DW_LANG_Ada83:
		224	case DW_LANG_Cobol74:
		225	case DW_LANG_Cobol85:
		226	case DW_LANG_Fortran77:
		227	case DW_LANG_Fortran90:
		228	case DW_LANG_Pascal83:
		229	case DW_LANG_Modula2:
		230	case DW_LANG_Java:
		231	case DW_LANG_C99:
		232	case DW_LANG_Ada95:
		233	case DW_LANG_Fortran95:
		234	case DW_LANG_PLI:
		235	case DW_LANG_ObjC:
		236	case DW_LANG_ObjC_plus_plus:
		237	case DW_LANG_UPC:
		238	case DW_LANG_D:
		239	case DW_LANG_Python:
		240	case DW_LANG_OpenCL:
		241	case DW_LANG_Go:
		242	case DW_LANG_Modula3:
		243	case DW_LANG_Haskell:
		244	case DW_LANG_OCaml:
		245	case DW_LANG_Rust:
		246	case DW_LANG_C11:
		247	case DW_LANG_Swift:
		248	case DW_LANG_Julia:
		249	case DW_LANG_Dylan:
		250	case DW_LANG_Fortran03:
		251	case DW_LANG_Fortran08:
		252	case DW_LANG_RenderScript:
		253	case DW_LANG_BLISS:
		254	case DW_LANG_Mips_Assembler:
		255	case DW_LANG_GOOGLE_RenderScript:
		256	case DW_LANG_BORLAND_Delphi:
		257	case DW_LANG_lo_user:
		258	case DW_LANG_hi_user:
		259	case DW_LANG_Kotlin:
		260	case DW_LANG_Zig:
		261	case DW_LANG_Crystal:
		262	case DW_LANG_C17:
		263	case DW_LANG_Fortran18:
		264	case DW_LANG_Ada2005:
		265	case DW_LANG_Ada2012:
		266	result = false;
		267	break;
		268	}
		269
		270	return result;
		271	}
		272
		273	inline bool isFortran(SourceLanguage S) {
		274	bool result = false;
		275	// Deliberately enumerate all the language options so we get a warning when
		276	// new language options are added (-Wswitch) that'll hopefully help keep this
		277	// switch up-to-date when new Fortran versions are added.
		278	switch (S) {
		279	case DW_LANG_Fortran77:
		280	case DW_LANG_Fortran90:
		281	case DW_LANG_Fortran95:
		282	case DW_LANG_Fortran03:
		283	case DW_LANG_Fortran08:
		284	case DW_LANG_Fortran18:
		285	result = true;
		286	break;
		287	case DW_LANG_C89:
		288	case DW_LANG_C:
		289	case DW_LANG_Ada83:
		290	case DW_LANG_C_plus_plus:
		291	case DW_LANG_Cobol74:
		292	case DW_LANG_Cobol85:
		293	case DW_LANG_Pascal83:
		294	case DW_LANG_Modula2:
		295	case DW_LANG_Java:
		296	case DW_LANG_C99:
		297	case DW_LANG_Ada95:
		298	case DW_LANG_PLI:
		299	case DW_LANG_ObjC:
		300	case DW_LANG_ObjC_plus_plus:
		301	case DW_LANG_UPC:
		302	case DW_LANG_D:
		303	case DW_LANG_Python:
		304	case DW_LANG_OpenCL:
		305	case DW_LANG_Go:
		306	case DW_LANG_Modula3:
		307	case DW_LANG_Haskell:
		308	case DW_LANG_C_plus_plus_03:
		309	case DW_LANG_C_plus_plus_11:
		310	case DW_LANG_OCaml:
		311	case DW_LANG_Rust:
		312	case DW_LANG_C11:
		313	case DW_LANG_Swift:
		314	case DW_LANG_Julia:
		315	case DW_LANG_Dylan:
		316	case DW_LANG_C_plus_plus_14:
		317	case DW_LANG_RenderScript:
		318	case DW_LANG_BLISS:
		319	case DW_LANG_Mips_Assembler:
		320	case DW_LANG_GOOGLE_RenderScript:
		321	case DW_LANG_BORLAND_Delphi:
		322	case DW_LANG_lo_user:
		323	case DW_LANG_hi_user:
		324	case DW_LANG_Kotlin:
		325	case DW_LANG_Zig:
		326	case DW_LANG_Crystal:
		327	case DW_LANG_C_plus_plus_17:
		328	case DW_LANG_C_plus_plus_20:
		329	case DW_LANG_C17:
		330	case DW_LANG_Ada2005:
		331	case DW_LANG_Ada2012:
		332	result = false;
		333	break;
		334	}
		335
		336	return result;
		337	}
		338
		339	inline bool isC(SourceLanguage S) {
		340	// Deliberately enumerate all the language options so we get a warning when
		341	// new language options are added (-Wswitch) that'll hopefully help keep this
		342	// switch up-to-date when new C++ versions are added.
		343	switch (S) {
		344	case DW_LANG_C11:
		345	case DW_LANG_C17:
		346	case DW_LANG_C89:
		347	case DW_LANG_C99:
		348	case DW_LANG_C:
		349	case DW_LANG_ObjC:
		350	return true;
		351	case DW_LANG_C_plus_plus:
		352	case DW_LANG_C_plus_plus_03:
		353	case DW_LANG_C_plus_plus_11:
		354	case DW_LANG_C_plus_plus_14:
		355	case DW_LANG_C_plus_plus_17:
		356	case DW_LANG_C_plus_plus_20:
		357	case DW_LANG_Ada83:
		358	case DW_LANG_Cobol74:
		359	case DW_LANG_Cobol85:
		360	case DW_LANG_Fortran77:
		361	case DW_LANG_Fortran90:
		362	case DW_LANG_Pascal83:
		363	case DW_LANG_Modula2:
		364	case DW_LANG_Java:
		365	case DW_LANG_Ada95:
		366	case DW_LANG_Fortran95:
		367	case DW_LANG_PLI:
		368	case DW_LANG_ObjC_plus_plus:
		369	case DW_LANG_UPC:
		370	case DW_LANG_D:
		371	case DW_LANG_Python:
		372	case DW_LANG_OpenCL:
		373	case DW_LANG_Go:
		374	case DW_LANG_Modula3:
		375	case DW_LANG_Haskell:
		376	case DW_LANG_OCaml:
		377	case DW_LANG_Rust:
		378	case DW_LANG_Swift:
		379	case DW_LANG_Julia:
		380	case DW_LANG_Dylan:
		381	case DW_LANG_Fortran03:
		382	case DW_LANG_Fortran08:
		383	case DW_LANG_RenderScript:
		384	case DW_LANG_BLISS:
		385	case DW_LANG_Mips_Assembler:
		386	case DW_LANG_GOOGLE_RenderScript:
		387	case DW_LANG_BORLAND_Delphi:
		388	case DW_LANG_lo_user:
		389	case DW_LANG_hi_user:
		390	case DW_LANG_Kotlin:
		391	case DW_LANG_Zig:
		392	case DW_LANG_Crystal:
		393	case DW_LANG_Fortran18:
		394	case DW_LANG_Ada2005:
		395	case DW_LANG_Ada2012:
		396	return false;
		397	}
		398	llvm_unreachable("Unknown language kind.");
		399	}
		400
		401	inline TypeKind getArrayIndexTypeEncoding(SourceLanguage S) {
		402	return isFortran(S) ? DW_ATE_signed : DW_ATE_unsigned;
		403	}
		404
		405	enum CaseSensitivity {
		406	// Identifier case codes
		407	DW_ID_case_sensitive = 0x00,
		408	DW_ID_up_case = 0x01,
		409	DW_ID_down_case = 0x02,
		410	DW_ID_case_insensitive = 0x03
		411	};
		412
		413	enum CallingConvention {
		414	// Calling convention codes
		415	#define HANDLE_DW_CC(ID, NAME) DW_CC_##NAME = ID,
		416	#include "llvm/BinaryFormat/Dwarf.def"
		417	DW_CC_lo_user = 0x40,
		418	DW_CC_hi_user = 0xff
		419	};
		420
		421	enum InlineAttribute {
		422	// Inline codes
		423	DW_INL_not_inlined = 0x00,
		424	DW_INL_inlined = 0x01,
		425	DW_INL_declared_not_inlined = 0x02,
		426	DW_INL_declared_inlined = 0x03
		427	};
		428
		429	enum ArrayDimensionOrdering {
		430	// Array ordering
		431	DW_ORD_row_major = 0x00,
		432	DW_ORD_col_major = 0x01
		433	};
		434
		435	enum DiscriminantList {
		436	// Discriminant descriptor values
		437	DW_DSC_label = 0x00,
		438	DW_DSC_range = 0x01
		439	};
		440
		441	/// Line Number Standard Opcode Encodings.
		442	enum LineNumberOps : uint8_t {
		443	#define HANDLE_DW_LNS(ID, NAME) DW_LNS_##NAME = ID,
		444	#include "llvm/BinaryFormat/Dwarf.def"
		445	};
		446
		447	/// Line Number Extended Opcode Encodings.
		448	enum LineNumberExtendedOps {
		449	#define HANDLE_DW_LNE(ID, NAME) DW_LNE_##NAME = ID,
		450	#include "llvm/BinaryFormat/Dwarf.def"
		451	DW_LNE_lo_user = 0x80,
		452	DW_LNE_hi_user = 0xff
		453	};
		454
		455	enum LineNumberEntryFormat {
		456	#define HANDLE_DW_LNCT(ID, NAME) DW_LNCT_##NAME = ID,
		457	#include "llvm/BinaryFormat/Dwarf.def"
		458	DW_LNCT_lo_user = 0x2000,
		459	DW_LNCT_hi_user = 0x3fff,
		460	};
		461
		462	enum MacinfoRecordType {
		463	// Macinfo Type Encodings
		464	DW_MACINFO_define = 0x01,
		465	DW_MACINFO_undef = 0x02,
		466	DW_MACINFO_start_file = 0x03,
		467	DW_MACINFO_end_file = 0x04,
		468	DW_MACINFO_vendor_ext = 0xff
		469	};
		470
		471	/// DWARF v5 macro information entry type encodings.
		472	enum MacroEntryType {
		473	#define HANDLE_DW_MACRO(ID, NAME) DW_MACRO_##NAME = ID,
		474	#include "llvm/BinaryFormat/Dwarf.def"
		475	DW_MACRO_lo_user = 0xe0,
		476	DW_MACRO_hi_user = 0xff
		477	};
		478
		479	/// GNU .debug_macro macro information entry type encodings.
		480	enum GnuMacroEntryType {
		481	#define HANDLE_DW_MACRO_GNU(ID, NAME) DW_MACRO_GNU_##NAME = ID,
		482	#include "llvm/BinaryFormat/Dwarf.def"
		483	DW_MACRO_GNU_lo_user = 0xe0,
		484	DW_MACRO_GNU_hi_user = 0xff
		485	};
		486
		487	/// DWARF v5 range list entry encoding values.
		488	enum RnglistEntries {
		489	#define HANDLE_DW_RLE(ID, NAME) DW_RLE_##NAME = ID,
		490	#include "llvm/BinaryFormat/Dwarf.def"
		491	};
		492
		493	/// DWARF v5 loc list entry encoding values.
		494	enum LoclistEntries {
		495	#define HANDLE_DW_LLE(ID, NAME) DW_LLE_##NAME = ID,
		496	#include "llvm/BinaryFormat/Dwarf.def"
		497	};
		498
		499	/// Call frame instruction encodings.
		500	enum CallFrameInfo {
		501	#define HANDLE_DW_CFA(ID, NAME) DW_CFA_##NAME = ID,
		502	#define HANDLE_DW_CFA_PRED(ID, NAME, ARCH) DW_CFA_##NAME = ID,
		503	#include "llvm/BinaryFormat/Dwarf.def"
		504	DW_CFA_extended = 0x00,
		505
		506	DW_CFA_lo_user = 0x1c,
		507	DW_CFA_hi_user = 0x3f
		508	};
		509
		510	enum Constants {
		511	// Children flag
		512	DW_CHILDREN_no = 0x00,
		513	DW_CHILDREN_yes = 0x01,
		514
		515	DW_EH_PE_absptr = 0x00,
		516	DW_EH_PE_omit = 0xff,
		517	DW_EH_PE_uleb128 = 0x01,
		518	DW_EH_PE_udata2 = 0x02,
		519	DW_EH_PE_udata4 = 0x03,
		520	DW_EH_PE_udata8 = 0x04,
		521	DW_EH_PE_sleb128 = 0x09,
		522	DW_EH_PE_sdata2 = 0x0A,
		523	DW_EH_PE_sdata4 = 0x0B,
		524	DW_EH_PE_sdata8 = 0x0C,
		525	DW_EH_PE_signed = 0x08,
		526	DW_EH_PE_pcrel = 0x10,
		527	DW_EH_PE_textrel = 0x20,
		528	DW_EH_PE_datarel = 0x30,
		529	DW_EH_PE_funcrel = 0x40,
		530	DW_EH_PE_aligned = 0x50,
		531	DW_EH_PE_indirect = 0x80
		532	};
		533
		534	/// Constants for the DW_APPLE_PROPERTY_attributes attribute.
		535	/// Keep this list in sync with clang's DeclObjCCommon.h
		536	/// ObjCPropertyAttribute::Kind!
		537	enum ApplePropertyAttributes {
		538	#define HANDLE_DW_APPLE_PROPERTY(ID, NAME) DW_APPLE_PROPERTY_##NAME = ID,
		539	#include "llvm/BinaryFormat/Dwarf.def"
		540	};
		541
		542	/// Constants for unit types in DWARF v5.
		543	enum UnitType : unsigned char {
		544	#define HANDLE_DW_UT(ID, NAME) DW_UT_##NAME = ID,
		545	#include "llvm/BinaryFormat/Dwarf.def"
		546	DW_UT_lo_user = 0x80,
		547	DW_UT_hi_user = 0xff
		548	};
		549
		550	enum Index {
		551	#define HANDLE_DW_IDX(ID, NAME) DW_IDX_##NAME = ID,
		552	#include "llvm/BinaryFormat/Dwarf.def"
		553	DW_IDX_lo_user = 0x2000,
		554	DW_IDX_hi_user = 0x3fff
		555	};
		556
		557	inline bool isUnitType(uint8_t UnitType) {
		558	switch (UnitType) {
		559	case DW_UT_compile:
		560	case DW_UT_type:
		561	case DW_UT_partial:
		562	case DW_UT_skeleton:
		563	case DW_UT_split_compile:
		564	case DW_UT_split_type:
		565	return true;
		566	default:
		567	return false;
		568	}
		569	}
		570
		571	inline bool isUnitType(dwarf::Tag T) {
		572	switch (T) {
		573	case DW_TAG_compile_unit:
		574	case DW_TAG_type_unit:
		575	case DW_TAG_partial_unit:
		576	case DW_TAG_skeleton_unit:
		577	return true;
		578	default:
		579	return false;
		580	}
		581	}
		582
		583	// Constants for the DWARF v5 Accelerator Table Proposal
		584	enum AcceleratorTable {
		585	// Data layout descriptors.
		586	DW_ATOM_null = 0u, /// Marker as the end of a list of atoms.
		587	DW_ATOM_die_offset = 1u, // DIE offset in the debug_info section.
		588	DW_ATOM_cu_offset = 2u, // Offset of the compile unit header that contains the
		589	// item in question.
		590	DW_ATOM_die_tag = 3u, // A tag entry.
		591	DW_ATOM_type_flags = 4u, // Set of flags for a type.
		592
		593	DW_ATOM_type_type_flags = 5u, // Dsymutil type extension.
		594	DW_ATOM_qual_name_hash = 6u, // Dsymutil qualified hash extension.
		595
		596	// DW_ATOM_type_flags values.
		597
		598	// Always set for C++, only set for ObjC if this is the @implementation for a
		599	// class.
		600	DW_FLAG_type_implementation = 2u,
		601
		602	// Hash functions.
		603
		604	// Daniel J. Bernstein hash.
		605	DW_hash_function_djb = 0u
		606	};
		607
		608	// Constants for the GNU pubnames/pubtypes extensions supporting gdb index.
		609	enum GDBIndexEntryKind {
		610	GIEK_NONE,
		611	GIEK_TYPE,
		612	GIEK_VARIABLE,
		613	GIEK_FUNCTION,
		614	GIEK_OTHER,
		615	GIEK_UNUSED5,
		616	GIEK_UNUSED6,
		617	GIEK_UNUSED7
		618	};
		619
		620	enum GDBIndexEntryLinkage { GIEL_EXTERNAL, GIEL_STATIC };
		621
		622	/// \defgroup DwarfConstantsDumping Dwarf constants dumping functions
		623	///
		624	/// All these functions map their argument's value back to the
		625	/// corresponding enumerator name or return an empty StringRef if the value
		626	/// isn't known.
		627	///
		628	/// @{
		629	StringRef TagString(unsigned Tag);
		630	StringRef ChildrenString(unsigned Children);
		631	StringRef AttributeString(unsigned Attribute);
		632	StringRef FormEncodingString(unsigned Encoding);
		633	StringRef OperationEncodingString(unsigned Encoding);
		634	StringRef AttributeEncodingString(unsigned Encoding);
		635	StringRef DecimalSignString(unsigned Sign);
		636	StringRef EndianityString(unsigned Endian);
		637	StringRef AccessibilityString(unsigned Access);
		638	StringRef DefaultedMemberString(unsigned DefaultedEncodings);
		639	StringRef VisibilityString(unsigned Visibility);
		640	StringRef VirtualityString(unsigned Virtuality);
		641	StringRef LanguageString(unsigned Language);
		642	StringRef CaseString(unsigned Case);
		643	StringRef ConventionString(unsigned Convention);
		644	StringRef InlineCodeString(unsigned Code);
		645	StringRef ArrayOrderString(unsigned Order);
		646	StringRef LNStandardString(unsigned Standard);
		647	StringRef LNExtendedString(unsigned Encoding);
		648	StringRef MacinfoString(unsigned Encoding);
		649	StringRef MacroString(unsigned Encoding);
		650	StringRef GnuMacroString(unsigned Encoding);
		651	StringRef RangeListEncodingString(unsigned Encoding);
		652	StringRef LocListEncodingString(unsigned Encoding);
		653	StringRef CallFrameString(unsigned Encoding, Triple::ArchType Arch);
		654	StringRef ApplePropertyString(unsigned);
		655	StringRef UnitTypeString(unsigned);
		656	StringRef AtomTypeString(unsigned Atom);
		657	StringRef GDBIndexEntryKindString(GDBIndexEntryKind Kind);
		658	StringRef GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage);
		659	StringRef IndexString(unsigned Idx);
		660	StringRef FormatString(DwarfFormat Format);
		661	StringRef FormatString(bool IsDWARF64);
		662	StringRef RLEString(unsigned RLE);
		663	/// @}
		664
		665	/// \defgroup DwarfConstantsParsing Dwarf constants parsing functions
		666	///
		667	/// These functions map their strings back to the corresponding enumeration
		668	/// value or return 0 if there is none, except for these exceptions:
		669	///
		670	/// \li \a getTag() returns \a DW_TAG_invalid on invalid input.
		671	/// \li \a getVirtuality() returns \a DW_VIRTUALITY_invalid on invalid input.
		672	/// \li \a getMacinfo() returns \a DW_MACINFO_invalid on invalid input.
		673	///
		674	/// @{
		675	unsigned getTag(StringRef TagString);
		676	unsigned getOperationEncoding(StringRef OperationEncodingString);
		677	unsigned getVirtuality(StringRef VirtualityString);
		678	unsigned getLanguage(StringRef LanguageString);
		679	unsigned getCallingConvention(StringRef LanguageString);
		680	unsigned getAttributeEncoding(StringRef EncodingString);
		681	unsigned getMacinfo(StringRef MacinfoString);
		682	unsigned getMacro(StringRef MacroString);
		683	/// @}
		684
		685	/// \defgroup DwarfConstantsVersioning Dwarf version for constants
		686	///
		687	/// For constants defined by DWARF, returns the DWARF version when the constant
		688	/// was first defined. For vendor extensions, if there is a version-related
		689	/// policy for when to emit it, returns a version number for that policy.
		690	/// Otherwise returns 0.
		691	///
		692	/// @{
		693	unsigned TagVersion(Tag T);
		694	unsigned AttributeVersion(Attribute A);
		695	unsigned FormVersion(Form F);
		696	unsigned OperationVersion(LocationAtom O);
		697	unsigned AttributeEncodingVersion(TypeKind E);
		698	unsigned LanguageVersion(SourceLanguage L);
		699	/// @}
		700
		701	/// \defgroup DwarfConstantsVendor Dwarf "vendor" for constants
		702	///
		703	/// These functions return an identifier describing "who" defined the constant,
		704	/// either the DWARF standard itself or the vendor who defined the extension.
		705	///
		706	/// @{
		707	unsigned TagVendor(Tag T);
		708	unsigned AttributeVendor(Attribute A);
		709	unsigned FormVendor(Form F);
		710	unsigned OperationVendor(LocationAtom O);
		711	unsigned AttributeEncodingVendor(TypeKind E);
		712	unsigned LanguageVendor(SourceLanguage L);
		713	/// @}
		714
		715	std::optional<unsigned> LanguageLowerBound(SourceLanguage L);
		716
		717	/// The size of a reference determined by the DWARF 32/64-bit format.
		718	inline uint8_t getDwarfOffsetByteSize(DwarfFormat Format) {
		719	switch (Format) {
		720	case DwarfFormat::DWARF32:
		721	return 4;
		722	case DwarfFormat::DWARF64:
		723	return 8;
		724	}
		725	llvm_unreachable("Invalid Format value");
		726	}
		727
		728	/// A helper struct providing information about the byte size of DW_FORM
		729	/// values that vary in size depending on the DWARF version, address byte
		730	/// size, or DWARF32/DWARF64.
		731	struct FormParams {
		732	uint16_t Version;
		733	uint8_t AddrSize;
		734	DwarfFormat Format;
		735	/// True if DWARF v2 output generally uses relocations for references
		736	/// to other .debug_* sections.
		737	bool DwarfUsesRelocationsAcrossSections = false;
		738
		739	/// The definition of the size of form DW_FORM_ref_addr depends on the
		740	/// version. In DWARF v2 it's the size of an address; after that, it's the
		741	/// size of a reference.
		742	uint8_t getRefAddrByteSize() const {
		743	if (Version == 2)
		744	return AddrSize;
		745	return getDwarfOffsetByteSize();
		746	}
		747
		748	/// The size of a reference is determined by the DWARF 32/64-bit format.
		749	uint8_t getDwarfOffsetByteSize() const {
		750	return dwarf::getDwarfOffsetByteSize(Format);
		751	}
		752
		753	explicit operator bool() const { return Version && AddrSize; }
		754	};
		755
		756	/// Get the byte size of the unit length field depending on the DWARF format.
		757	inline uint8_t getUnitLengthFieldByteSize(DwarfFormat Format) {
		758	switch (Format) {
		759	case DwarfFormat::DWARF32:
		760	return 4;
		761	case DwarfFormat::DWARF64:
		762	return 12;
		763	}
		764	llvm_unreachable("Invalid Format value");
		765	}
		766
		767	/// Get the fixed byte size for a given form.
		768	///
		769	/// If the form has a fixed byte size, then an Optional with a value will be
		770	/// returned. If the form is always encoded using a variable length storage
		771	/// format (ULEB or SLEB numbers or blocks) then std::nullopt will be returned.
		772	///
		773	/// \param Form DWARF form to get the fixed byte size for.
		774	/// \param Params DWARF parameters to help interpret forms.
		775	/// \returns std::optional<uint8_t> value with the fixed byte size or
		776	/// std::nullopt if \p Form doesn't have a fixed byte size.
		777	std::optional<uint8_t> getFixedFormByteSize(dwarf::Form Form,
		778	FormParams Params);
		779
		780	/// Tells whether the specified form is defined in the specified version,
		781	/// or is an extension if extensions are allowed.
		782	bool isValidFormForVersion(Form F, unsigned Version, bool ExtensionsOk = true);
		783
		784	/// Returns the symbolic string representing Val when used as a value
		785	/// for attribute Attr.
		786	StringRef AttributeValueString(uint16_t Attr, unsigned Val);
		787
		788	/// Returns the symbolic string representing Val when used as a value
		789	/// for atom Atom.
		790	StringRef AtomValueString(uint16_t Atom, unsigned Val);
		791
		792	/// Describes an entry of the various gnu_pub* debug sections.
		793	///
		794	/// The gnu_pub* kind looks like:
		795	///
		796	/// 0-3 reserved
		797	/// 4-6 symbol kind
		798	/// 7 0 == global, 1 == static
		799	///
		800	/// A gdb_index descriptor includes the above kind, shifted 24 bits up with the
		801	/// offset of the cu within the debug_info section stored in those 24 bits.
		802	struct PubIndexEntryDescriptor {
		803	GDBIndexEntryKind Kind;
		804	GDBIndexEntryLinkage Linkage;
		805	PubIndexEntryDescriptor(GDBIndexEntryKind Kind, GDBIndexEntryLinkage Linkage)
		806	: Kind(Kind), Linkage(Linkage) {}
		807	/* implicit */ PubIndexEntryDescriptor(GDBIndexEntryKind Kind)
		808	: Kind(Kind), Linkage(GIEL_EXTERNAL) {}
		809	explicit PubIndexEntryDescriptor(uint8_t Value)
		810	: Kind(
		811	static_cast<GDBIndexEntryKind>((Value & KIND_MASK) >> KIND_OFFSET)),
		812	Linkage(static_cast<GDBIndexEntryLinkage>((Value & LINKAGE_MASK) >>
		813	LINKAGE_OFFSET)) {}
		814	uint8_t toBits() const {
		815	return Kind << KIND_OFFSET \| Linkage << LINKAGE_OFFSET;
		816	}
		817
		818	private:
		819	enum {
		820	KIND_OFFSET = 4,
		821	KIND_MASK = 7 << KIND_OFFSET,
		822	LINKAGE_OFFSET = 7,
		823	LINKAGE_MASK = 1 << LINKAGE_OFFSET
		824	};
		825	};
		826
		827	template <typename Enum> struct EnumTraits : public std::false_type {};
		828
		829	template <> struct EnumTraits<Attribute> : public std::true_type {
		830	static constexpr char Type[3] = "AT";
		831	static constexpr StringRef (*StringFn)(unsigned) = &AttributeString;
		832	};
		833
		834	template <> struct EnumTraits<Form> : public std::true_type {
		835	static constexpr char Type[5] = "FORM";
		836	static constexpr StringRef (*StringFn)(unsigned) = &FormEncodingString;
		837	};
		838
		839	template <> struct EnumTraits<Index> : public std::true_type {
		840	static constexpr char Type[4] = "IDX";
		841	static constexpr StringRef (*StringFn)(unsigned) = &IndexString;
		842	};
		843
		844	template <> struct EnumTraits<Tag> : public std::true_type {
		845	static constexpr char Type[4] = "TAG";
		846	static constexpr StringRef (*StringFn)(unsigned) = &TagString;
		847	};
		848
		849	template <> struct EnumTraits<LineNumberOps> : public std::true_type {
		850	static constexpr char Type[4] = "LNS";
		851	static constexpr StringRef (*StringFn)(unsigned) = &LNStandardString;
		852	};
		853
		854	template <> struct EnumTraits<LocationAtom> : public std::true_type {
		855	static constexpr char Type[3] = "OP";
		856	static constexpr StringRef (*StringFn)(unsigned) = &OperationEncodingString;
		857	};
		858
		859	inline uint64_t computeTombstoneAddress(uint8_t AddressByteSize) {
		860	return std::numeric_limits<uint64_t>::max() >> (8 - AddressByteSize) * 8;
		861	}
		862
		863	} // End of namespace dwarf
		864
		865	/// Dwarf constants format_provider
		866	///
		867	/// Specialization of the format_provider template for dwarf enums. Unlike the
		868	/// dumping functions above, these format unknown enumerator values as
		869	/// DW_TYPE_unknown_1234 (e.g. DW_TAG_unknown_ffff).
		870	template <typename Enum>
		871	struct format_provider<Enum, std::enable_if_t<dwarf::EnumTraits<Enum>::value>> {
		872	static void format(const Enum &E, raw_ostream &OS, StringRef Style) {
		873	StringRef Str = dwarf::EnumTraits<Enum>::StringFn(E);
		874	if (Str.empty()) {
		875	OS << "DW_" << dwarf::EnumTraits<Enum>::Type << "_unknown_"
		876	<< llvm::format("%x", E);
		877	} else
		878	OS << Str;
		879	}
		880	};
		881	} // End of namespace llvm
		882
		883	#endif

Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

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