52 E.second.Values.erase(
53 std::unique(E.second.Values.begin(), E.second.Values.end()),
54 E.second.Values.end());
67 Buckets[Bucket].push_back(&E.second);
68 E.second.Sym = Asm->createTempSymbol(Prefix);
75 return LHS->HashValue <
RHS->HashValue;
82class AccelTableWriter {
90 const bool SkipIdenticalHashes;
92 void emitHashes()
const;
100 bool SkipIdenticalHashes)
101 : Asm(Asm), Contents(Contents), SkipIdenticalHashes(SkipIdenticalHashes) {
105class AppleAccelTableWriter :
public AccelTableWriter {
118 static const uint32_t MagicHash = 0x48415348;
121 : BucketCount(BucketCount), HashCount(UniqueHashCount),
122 HeaderDataLength(DataLength) {}
141 : DieOffsetBase(
Offset), Atoms(AtomList.
begin(), AtomList.
end()) {}
151 HeaderData HeaderData;
154 void emitBuckets()
const;
155 void emitData()
const;
160 : AccelTableWriter(
Asm, Contents,
true),
161 Header(Contents.getBucketCount(), Contents.getUniqueHashCount(),
162 8 + (Atoms.
size() * 4)),
163 HeaderData(Atoms), SecBegin(SecBegin) {}
177class Dwarf5AccelTableWriter :
public AccelTableWriter {
187 uint32_t AugmentationStringSize =
sizeof(AugmentationString);
188 char AugmentationString[8] = {
'L',
'L',
'V',
'M',
'0',
'7',
'0',
'0'};
193 : CompUnitCount(CompUnitCount), LocalTypeUnitCount(LocalTypeUnitCount),
194 ForeignTypeUnitCount(ForeignTypeUnitCount), BucketCount(BucketCount),
195 NameCount(NameCount) {}
197 void emit(Dwarf5AccelTableWriter &Ctx);
213 MCSymbol *ContributionEnd =
nullptr;
214 MCSymbol *AbbrevStart =
Asm->createTempSymbol(
"names_abbrev_start");
215 MCSymbol *AbbrevEnd =
Asm->createTempSymbol(
"names_abbrev_end");
216 MCSymbol *EntryPool =
Asm->createTempSymbol(
"names_entries");
218 bool IsSplitDwarf =
false;
222 void populateAbbrevsMap();
224 void emitCUList()
const;
225 void emitTUList()
const;
226 void emitBuckets()
const;
227 void emitStringOffsets()
const;
228 void emitAbbrevs()
const;
236 Dwarf5AccelTableWriter(
238 ArrayRef<std::variant<MCSymbol *, uint64_t>> CompUnits,
239 ArrayRef<std::variant<MCSymbol *, uint64_t>> TypeUnits,
244 ~Dwarf5AccelTableWriter() {
246 Abbrev->~DebugNamesAbbrev();
252void AccelTableWriter::emitHashes()
const {
253 uint64_t PrevHash = std::numeric_limits<uint64_t>::max();
254 unsigned BucketIdx = 0;
255 for (
const auto &Bucket : Contents.
getBuckets()) {
256 for (
const auto &Hash : Bucket) {
257 uint32_t HashValue = Hash->HashValue;
258 if (SkipIdenticalHashes && PrevHash == HashValue)
260 Asm->OutStreamer->AddComment(
"Hash in Bucket " +
Twine(BucketIdx));
261 Asm->emitInt32(HashValue);
262 PrevHash = HashValue;
268void AccelTableWriter::emitOffsets(
const MCSymbol *
Base)
const {
270 uint64_t PrevHash = std::numeric_limits<uint64_t>::max();
271 for (
size_t i = 0, e = Buckets.size(); i < e; ++i) {
272 for (
auto *Hash : Buckets[i]) {
273 uint32_t HashValue = Hash->HashValue;
274 if (SkipIdenticalHashes && PrevHash == HashValue)
276 PrevHash = HashValue;
277 Asm->OutStreamer->AddComment(
"Offset in Bucket " +
Twine(i));
278 Asm->emitLabelDifference(Hash->Sym,
Base,
Asm->getDwarfOffsetByteSize());
283void AppleAccelTableWriter::Header::emit(
AsmPrinter *Asm)
const {
284 Asm->OutStreamer->AddComment(
"Header Magic");
285 Asm->emitInt32(Magic);
286 Asm->OutStreamer->AddComment(
"Header Version");
287 Asm->emitInt16(Version);
288 Asm->OutStreamer->AddComment(
"Header Hash Function");
289 Asm->emitInt16(HashFunction);
290 Asm->OutStreamer->AddComment(
"Header Bucket Count");
291 Asm->emitInt32(BucketCount);
292 Asm->OutStreamer->AddComment(
"Header Hash Count");
293 Asm->emitInt32(HashCount);
294 Asm->OutStreamer->AddComment(
"Header Data Length");
295 Asm->emitInt32(HeaderDataLength);
298void AppleAccelTableWriter::HeaderData::emit(
AsmPrinter *Asm)
const {
299 Asm->OutStreamer->AddComment(
"HeaderData Die Offset Base");
300 Asm->emitInt32(DieOffsetBase);
301 Asm->OutStreamer->AddComment(
"HeaderData Atom Count");
304 for (
const Atom &
A : Atoms) {
306 Asm->emitInt16(
A.Type);
308 Asm->emitInt16(
A.Form);
312void AppleAccelTableWriter::emitBuckets()
const {
315 for (
size_t i = 0, e = Buckets.size(); i < e; ++i) {
316 Asm->OutStreamer->AddComment(
"Bucket " +
Twine(i));
317 if (!Buckets[i].empty())
318 Asm->emitInt32(index);
320 Asm->emitInt32(std::numeric_limits<uint32_t>::max());
323 uint64_t PrevHash = std::numeric_limits<uint64_t>::max();
324 for (
auto *HD : Buckets[i]) {
326 if (PrevHash != HashValue)
328 PrevHash = HashValue;
333void AppleAccelTableWriter::emitData()
const {
336 uint64_t PrevHash = std::numeric_limits<uint64_t>::max();
337 for (
const auto &Hash : Bucket) {
340 if (PrevHash != std::numeric_limits<uint64_t>::max() &&
341 PrevHash != Hash->HashValue)
344 Asm->OutStreamer->emitLabel(Hash->Sym);
345 Asm->OutStreamer->AddComment(Hash->Name.getString());
346 Asm->emitDwarfStringOffset(Hash->Name);
347 Asm->OutStreamer->AddComment(
"Num DIEs");
348 Asm->emitInt32(Hash->Values.size());
351 PrevHash = Hash->HashValue;
359void AppleAccelTableWriter::emit()
const {
361 HeaderData.emit(Asm);
364 emitOffsets(SecBegin);
371 : OffsetVal(&Die), DieTag(Die.
getTag()), AbbrevNumber(0), IsTU(IsTU),
374void Dwarf5AccelTableWriter::Header::emit(Dwarf5AccelTableWriter &Ctx) {
375 assert(CompUnitCount > 0 &&
"Index must have at least one CU.");
378 Ctx.ContributionEnd =
379 Asm->emitDwarfUnitLength(
"names",
"Header: unit length");
380 Asm->OutStreamer->AddComment(
"Header: version");
381 Asm->emitInt16(Version);
382 Asm->OutStreamer->AddComment(
"Header: padding");
383 Asm->emitInt16(Padding);
384 Asm->OutStreamer->AddComment(
"Header: compilation unit count");
385 Asm->emitInt32(CompUnitCount);
386 Asm->OutStreamer->AddComment(
"Header: local type unit count");
387 Asm->emitInt32(LocalTypeUnitCount);
388 Asm->OutStreamer->AddComment(
"Header: foreign type unit count");
389 Asm->emitInt32(ForeignTypeUnitCount);
390 Asm->OutStreamer->AddComment(
"Header: bucket count");
391 Asm->emitInt32(BucketCount);
392 Asm->OutStreamer->AddComment(
"Header: name count");
393 Asm->emitInt32(NameCount);
394 Asm->OutStreamer->AddComment(
"Header: abbreviation table size");
395 Asm->emitLabelDifference(Ctx.AbbrevEnd, Ctx.AbbrevStart,
sizeof(
uint32_t));
396 Asm->OutStreamer->AddComment(
"Header: augmentation string size");
397 assert(AugmentationStringSize % 4 == 0);
398 Asm->emitInt32(AugmentationStringSize);
399 Asm->OutStreamer->AddComment(
"Header: augmentation string");
400 Asm->OutStreamer->emitBytes({AugmentationString, AugmentationStringSize});
403std::optional<uint64_t>
406 Parent && !Parent->
findAttribute(dwarf::Attribute::DW_AT_declaration))
407 return Parent->getOffset();
411static std::optional<dwarf::Form>
413 std::optional<OffsetAndUnitID> ParentOffset) {
418 if (IndexedOffsets.
contains(*ParentOffset))
419 return dwarf::Form::DW_FORM_ref4;
421 return dwarf::Form::DW_FORM_flag_present;
427 ID.AddInteger(Enc.Index);
428 ID.AddInteger(Enc.Form);
432void Dwarf5AccelTableWriter::populateAbbrevsMap() {
434 for (
auto *Hash : Bucket) {
436 std::optional<DWARF5AccelTable::UnitIndexAndEncoding> EntryRet =
437 getIndexForEntry(*
Value);
439 IndexedOffsets,
Value->getParentDieOffsetAndUnitID());
442 Abbrev.addAttribute(EntryRet->Encoding);
443 Abbrev.addAttribute({dwarf::DW_IDX_die_offset, dwarf::DW_FORM_ref4});
445 Abbrev.addAttribute({dwarf::DW_IDX_parent, *MaybeParentForm});
451 Value->setAbbrevNumber(Existing->getNumber());
456 AbbreviationsVector.
push_back(NewAbbrev);
458 AbbreviationsSet.
InsertNode(NewAbbrev, InsertPos);
465void Dwarf5AccelTableWriter::emitCUList()
const {
467 Asm->OutStreamer->AddComment(
"Compilation unit " +
Twine(
CU.index()));
468 if (std::holds_alternative<MCSymbol *>(
CU.value()))
469 Asm->emitDwarfSymbolReference(std::get<MCSymbol *>(
CU.value()));
471 Asm->emitDwarfLengthOrOffset(std::get<uint64_t>(
CU.value()));
475void Dwarf5AccelTableWriter::emitTUList()
const {
476 for (
const auto &TU :
enumerate(TypeUnits)) {
477 Asm->OutStreamer->AddComment(
"Type unit " +
Twine(TU.index()));
478 if (std::holds_alternative<MCSymbol *>(TU.value()))
479 Asm->emitDwarfSymbolReference(std::get<MCSymbol *>(TU.value()));
480 else if (IsSplitDwarf)
481 Asm->emitInt64(std::get<uint64_t>(TU.value()));
483 Asm->emitDwarfLengthOrOffset(std::get<uint64_t>(TU.value()));
487void Dwarf5AccelTableWriter::emitBuckets()
const {
490 Asm->OutStreamer->AddComment(
"Bucket " +
Twine(Bucket.index()));
491 Asm->emitInt32(Bucket.value().empty() ? 0 :
Index);
492 Index += Bucket.value().size();
496void Dwarf5AccelTableWriter::emitStringOffsets()
const {
498 for (
auto *Hash : Bucket.value()) {
500 Asm->OutStreamer->AddComment(
"String in Bucket " +
Twine(Bucket.index()) +
501 ": " +
String.getString());
507void Dwarf5AccelTableWriter::emitAbbrevs()
const {
508 Asm->OutStreamer->emitLabel(AbbrevStart);
510 Asm->OutStreamer->AddComment(
"Abbrev code");
511 Asm->emitULEB128(Abbrev->getNumber());
513 Asm->emitULEB128(Abbrev->getDieTag());
515 Abbrev->getAttributes()) {
517 Asm->emitULEB128(AttrEnc.Form,
520 Asm->emitULEB128(0,
"End of abbrev");
521 Asm->emitULEB128(0,
"End of abbrev");
523 Asm->emitULEB128(0,
"End of abbrev list");
524 Asm->OutStreamer->emitLabel(AbbrevEnd);
527void Dwarf5AccelTableWriter::emitEntry(
531 unsigned AbbrevIndex = Entry.getAbbrevNumber() - 1;
532 assert(AbbrevIndex < AbbreviationsVector.size() &&
533 "Entry abbrev index is outside of abbreviations vector range.");
535 std::optional<DWARF5AccelTable::UnitIndexAndEncoding> EntryRet =
536 getIndexForEntry(Entry);
537 std::optional<OffsetAndUnitID> MaybeParentOffset =
538 Entry.getParentDieOffsetAndUnitID();
540 DIEOffsetToAccelEntryLabel.
find(Entry.getDieOffsetAndUnitID());
541 assert(EntrySymbolIt != DIEOffsetToAccelEntryLabel.
end());
542 MCSymbol *EntrySymbol = EntrySymbolIt->getSecond();
547 if (EmittedAccelEntrySymbols.
insert(EntrySymbol).second)
548 Asm->OutStreamer->emitLabel(EntrySymbol);
550 Asm->emitULEB128(Entry.getAbbrevNumber(),
"Abbreviation code");
555 switch (AttrEnc.Index) {
556 case dwarf::DW_IDX_compile_unit:
557 case dwarf::DW_IDX_type_unit: {
559 ID.emitValue(Asm, AttrEnc.Form);
562 case dwarf::DW_IDX_die_offset:
563 assert(AttrEnc.Form == dwarf::DW_FORM_ref4);
564 Asm->emitInt32(Entry.getDieOffset());
566 case dwarf::DW_IDX_parent: {
567 if (AttrEnc.Form == dwarf::Form::DW_FORM_flag_present)
569 auto ParentSymbolIt = DIEOffsetToAccelEntryLabel.
find(*MaybeParentOffset);
570 assert(ParentSymbolIt != DIEOffsetToAccelEntryLabel.
end());
571 Asm->emitLabelDifference(ParentSymbolIt->getSecond(), EntryPool, 4);
580void Dwarf5AccelTableWriter::emitData() {
584 DIEOffsetToAccelEntryLabel.
insert({
Offset,
Asm->createTempSymbol(
"")});
586 Asm->OutStreamer->emitLabel(EntryPool);
589 for (
auto *Hash : Bucket) {
591 Asm->OutStreamer->emitLabel(Hash->Sym);
593 emitEntry(*
Value, DIEOffsetToAccelEntryLabel, EmittedAccelEntrySymbols);
594 Asm->OutStreamer->AddComment(
"End of list: " + Hash->Name.getString());
600Dwarf5AccelTableWriter::Dwarf5AccelTableWriter(
602 ArrayRef<std::variant<MCSymbol *, uint64_t>> CompUnits,
603 ArrayRef<std::variant<MCSymbol *, uint64_t>> TypeUnits,
608 : AccelTableWriter(
Asm, Contents,
false),
609 Header(CompUnits.
size(), IsSplitDwarf ? 0 : TypeUnits.
size(),
610 IsSplitDwarf ? TypeUnits.
size() : 0, Contents.getBucketCount(),
611 Contents.getUniqueNameCount()),
612 CompUnits(CompUnits), TypeUnits(TypeUnits),
613 getIndexForEntry(
std::
move(getIndexForEntry)),
614 IsSplitDwarf(IsSplitDwarf) {
617 for (
auto *Hash : Bucket)
619 IndexedOffsets.insert(
Value->getDieOffsetAndUnitID());
621 populateAbbrevsMap();
624void Dwarf5AccelTableWriter::emit() {
631 emitOffsets(EntryPool);
634 Asm->OutStreamer->emitValueToAlignment(
Align(4), 0);
635 Asm->OutStreamer->emitLabel(ContributionEnd);
642 AppleAccelTableWriter(Asm, Contents, Atoms, SecBegin).emit();
647 ArrayRef<std::unique_ptr<DwarfCompileUnit>> CUs) {
649 std::vector<std::variant<MCSymbol *, uint64_t>> CompUnits;
650 std::vector<std::variant<MCSymbol *, uint64_t>> TypeUnits;
656 switch (
CU.value()->getCUNode()->getNameTableKind()) {
663 CUIndex[
CU.index()] = CUCount++;
664 assert(
CU.index() ==
CU.value()->getUniqueID());
670 for (
const auto &TU : TUSymbols) {
671 TUIndex[TU.UniqueID] = TUCount++;
673 TypeUnits.push_back(std::get<uint64_t>(TU.LabelOrSignature));
675 TypeUnits.push_back(std::get<MCSymbol *>(TU.LabelOrSignature));
678 if (CompUnits.empty())
681 Asm->OutStreamer->switchSection(
682 Asm->getObjFileLowering().getDwarfDebugNamesSection());
689 Dwarf5AccelTableWriter(
690 Asm, Contents, CompUnits, TypeUnits,
692 -> std::optional<DWARF5AccelTable::UnitIndexAndEncoding> {
694 return {{TUIndex[Entry.getUnitID()],
695 {dwarf::DW_IDX_type_unit, TUIndexForm}}};
696 if (CUIndex.
size() > 1)
697 return {{CUIndex[Entry.getUnitID()],
698 {dwarf::DW_IDX_compile_unit, CUIndexForm}}};
706 TUSymbolsOrHashes.
push_back({U.getLabelBegin(), U.getUniqueID()});
710 TUSymbolsOrHashes.
push_back({U.getTypeSignature(), U.getUniqueID()});
715 ArrayRef<std::variant<MCSymbol *, uint64_t>> CUs,
719 std::vector<std::variant<MCSymbol *, uint64_t>> TypeUnits;
721 Dwarf5AccelTableWriter(Asm, Contents, CUs, TypeUnits, getIndexForEntry,
false)
727 "The section offset exceeds the limit.");
733 "The section offset exceeds the limit.");
757void AppleAccelTableWriter::Header::print(
raw_ostream &
OS)
const {
758 OS <<
"Magic: " <<
format(
"0x%x", Magic) <<
"\n"
759 <<
"Version: " << Version <<
"\n"
760 <<
"Hash Function: " << HashFunction <<
"\n"
761 <<
"Bucket Count: " << BucketCount <<
"\n"
762 <<
"Header Data Length: " << HeaderDataLength <<
"\n";
770void AppleAccelTableWriter::HeaderData::print(
raw_ostream &
OS)
const {
771 OS <<
"DIE Offset Base: " << DieOffsetBase <<
"\n";
772 for (
auto Atom : Atoms)
778 HeaderData.print(
OS);
784 OS <<
"Name: " <<
Name.getString() <<
"\n";
785 OS <<
" Hash Value: " <<
format(
"0x%x", HashValue) <<
"\n";
792 for (
auto *
Value : Values)
799 for (
const auto &[
Name,
Data] : Entries) {
800 OS <<
"Name: " <<
Name <<
"\n";
801 for (
auto *V :
Data.Values)
805 OS <<
"Buckets and Hashes: \n";
806 for (
const auto &Bucket : Buckets)
807 for (
const auto &Hash : Bucket)
811 for (
const auto &E : Entries)
816 OS <<
" Offset: " << getDieOffset() <<
"\n";
821 OS <<
" Offset: " << Die.getOffset() <<
"\n";
825 OS <<
" Offset: " << Die.getOffset() <<
"\n";
830 OS <<
" Static Offset: " <<
Offset <<
"\n";
834 OS <<
" Static Offset: " <<
Offset <<
"\n";
835 OS <<
" QualifiedNameHash: " <<
format(
"%x\n", QualifiedNameHash) <<
"\n";
837 OS <<
" ObjCClassIsImplementation: "
838 << (ObjCClassIsImplementation ?
"true" :
"false");
static std::optional< dwarf::Form > getFormForIdxParent(const DenseSet< OffsetAndUnitID > &IndexedOffsets, std::optional< OffsetAndUnitID > ParentOffset)
This file contains support for writing accelerator tables.
static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
This file defines the DenseSet and SmallDenseSet classes.
This file contains constants used for implementing Dwarf debug support.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
A base class holding non-template-dependant functionality of the AccelTable class.
std::vector< HashData * > HashList
void computeBucketCount()
void finalize(AsmPrinter *Asm, StringRef Prefix)
void print(raw_ostream &OS) const
ArrayRef< HashList > getBuckets() const
Interface which the different types of accelerator table data have to conform.
A base class for different implementations of Data classes for Apple Accelerator Tables.
void emit(AsmPrinter *Asm) const override
void print(raw_ostream &OS) const override
static constexpr Atom Atoms[]
static constexpr Atom Atoms[]
void emit(AsmPrinter *Asm) const override
void print(raw_ostream &OS) const override
uint32_t QualifiedNameHash
void emit(AsmPrinter *Asm) const override
void print(raw_ostream &OS) const override
bool ObjCClassIsImplementation
static constexpr Atom Atoms[]
void print(raw_ostream &OS) const override
void emit(AsmPrinter *Asm) const override
static constexpr Atom Atoms[]
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
This class is intended to be used as a driving class for all asm writers.
Allocate memory in an ever growing pool, as if by bump-pointer.
static dwarf::Form BestForm(bool IsSigned, uint64_t Int)
Choose the best form for integer.
A structured debug information entry.
DIEValue findAttribute(dwarf::Attribute Attribute) const
Find a value in the DIE with the attribute given.
uint64_t getDebugSectionOffset() const
Get the absolute offset within the .debug_info or .debug_types section for this DIE.
dwarf::Tag getTag() const
The Data class implementation for DWARF v5 accelerator table.
void print(raw_ostream &OS) const override
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.
DWARF5AccelTableData(const DIE &Die, const uint32_t UnitID, const bool IsTU=false)
void addTypeUnitSignature(DwarfTypeUnit &U)
Add a type unit Signature.
const TUVectorTy & getTypeUnitsSymbols()
Returns type units that were constructed.
void addTypeUnitSymbol(DwarfTypeUnit &U)
Add a type unit start symbol.
void setNumber(uint32_t AbbrevNumber)
Set abbreviation tag index.
const SmallVector< AttributeEncoding, 1 > & getAttributes() const
Returns attributes for an abbreviation.
void Profile(FoldingSetNodeID &ID) const
Used to gather unique data for the abbreviation folding set.
uint32_t getNumber() const
Get abbreviation tag index.
iterator find(const_arg_type_t< KeyT > Val)
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Implements a dense probed hash-table based set.
Collects and handles dwarf debug information.
bool useSplitDwarf() const
Returns whether or not to change the current debug info for the split dwarf proposal support.
DwarfStringPoolEntryRef: Dwarf string pool entry reference.
MCSymbol * getLabelBegin() const
Get the the symbol for start of the section for this unit.
void InsertNode(T *N, void *InsertPos)
InsertNode - Insert the specified node into the folding set, knowing that it is not already in the fo...
T * FindNodeOrInsertPos(const FoldingSetNodeID &ID, void *&InsertPos)
FindNodeOrInsertPos - Look up the node specified by ID.
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
FoldingSet - This template class is used to instantiate a specialized implementation of the folding s...
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
void print(raw_ostream &OS, const MCAsmInfo *MAI) const
print - Print the value to the stream OS.
void reserve(size_type N)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
constexpr const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
The instances of the Type class are immutable: once they are created, they are never changed.
LLVM Value Representation.
void print(raw_ostream &O, bool IsForDebug=false) const
Implement operator<< on Value.
std::pair< iterator, bool > insert(const ValueT &V)
bool contains(const_arg_type_t< ValueT > V) const
Check if the set contains the given element.
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.
StringRef FormEncodingString(unsigned Encoding)
StringRef IndexString(unsigned Idx)
StringRef AtomTypeString(unsigned Atom)
StringRef TagString(unsigned Tag)
unsigned getTag(StringRef TagString)
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
uint32_t getDebugNamesBucketCount(uint32_t UniqueHashCount)
@ DW_FLAG_type_implementation
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
const_iterator end(StringRef path)
Get end iterator over path.
This is an optimization pass for GlobalISel generic memory operations.
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
void stable_sort(R &&Range)
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
auto enumerate(FirstRange &&First, RestRanges &&...Rest)
Given two or more input ranges, returns a new range whose values are are tuples (A,...
auto unique(Range &&R, Predicate P)
void emitAppleAccelTableImpl(AsmPrinter *Asm, AccelTableBase &Contents, StringRef Prefix, const MCSymbol *SecBegin, ArrayRef< AppleAccelTableData::Atom > Atoms)
void sort(IteratorTy Start, IteratorTy End)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
void emitDWARF5AccelTable(AsmPrinter *Asm, DWARF5AccelTable &Contents, const DwarfDebug &DD, ArrayRef< std::unique_ptr< DwarfCompileUnit > > CUs)
Implement std::hash so that hash_code can be used in STL containers.
Represents a group of entries with identical name (and hence, hash value).
void print(raw_ostream &OS) const
This struct is a compact representation of a valid (non-zero power of two) alignment.
An Atom defines the form of the data in an Apple accelerator table.
void print(raw_ostream &OS) const
Helper class to identify an entry in DWARF5AccelTable based on their DIE offset and UnitID.