LLVM 20.0.0git
AccelTable.h
Go to the documentation of this file.
1//==- include/llvm/CodeGen/AccelTable.h - Accelerator Tables -----*- 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/// \file
9/// This file contains support for writing accelerator tables.
10///
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CODEGEN_ACCELTABLE_H
14#define LLVM_CODEGEN_ACCELTABLE_H
15
16#include "llvm/ADT/ArrayRef.h"
17#include "llvm/ADT/MapVector.h"
19#include "llvm/ADT/StringRef.h"
21#include "llvm/CodeGen/DIE.h"
24#include "llvm/Support/DJB.h"
25#include "llvm/Support/Debug.h"
26#include <cstdint>
27#include <variant>
28#include <vector>
29
30/// \file
31/// The DWARF and Apple accelerator tables are an indirect hash table optimized
32/// for null lookup rather than access to known data. The Apple accelerator
33/// tables are a precursor of the newer DWARF v5 accelerator tables. Both
34/// formats share common design ideas.
35///
36/// The Apple accelerator table are output into an on-disk format that looks
37/// like this:
38///
39/// .------------------.
40/// | HEADER |
41/// |------------------|
42/// | BUCKETS |
43/// |------------------|
44/// | HASHES |
45/// |------------------|
46/// | OFFSETS |
47/// |------------------|
48/// | DATA |
49/// `------------------'
50///
51/// The header contains a magic number, version, type of hash function,
52/// the number of buckets, total number of hashes, and room for a special struct
53/// of data and the length of that struct.
54///
55/// The buckets contain an index (e.g. 6) into the hashes array. The hashes
56/// section contains all of the 32-bit hash values in contiguous memory, and the
57/// offsets contain the offset into the data area for the particular hash.
58///
59/// For a lookup example, we could hash a function name and take it modulo the
60/// number of buckets giving us our bucket. From there we take the bucket value
61/// as an index into the hashes table and look at each successive hash as long
62/// as the hash value is still the same modulo result (bucket value) as earlier.
63/// If we have a match we look at that same entry in the offsets table and grab
64/// the offset in the data for our final match.
65///
66/// The DWARF v5 accelerator table consists of zero or more name indices that
67/// are output into an on-disk format that looks like this:
68///
69/// .------------------.
70/// | HEADER |
71/// |------------------|
72/// | CU LIST |
73/// |------------------|
74/// | LOCAL TU LIST |
75/// |------------------|
76/// | FOREIGN TU LIST |
77/// |------------------|
78/// | HASH TABLE |
79/// |------------------|
80/// | NAME TABLE |
81/// |------------------|
82/// | ABBREV TABLE |
83/// |------------------|
84/// | ENTRY POOL |
85/// `------------------'
86///
87/// For the full documentation please refer to the DWARF 5 standard.
88///
89///
90/// This file defines the class template AccelTable, which is represents an
91/// abstract view of an Accelerator table, without any notion of an on-disk
92/// layout. This class is parameterized by an entry type, which should derive
93/// from AccelTableData. This is the type of individual entries in the table,
94/// and it should store the data necessary to emit them. AppleAccelTableData is
95/// the base class for Apple Accelerator Table entries, which have a uniform
96/// structure based on a sequence of Atoms. There are different sub-classes
97/// derived from AppleAccelTable, which differ in the set of Atoms and how they
98/// obtain their values.
99///
100/// An Apple Accelerator Table can be serialized by calling emitAppleAccelTable
101/// function.
102
103namespace llvm {
104
105class AsmPrinter;
106class DwarfDebug;
107class DwarfTypeUnit;
108class MCSymbol;
109class raw_ostream;
110
111/// Interface which the different types of accelerator table data have to
112/// conform. It serves as a base class for different values of the template
113/// argument of the AccelTable class template.
115public:
116 virtual ~AccelTableData() = default;
117
118 bool operator<(const AccelTableData &Other) const {
119 return order() < Other.order();
120 }
121
122 // Subclasses should implement:
123 // static uint32_t hash(StringRef Name);
124
125#ifndef NDEBUG
126 virtual void print(raw_ostream &OS) const = 0;
127#endif
128protected:
129 virtual uint64_t order() const = 0;
130};
131
132/// A base class holding non-template-dependant functionality of the AccelTable
133/// class. Clients should not use this class directly but rather instantiate
134/// AccelTable with a type derived from AccelTableData.
136public:
138
139 /// Represents a group of entries with identical name (and hence, hash value).
140 struct HashData {
143 std::vector<AccelTableData *> Values;
145
146 /// Get all AccelTableData cast as a `T`.
147 template <typename T = AccelTableData *> auto getValues() const {
148 static_assert(std::is_pointer<T>());
149 static_assert(
150 std::is_base_of<AccelTableData, std::remove_pointer_t<T>>());
151 return map_range(
152 Values, [](AccelTableData *Data) { return static_cast<T>(Data); });
153 }
154
155#ifndef NDEBUG
156 void print(raw_ostream &OS) const;
157 void dump() const { print(dbgs()); }
158#endif
159 };
160 using HashList = std::vector<HashData *>;
161 using BucketList = std::vector<HashList>;
162
163protected:
164 /// Allocator for HashData and Values.
166
169
173
176
177 void computeBucketCount();
178
180
181public:
182 void finalize(AsmPrinter *Asm, StringRef Prefix);
187
188#ifndef NDEBUG
189 void print(raw_ostream &OS) const;
190 void dump() const { print(dbgs()); }
191#endif
192
194 void operator=(const AccelTableBase &) = delete;
195};
196
197/// This class holds an abstract representation of an Accelerator Table,
198/// consisting of a sequence of buckets, each bucket containint a sequence of
199/// HashData entries. The class is parameterized by the type of entries it
200/// holds. The type template parameter also defines the hash function to use for
201/// hashing names.
202template <typename DataT> class AccelTable : public AccelTableBase {
203public:
204 AccelTable() : AccelTableBase(DataT::hash) {}
205
206 template <typename... Types>
207 void addName(DwarfStringPoolEntryRef Name, Types &&... Args);
208 void clear() { Entries.clear(); }
210 const StringEntries getEntries() const { return Entries; }
211};
212
213template <typename AccelTableDataT>
214template <typename... Types>
216 Types &&... Args) {
217 assert(Buckets.empty() && "Already finalized!");
218 // If the string is in the list already then add this die to the list
219 // otherwise add a new one.
220 auto &It = Entries[Name.getString()];
221 if (It.Values.empty()) {
222 It.Name = Name;
223 It.HashValue = Hash(Name.getString());
224 }
225 It.Values.push_back(new (Allocator)
226 AccelTableDataT(std::forward<Types>(Args)...));
227}
228
229/// A base class for different implementations of Data classes for Apple
230/// Accelerator Tables. The columns in the table are defined by the static Atoms
231/// variable defined on the subclasses.
233public:
234 /// An Atom defines the form of the data in an Apple accelerator table.
235 /// Conceptually it is a column in the accelerator consisting of a type and a
236 /// specification of the form of its data.
237 struct Atom {
238 /// Atom Type.
240 /// DWARF Form.
242
244
245#ifndef NDEBUG
246 void print(raw_ostream &OS) const;
247 void dump() const { print(dbgs()); }
248#endif
249 };
250 // Subclasses should define:
251 // static constexpr Atom Atoms[];
252
253 virtual void emit(AsmPrinter *Asm) const = 0;
254
255 static uint32_t hash(StringRef Buffer) { return djbHash(Buffer); }
256};
257
258/// Helper class to identify an entry in DWARF5AccelTable based on their DIE
259/// offset and UnitID.
263 bool IsTU = false;
264 OffsetAndUnitID() = delete;
267 uint64_t offset() const { return Offset; };
268 uint32_t unitID() const { return UnitID; };
269 bool isTU() const { return IsTU; }
270};
271
272template <> struct DenseMapInfo<OffsetAndUnitID> {
273 static inline OffsetAndUnitID getEmptyKey() {
274 return OffsetAndUnitID(-1, -1, false);
275 }
277 return OffsetAndUnitID(-2, -2, false);
278 }
279 static unsigned getHashValue(const OffsetAndUnitID &Val) {
280 return (unsigned)llvm::hash_combine(Val.offset(), Val.unitID(), Val.IsTU);
281 }
282 static bool isEqual(const OffsetAndUnitID &LHS, const OffsetAndUnitID &RHS) {
283 return LHS.offset() == RHS.offset() && LHS.unitID() == RHS.unitID() &&
284 LHS.IsTU == RHS.isTU();
285 }
286};
287
288/// The Data class implementation for DWARF v5 accelerator table. Unlike the
289/// Apple Data classes, this class is just a DIE wrapper, and does not know to
290/// serialize itself. The complete serialization logic is in the
291/// emitDWARF5AccelTable function.
293public:
295
296 DWARF5AccelTableData(const DIE &Die, const uint32_t UnitID, const bool IsTU);
298 const std::optional<uint64_t> DefiningParentOffset,
299 const unsigned DieTag, const unsigned UnitID,
300 const bool IsTU)
301 : OffsetVal(DieOffset), ParentOffset(DefiningParentOffset),
303
304#ifndef NDEBUG
305 void print(raw_ostream &OS) const override;
306#endif
307
309 assert(isNormalized() && "Accessing DIE Offset before normalizing.");
310 return std::get<uint64_t>(OffsetVal);
311 }
312
314 return {getDieOffset(), getUnitID(), isTU()};
315 }
316
317 unsigned getDieTag() const { return DieTag; }
318 unsigned getUnitID() const { return UnitID; }
319 bool isTU() const { return IsTU; }
321 assert(!isNormalized() && "Accessing offset after normalizing.");
322 const DIE *Entry = std::get<const DIE *>(OffsetVal);
324 OffsetVal = Entry->getOffset();
325 }
326 bool isNormalized() const {
327 return std::holds_alternative<uint64_t>(OffsetVal);
328 }
329
330 std::optional<uint64_t> getParentDieOffset() const {
331 if (auto OffsetAndId = getParentDieOffsetAndUnitID())
332 return OffsetAndId->offset();
333 return {};
334 }
335
336 std::optional<OffsetAndUnitID> getParentDieOffsetAndUnitID() const {
337 assert(isNormalized() && "Accessing DIE Offset before normalizing.");
338 if (!ParentOffset)
339 return std::nullopt;
341 }
342
343 /// Sets AbbrevIndex for an Entry.
344 void setAbbrevNumber(uint16_t AbbrevNum) { AbbrevNumber = AbbrevNum; }
345
346 /// Returns AbbrevIndex for an Entry.
348
349 /// If `Die` has a non-null parent and the parent is not a declaration,
350 /// return its offset.
351 static std::optional<uint64_t> getDefiningParentDieOffset(const DIE &Die);
352
353protected:
354 std::variant<const DIE *, uint64_t> OffsetVal;
355 std::optional<uint64_t> ParentOffset;
360 uint64_t order() const override { return getDieOffset(); }
361};
362
364public:
370 };
372 /// Add attribute encoding to an abbreviation.
374 AttrVect.push_back(Attr);
375 }
376 /// Set abbreviation tag index.
377 void setNumber(uint32_t AbbrevNumber) { Number = AbbrevNumber; }
378 /// Get abbreviation tag index.
379 uint32_t getNumber() const { return Number; }
380 /// Get DIE Tag.
381 uint32_t getDieTag() const { return DieTag; }
382 /// Used to gather unique data for the abbreviation folding set.
383 void Profile(FoldingSetNodeID &ID) const;
384 /// Returns attributes for an abbreviation.
386 return AttrVect;
387 }
388
389private:
391};
392
394 // Symbol for start of the TU section or signature if this is SplitDwarf.
395 std::variant<MCSymbol *, uint64_t> LabelOrSignature;
396 // Unique ID of Type Unit.
397 unsigned UniqueID;
398};
400class DWARF5AccelTable : public AccelTable<DWARF5AccelTableData> {
401 // Symbols to start of all the TU sections that were generated.
402 TUVectorTy TUSymbolsOrHashes;
403
404public:
406 unsigned Index;
408 };
409 /// Returns type units that were constructed.
410 const TUVectorTy &getTypeUnitsSymbols() { return TUSymbolsOrHashes; }
411 /// Add a type unit start symbol.
413 /// Add a type unit Signature.
415 /// Convert DIE entries to explicit offset.
416 /// Needs to be called after DIE offsets are computed.
418 for (auto &Entry : Entries) {
419 for (auto *Data : Entry.second.getValues<DWARF5AccelTableData *>()) {
420 // For TU we normalize as each Unit is emitted.
421 // So when this is invoked after CU construction we will be in mixed
422 // state.
423 if (!Data->isNormalized())
424 Data->normalizeDIEToOffset();
425 }
426 }
427 }
428
430 for (auto &Entry : Table.getEntries()) {
431 for (auto *Data : Entry.second.getValues<DWARF5AccelTableData *>()) {
432 addName(Entry.second.Name, Data->getDieOffset(),
433 Data->getParentDieOffset(), Data->getDieTag(),
434 Data->getUnitID(), Data->isTU());
435 }
436 }
437 }
438};
439
440void emitAppleAccelTableImpl(AsmPrinter *Asm, AccelTableBase &Contents,
441 StringRef Prefix, const MCSymbol *SecBegin,
442 ArrayRef<AppleAccelTableData::Atom> Atoms);
443
444/// Emit an Apple Accelerator Table consisting of entries in the specified
445/// AccelTable. The DataT template parameter should be derived from
446/// AppleAccelTableData.
447template <typename DataT>
449 StringRef Prefix, const MCSymbol *SecBegin) {
450 static_assert(std::is_convertible<DataT *, AppleAccelTableData *>::value);
451 emitAppleAccelTableImpl(Asm, Contents, Prefix, SecBegin, DataT::Atoms);
452}
453
454void emitDWARF5AccelTable(AsmPrinter *Asm, DWARF5AccelTable &Contents,
455 const DwarfDebug &DD,
456 ArrayRef<std::unique_ptr<DwarfCompileUnit>> CUs);
457
458/// Emit a DWARFv5 Accelerator Table consisting of entries in the specified
459/// AccelTable. The \p CUs contains either symbols keeping offsets to the
460/// start of compilation unit, either offsets to the start of compilation
461/// unit themselves.
463 AsmPrinter *Asm, DWARF5AccelTable &Contents,
464 ArrayRef<std::variant<MCSymbol *, uint64_t>> CUs,
465 llvm::function_ref<std::optional<DWARF5AccelTable::UnitIndexAndEncoding>(
466 const DWARF5AccelTableData &)>
467 getIndexForEntry);
468
469/// Accelerator table data implementation for simple Apple accelerator tables
470/// with just a DIE reference.
472public:
474
475 void emit(AsmPrinter *Asm) const override;
476
477 static constexpr Atom Atoms[] = {
478 Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4)};
479
480#ifndef NDEBUG
481 void print(raw_ostream &OS) const override;
482#endif
483protected:
484 uint64_t order() const override { return Die.getOffset(); }
485
486 const DIE &Die;
487};
488
489/// Accelerator table data implementation for Apple type accelerator tables.
491public:
493
494 void emit(AsmPrinter *Asm) const override;
495
496 static constexpr Atom Atoms[] = {
497 Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4),
498 Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2),
499 Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1)};
500
501#ifndef NDEBUG
502 void print(raw_ostream &OS) const override;
503#endif
504};
505
506/// Accelerator table data implementation for simple Apple accelerator tables
507/// with a DIE offset but no actual DIE pointer.
509public:
511
512 void emit(AsmPrinter *Asm) const override;
513
514 static constexpr Atom Atoms[] = {
515 Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4)};
516
517#ifndef NDEBUG
518 void print(raw_ostream &OS) const override;
519#endif
520protected:
521 uint64_t order() const override { return Offset; }
522
524};
525
526/// Accelerator table data implementation for type accelerator tables with
527/// a DIE offset but no actual DIE pointer.
529public:
536
537 void emit(AsmPrinter *Asm) const override;
538
539 static constexpr Atom Atoms[] = {
540 Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4),
541 Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2),
542 Atom(5, dwarf::DW_FORM_data1), Atom(6, dwarf::DW_FORM_data4)};
543
544#ifndef NDEBUG
545 void print(raw_ostream &OS) const override;
546#endif
547protected:
548 uint64_t order() const override { return Offset; }
549
553};
554
555} // end namespace llvm
556
557#endif // LLVM_CODEGEN_ACCELTABLE_H
arc branch finalize
This file defines the BumpPtrAllocator interface.
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
This file contains constants used for implementing Dwarf debug support.
std::string Name
Load MIR Sample Profile
This file implements a map that provides insertion order iteration.
Basic Register Allocator
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
Value * RHS
Value * LHS
A base class holding non-template-dependant functionality of the AccelTable class.
Definition: AccelTable.h:135
BucketList Buckets
Definition: AccelTable.h:175
uint32_t getUniqueNameCount() const
Definition: AccelTable.h:186
std::vector< HashData * > HashList
Definition: AccelTable.h:160
std::vector< HashList > BucketList
Definition: AccelTable.h:161
BumpPtrAllocator Allocator
Allocator for HashData and Values.
Definition: AccelTable.h:165
void operator=(const AccelTableBase &)=delete
uint32_t getUniqueHashCount() const
Definition: AccelTable.h:185
void print(raw_ostream &OS) const
Definition: AccelTable.cpp:794
void dump() const
Definition: AccelTable.h:190
AccelTableBase(const AccelTableBase &)=delete
AccelTableBase(HashFn *Hash)
Definition: AccelTable.h:179
ArrayRef< HashList > getBuckets() const
Definition: AccelTable.h:183
uint32_t getBucketCount() const
Definition: AccelTable.h:184
uint32_t(StringRef) HashFn
Definition: AccelTable.h:137
uint32_t UniqueHashCount
Definition: AccelTable.h:172
StringEntries Entries
Definition: AccelTable.h:168
Interface which the different types of accelerator table data have to conform.
Definition: AccelTable.h:114
virtual uint64_t order() const =0
virtual ~AccelTableData()=default
virtual void print(raw_ostream &OS) const =0
bool operator<(const AccelTableData &Other) const
Definition: AccelTable.h:118
This class holds an abstract representation of an Accelerator Table, consisting of a sequence of buck...
Definition: AccelTable.h:202
const StringEntries getEntries() const
Definition: AccelTable.h:210
void addEntries(AccelTable< DataT > &Table)
void addName(DwarfStringPoolEntryRef Name, Types &&... Args)
Definition: AccelTable.h:215
A base class for different implementations of Data classes for Apple Accelerator Tables.
Definition: AccelTable.h:232
virtual void emit(AsmPrinter *Asm) const =0
static uint32_t hash(StringRef Buffer)
Definition: AccelTable.h:255
Accelerator table data implementation for simple Apple accelerator tables with just a DIE reference.
Definition: AccelTable.h:471
void emit(AsmPrinter *Asm) const override
Definition: AccelTable.cpp:723
uint64_t order() const override
Definition: AccelTable.h:484
void print(raw_ostream &OS) const override
Definition: AccelTable.cpp:818
static constexpr Atom Atoms[]
Definition: AccelTable.h:477
AppleAccelTableOffsetData(const DIE &D)
Definition: AccelTable.h:473
Accelerator table data implementation for simple Apple accelerator tables with a DIE offset but no ac...
Definition: AccelTable.h:508
AppleAccelTableStaticOffsetData(uint32_t Offset)
Definition: AccelTable.h:510
static constexpr Atom Atoms[]
Definition: AccelTable.h:514
void emit(AsmPrinter *Asm) const override
Definition: AccelTable.cpp:737
void print(raw_ostream &OS) const override
Definition: AccelTable.cpp:827
uint64_t order() const override
Definition: AccelTable.h:521
Accelerator table data implementation for type accelerator tables with a DIE offset but no actual DIE...
Definition: AccelTable.h:528
void emit(AsmPrinter *Asm) const override
Definition: AccelTable.cpp:741
void print(raw_ostream &OS) const override
Definition: AccelTable.cpp:831
static constexpr Atom Atoms[]
Definition: AccelTable.h:539
uint64_t order() const override
Definition: AccelTable.h:548
AppleAccelTableStaticTypeData(uint32_t Offset, uint16_t Tag, bool ObjCClassIsImplementation, uint32_t QualifiedNameHash)
Definition: AccelTable.h:530
Accelerator table data implementation for Apple type accelerator tables.
Definition: AccelTable.h:490
void print(raw_ostream &OS) const override
Definition: AccelTable.cpp:822
AppleAccelTableTypeData(const DIE &D)
Definition: AccelTable.h:492
void emit(AsmPrinter *Asm) const override
Definition: AccelTable.cpp:729
static constexpr Atom Atoms[]
Definition: AccelTable.h:496
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:86
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:66
A structured debug information entry.
Definition: DIE.h:819
unsigned getOffset() const
Get the compile/type unit relative offset of this DIE.
Definition: DIE.h:857
The Data class implementation for DWARF v5 accelerator table.
Definition: AccelTable.h:292
static uint32_t hash(StringRef Name)
Definition: AccelTable.h:294
void print(raw_ostream &OS) const override
Definition: AccelTable.cpp:813
unsigned getDieTag() const
Definition: AccelTable.h:317
std::optional< OffsetAndUnitID > getParentDieOffsetAndUnitID() const
Definition: AccelTable.h:336
std::optional< uint64_t > getParentDieOffset() const
Definition: AccelTable.h:330
std::variant< const DIE *, uint64_t > OffsetVal
Definition: AccelTable.h:354
unsigned getUnitID() const
Definition: AccelTable.h:318
void setAbbrevNumber(uint16_t AbbrevNum)
Sets AbbrevIndex for an Entry.
Definition: AccelTable.h:344
uint64_t order() const override
Definition: AccelTable.h:360
OffsetAndUnitID getDieOffsetAndUnitID() const
Definition: AccelTable.h:313
static std::optional< uint64_t > getDefiningParentDieOffset(const DIE &Die)
If Die has a non-null parent and the parent is not a declaration, return its offset.
Definition: AccelTable.cpp:402
DWARF5AccelTableData(const uint64_t DieOffset, const std::optional< uint64_t > DefiningParentOffset, const unsigned DieTag, const unsigned UnitID, const bool IsTU)
Definition: AccelTable.h:297
uint16_t getAbbrevNumber() const
Returns AbbrevIndex for an Entry.
Definition: AccelTable.h:347
uint64_t getDieOffset() const
Definition: AccelTable.h:308
std::optional< uint64_t > ParentOffset
Definition: AccelTable.h:355
void addTypeUnitSignature(DwarfTypeUnit &U)
Add a type unit Signature.
Definition: AccelTable.cpp:707
void convertDieToOffset()
Convert DIE entries to explicit offset.
Definition: AccelTable.h:417
const TUVectorTy & getTypeUnitsSymbols()
Returns type units that were constructed.
Definition: AccelTable.h:410
void addTypeUnitSymbol(DwarfTypeUnit &U)
Add a type unit start symbol.
Definition: AccelTable.cpp:703
void addTypeEntries(DWARF5AccelTable &Table)
Definition: AccelTable.h:429
void addAttribute(const DebugNamesAbbrev::AttributeEncoding &Attr)
Add attribute encoding to an abbreviation.
Definition: AccelTable.h:373
void setNumber(uint32_t AbbrevNumber)
Set abbreviation tag index.
Definition: AccelTable.h:377
const SmallVector< AttributeEncoding, 1 > & getAttributes() const
Returns attributes for an abbreviation.
Definition: AccelTable.h:385
uint32_t getNumber() const
Get abbreviation tag index.
Definition: AccelTable.h:379
uint32_t getDieTag() const
Get DIE Tag.
Definition: AccelTable.h:381
DebugNamesAbbrev(uint32_t DieTag)
Definition: AccelTable.h:371
DwarfStringPoolEntryRef: Dwarf string pool entry reference.
Node - This class is used to maintain the singly linked bucket list in a folding set.
Definition: FoldingSet.h:138
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
Definition: FoldingSet.h:327
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
size_type size() const
Definition: MapVector.h:60
void clear()
Definition: MapVector.h:88
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
An efficient, type-erasing, non-owning reference to a callable.
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
@ DW_ATOM_type_flags
Definition: Dwarf.h:916
@ DW_ATOM_die_tag
Definition: Dwarf.h:915
@ DW_ATOM_die_offset
Marker as the end of a list of atoms.
Definition: Dwarf.h:912
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
auto map_range(ContainerTy &&C, FuncTy F)
Definition: STLExtras.h:377
void emitAppleAccelTableImpl(AsmPrinter *Asm, AccelTableBase &Contents, StringRef Prefix, const MCSymbol *SecBegin, ArrayRef< AppleAccelTableData::Atom > Atoms)
Definition: AccelTable.cpp:636
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
@ Other
Any other memory.
void emitAppleAccelTable(AsmPrinter *Asm, AccelTable< DataT > &Contents, StringRef Prefix, const MCSymbol *SecBegin)
Emit an Apple Accelerator Table consisting of entries in the specified AccelTable.
Definition: AccelTable.h:448
uint32_t caseFoldingDjbHash(StringRef Buffer, uint32_t H=5381)
Computes the Bernstein hash after folding the input according to the Dwarf 5 standard case folding ru...
Definition: DJB.cpp:72
uint32_t djbHash(StringRef Buffer, uint32_t H=5381)
The Bernstein hash function used by the DWARF accelerator tables.
Definition: DJB.h:21
void emitDWARF5AccelTable(AsmPrinter *Asm, DWARF5AccelTable &Contents, const DwarfDebug &DD, ArrayRef< std::unique_ptr< DwarfCompileUnit > > CUs)
Definition: AccelTable.cpp:643
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
Definition: Hashing.h:593
Represents a group of entries with identical name (and hence, hash value).
Definition: AccelTable.h:140
void print(raw_ostream &OS) const
Definition: AccelTable.cpp:781
auto getValues() const
Get all AccelTableData cast as a T.
Definition: AccelTable.h:147
DwarfStringPoolEntryRef Name
Definition: AccelTable.h:141
std::vector< AccelTableData * > Values
Definition: AccelTable.h:143
An Atom defines the form of the data in an Apple accelerator table.
Definition: AccelTable.h:237
const uint16_t Form
DWARF Form.
Definition: AccelTable.h:241
void print(raw_ostream &OS) const
Definition: AccelTable.cpp:763
const uint16_t Type
Atom Type.
Definition: AccelTable.h:239
constexpr Atom(uint16_t Type, uint16_t Form)
Definition: AccelTable.h:243
DebugNamesAbbrev::AttributeEncoding Encoding
Definition: AccelTable.h:407
static bool isEqual(const OffsetAndUnitID &LHS, const OffsetAndUnitID &RHS)
Definition: AccelTable.h:282
static OffsetAndUnitID getEmptyKey()
Definition: AccelTable.h:273
static unsigned getHashValue(const OffsetAndUnitID &Val)
Definition: AccelTable.h:279
static OffsetAndUnitID getTombstoneKey()
Definition: AccelTable.h:276
An information struct used to provide DenseMap with the various necessary components for a given valu...
Definition: DenseMapInfo.h:52
Helper class to identify an entry in DWARF5AccelTable based on their DIE offset and UnitID.
Definition: AccelTable.h:260
bool isTU() const
Definition: AccelTable.h:269
uint32_t unitID() const
Definition: AccelTable.h:268
uint64_t offset() const
Definition: AccelTable.h:267
OffsetAndUnitID(uint64_t Offset, uint32_t UnitID, bool IsTU)
Definition: AccelTable.h:265
std::variant< MCSymbol *, uint64_t > LabelOrSignature
Definition: AccelTable.h:395