LLVM 18.0.0git
DWARFAcceleratorTable.cpp
Go to the documentation of this file.
1//===- DWARFAcceleratorTable.cpp ------------------------------------------===//
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
10
14#include "llvm/Support/DJB.h"
15#include "llvm/Support/Errc.h"
16#include "llvm/Support/Format.h"
20#include <cstddef>
21#include <cstdint>
22#include <utility>
23
24using namespace llvm;
25
26namespace {
27struct Atom {
28 unsigned Value;
29};
30
31static raw_ostream &operator<<(raw_ostream &OS, const Atom &A) {
33 if (!Str.empty())
34 return OS << Str;
35 return OS << "DW_ATOM_unknown_" << format("%x", A.Value);
36}
37} // namespace
38
39static Atom formatAtom(unsigned Atom) { return {Atom}; }
40
42
44 uint64_t Offset = 0;
45
46 // Check that we can at least read the header.
47 if (!AccelSection.isValidOffset(offsetof(Header, HeaderDataLength) + 4))
49 "Section too small: cannot read header.");
50
51 Hdr.Magic = AccelSection.getU32(&Offset);
52 Hdr.Version = AccelSection.getU16(&Offset);
53 Hdr.HashFunction = AccelSection.getU16(&Offset);
54 Hdr.BucketCount = AccelSection.getU32(&Offset);
55 Hdr.HashCount = AccelSection.getU32(&Offset);
56 Hdr.HeaderDataLength = AccelSection.getU32(&Offset);
57 FormParams = {Hdr.Version, 0, dwarf::DwarfFormat::DWARF32};
58
59 // Check that we can read all the hashes and offsets from the
60 // section (see SourceLevelDebugging.rst for the structure of the index).
61 if (!AccelSection.isValidOffset(getIthBucketBase(Hdr.BucketCount - 1)))
62 return createStringError(
64 "Section too small: cannot read buckets and hashes.");
65
66 HdrData.DIEOffsetBase = AccelSection.getU32(&Offset);
68
69 HashDataEntryLength = 0;
70 auto MakeUnsupportedFormError = [](dwarf::Form Form) {
72 "Unsupported form:" +
74 };
75
76 for (unsigned i = 0; i < NumAtoms; ++i) {
78 auto AtomForm = static_cast<dwarf::Form>(AccelSection.getU16(&Offset));
79 HdrData.Atoms.push_back(std::make_pair(AtomType, AtomForm));
80
81 std::optional<uint8_t> FormSize =
83 if (!FormSize)
84 return MakeUnsupportedFormError(AtomForm);
85 HashDataEntryLength += *FormSize;
86 }
87
88 IsValid = true;
89 return Error::success();
90}
91
93 return Hdr.BucketCount;
94}
95uint32_t AppleAcceleratorTable::getNumHashes() const { return Hdr.HashCount; }
96uint32_t AppleAcceleratorTable::getSizeHdr() const { return sizeof(Hdr); }
98 return Hdr.HeaderDataLength;
99}
100
104 return HdrData.Atoms;
105}
106
108 for (auto Atom : getAtomsDesc()) {
109 DWARFFormValue FormValue(Atom.second);
110 switch (Atom.first) {
114 if ((!FormValue.isFormClass(DWARFFormValue::FC_Constant) &&
116 FormValue.getForm() == dwarf::DW_FORM_sdata)
117 return false;
118 break;
119 default:
120 break;
121 }
122 }
123 return true;
124}
125
126std::pair<uint64_t, dwarf::Tag>
129 dwarf::Tag DieTag = dwarf::DW_TAG_null;
130
131 for (auto Atom : getAtomsDesc()) {
132 DWARFFormValue FormValue(Atom.second);
133 FormValue.extractValue(AccelSection, HashDataOffset, FormParams);
134 switch (Atom.first) {
136 DieOffset = *FormValue.getAsUnsignedConstant();
137 break;
139 DieTag = (dwarf::Tag)*FormValue.getAsUnsignedConstant();
140 break;
141 default:
142 break;
143 }
144 }
145 return {DieOffset, DieTag};
146}
147
148void AppleAcceleratorTable::Header::dump(ScopedPrinter &W) const {
149 DictScope HeaderScope(W, "Header");
150 W.printHex("Magic", Magic);
151 W.printHex("Version", Version);
152 W.printHex("Hash function", HashFunction);
153 W.printNumber("Bucket count", BucketCount);
154 W.printNumber("Hashes count", HashCount);
155 W.printNumber("HeaderData length", HeaderDataLength);
156}
157
158std::optional<uint64_t> AppleAcceleratorTable::HeaderData::extractOffset(
159 std::optional<DWARFFormValue> Value) const {
160 if (!Value)
161 return std::nullopt;
162
163 switch (Value->getForm()) {
164 case dwarf::DW_FORM_ref1:
165 case dwarf::DW_FORM_ref2:
166 case dwarf::DW_FORM_ref4:
167 case dwarf::DW_FORM_ref8:
168 case dwarf::DW_FORM_ref_udata:
169 return Value->getRawUValue() + DIEOffsetBase;
170 default:
171 return Value->getAsSectionOffset();
172 }
173}
174
175bool AppleAcceleratorTable::dumpName(ScopedPrinter &W,
177 uint64_t *DataOffset) const {
178 uint64_t NameOffset = *DataOffset;
179 if (!AccelSection.isValidOffsetForDataOfSize(*DataOffset, 4)) {
180 W.printString("Incorrectly terminated list.");
181 return false;
182 }
183 uint64_t StringOffset = AccelSection.getRelocatedValue(4, DataOffset);
184 if (!StringOffset)
185 return false; // End of list
186
187 DictScope NameScope(W, ("Name@0x" + Twine::utohexstr(NameOffset)).str());
188 W.startLine() << format("String: 0x%08" PRIx64, StringOffset);
189 W.getOStream() << " \"" << StringSection.getCStr(&StringOffset) << "\"\n";
190
191 unsigned NumData = AccelSection.getU32(DataOffset);
192 for (unsigned Data = 0; Data < NumData; ++Data) {
193 ListScope DataScope(W, ("Data " + Twine(Data)).str());
194 unsigned i = 0;
195 for (auto &Atom : AtomForms) {
196 W.startLine() << format("Atom[%d]: ", i);
197 if (Atom.extractValue(AccelSection, DataOffset, FormParams)) {
198 Atom.dump(W.getOStream());
199 if (std::optional<uint64_t> Val = Atom.getAsUnsignedConstant()) {
200 StringRef Str = dwarf::AtomValueString(HdrData.Atoms[i].first, *Val);
201 if (!Str.empty())
202 W.getOStream() << " (" << Str << ")";
203 }
204 } else
205 W.getOStream() << "Error extracting the value";
206 W.getOStream() << "\n";
207 i++;
208 }
209 }
210 return true; // more entries follow
211}
212
214 if (!IsValid)
215 return;
216
217 ScopedPrinter W(OS);
218
219 Hdr.dump(W);
220
221 W.printNumber("DIE offset base", HdrData.DIEOffsetBase);
222 W.printNumber("Number of atoms", uint64_t(HdrData.Atoms.size()));
223 W.printNumber("Size of each hash data entry", getHashDataEntryLength());
225 {
226 ListScope AtomsScope(W, "Atoms");
227 unsigned i = 0;
228 for (const auto &Atom : HdrData.Atoms) {
229 DictScope AtomScope(W, ("Atom " + Twine(i++)).str());
230 W.startLine() << "Type: " << formatAtom(Atom.first) << '\n';
231 W.startLine() << "Form: " << formatv("{0}", Atom.second) << '\n';
232 AtomForms.push_back(DWARFFormValue(Atom.second));
233 }
234 }
235
236 // Now go through the actual tables and dump them.
237 uint64_t Offset = sizeof(Hdr) + Hdr.HeaderDataLength;
238 uint64_t HashesBase = Offset + Hdr.BucketCount * 4;
239 uint64_t OffsetsBase = HashesBase + Hdr.HashCount * 4;
240
241 for (unsigned Bucket = 0; Bucket < Hdr.BucketCount; ++Bucket) {
242 unsigned Index = AccelSection.getU32(&Offset);
243
244 ListScope BucketScope(W, ("Bucket " + Twine(Bucket)).str());
245 if (Index == UINT32_MAX) {
246 W.printString("EMPTY");
247 continue;
248 }
249
250 for (unsigned HashIdx = Index; HashIdx < Hdr.HashCount; ++HashIdx) {
251 uint64_t HashOffset = HashesBase + HashIdx*4;
252 uint64_t OffsetsOffset = OffsetsBase + HashIdx*4;
253 uint32_t Hash = AccelSection.getU32(&HashOffset);
254
255 if (Hash % Hdr.BucketCount != Bucket)
256 break;
257
258 uint64_t DataOffset = AccelSection.getU32(&OffsetsOffset);
259 ListScope HashScope(W, ("Hash 0x" + Twine::utohexstr(Hash)).str());
260 if (!AccelSection.isValidOffset(DataOffset)) {
261 W.printString("Invalid section offset");
262 continue;
263 }
264 while (dumpName(W, AtomForms, &DataOffset))
265 /*empty*/;
266 }
267 }
268}
269
271 : Table(Table) {
272 Values.reserve(Table.HdrData.Atoms.size());
273 for (const auto &Atom : Table.HdrData.Atoms)
274 Values.push_back(DWARFFormValue(Atom.second));
275}
276
277void AppleAcceleratorTable::Entry::extract(uint64_t *Offset) {
278 for (auto &FormValue : Values)
279 FormValue.extractValue(Table.AccelSection, Offset, Table.FormParams);
280}
281
282std::optional<DWARFFormValue>
284 for (auto [Atom, FormValue] : zip_equal(Table.HdrData.Atoms, Values))
285 if (Atom.first == AtomToFind)
286 return FormValue;
287 return std::nullopt;
288}
289
290std::optional<uint64_t>
292 return Table.HdrData.extractOffset(lookup(dwarf::DW_ATOM_die_offset));
293}
294
295std::optional<uint64_t> AppleAcceleratorTable::Entry::getCUOffset() const {
296 return Table.HdrData.extractOffset(lookup(dwarf::DW_ATOM_cu_offset));
297}
298
299std::optional<dwarf::Tag> AppleAcceleratorTable::Entry::getTag() const {
300 std::optional<DWARFFormValue> Tag = lookup(dwarf::DW_ATOM_die_tag);
301 if (!Tag)
302 return std::nullopt;
303 if (std::optional<uint64_t> Value = Tag->getAsUnsignedConstant())
304 return dwarf::Tag(*Value);
305 return std::nullopt;
306}
307
309 const AppleAcceleratorTable &AccelTable, uint64_t DataOffset)
310 : Current(AccelTable), Offset(DataOffset) {}
311
312void AppleAcceleratorTable::Iterator::prepareNextEntryOrEnd() {
313 if (NumEntriesToCome == 0)
314 prepareNextStringOrEnd();
315 if (isEnd())
316 return;
317 uint64_t OffsetCopy = Offset;
318 Current.BaseEntry.extract(&OffsetCopy);
319 NumEntriesToCome--;
320 Offset += getTable().getHashDataEntryLength();
321}
322
323void AppleAcceleratorTable::Iterator::prepareNextStringOrEnd() {
324 std::optional<uint32_t> StrOffset = getTable().readStringOffsetAt(Offset);
325 if (!StrOffset)
326 return setToEnd();
327
328 // A zero denotes the end of the collision list. Read the next string
329 // again.
330 if (*StrOffset == 0)
331 return prepareNextStringOrEnd();
332 Current.StrOffset = *StrOffset;
333
334 std::optional<uint32_t> MaybeNumEntries = getTable().readU32FromAccel(Offset);
335 if (!MaybeNumEntries || *MaybeNumEntries == 0)
336 return setToEnd();
337 NumEntriesToCome = *MaybeNumEntries;
338}
339
341 bool SetEnd)
342 : Current(Table), Offset(Table.getEntriesBase()), NumEntriesToCome(0) {
343 if (SetEnd)
344 setToEnd();
345 else
346 prepareNextEntryOrEnd();
347}
348
351 const auto EmptyRange =
352 make_range(SameNameIterator(*this, 0), SameNameIterator(*this, 0));
353 if (!IsValid)
354 return EmptyRange;
355
356 // Find the bucket.
357 uint32_t SearchHash = djbHash(Key);
358 uint32_t BucketIdx = hashToBucketIdx(SearchHash);
359 std::optional<uint32_t> HashIdx = idxOfHashInBucket(SearchHash, BucketIdx);
360 if (!HashIdx)
361 return EmptyRange;
362
363 std::optional<uint64_t> MaybeDataOffset = readIthOffset(*HashIdx);
364 if (!MaybeDataOffset)
365 return EmptyRange;
366
367 uint64_t DataOffset = *MaybeDataOffset;
368 if (DataOffset >= AccelSection.size())
369 return EmptyRange;
370
371 std::optional<uint32_t> StrOffset = readStringOffsetAt(DataOffset);
372 // Valid input and still have strings in this hash.
373 while (StrOffset && *StrOffset) {
374 std::optional<StringRef> MaybeStr = readStringFromStrSection(*StrOffset);
375 std::optional<uint32_t> NumEntries = this->readU32FromAccel(DataOffset);
376 if (!MaybeStr || !NumEntries)
377 return EmptyRange;
378 uint64_t EndOffset = DataOffset + *NumEntries * getHashDataEntryLength();
379 if (Key == *MaybeStr)
380 return make_range({*this, DataOffset},
381 SameNameIterator{*this, EndOffset});
382 DataOffset = EndOffset;
383 StrOffset = readStringOffsetAt(DataOffset);
384 }
385
386 return EmptyRange;
387}
388
389std::optional<uint32_t>
390AppleAcceleratorTable::idxOfHashInBucket(uint32_t HashToFind,
391 uint32_t BucketIdx) const {
392 std::optional<uint32_t> HashStartIdx = readIthBucket(BucketIdx);
393 if (!HashStartIdx)
394 return std::nullopt;
395
396 for (uint32_t HashIdx = *HashStartIdx; HashIdx < getNumHashes(); HashIdx++) {
397 std::optional<uint32_t> MaybeHash = readIthHash(HashIdx);
398 if (!MaybeHash || !wouldHashBeInBucket(*MaybeHash, BucketIdx))
399 break;
400 if (*MaybeHash == HashToFind)
401 return HashIdx;
402 }
403 return std::nullopt;
404}
405
406std::optional<StringRef> AppleAcceleratorTable::readStringFromStrSection(
407 uint64_t StringSectionOffset) const {
409 StringRef Str = StringSection.getCStrRef(&StringSectionOffset, &E);
410 if (E) {
411 consumeError(std::move(E));
412 return std::nullopt;
413 }
414 return Str;
415}
416
417std::optional<uint32_t>
418AppleAcceleratorTable::readU32FromAccel(uint64_t &Offset,
419 bool UseRelocation) const {
421 uint32_t Data = UseRelocation
422 ? AccelSection.getRelocatedValue(4, &Offset, nullptr, &E)
424 if (E) {
425 consumeError(std::move(E));
426 return std::nullopt;
427 }
428 return Data;
429}
430
432 DictScope HeaderScope(W, "Header");
433 W.printHex("Length", UnitLength);
434 W.printString("Format", dwarf::FormatString(Format));
435 W.printNumber("Version", Version);
436 W.printNumber("CU count", CompUnitCount);
437 W.printNumber("Local TU count", LocalTypeUnitCount);
438 W.printNumber("Foreign TU count", ForeignTypeUnitCount);
439 W.printNumber("Bucket count", BucketCount);
440 W.printNumber("Name count", NameCount);
441 W.printHex("Abbreviations table size", AbbrevTableSize);
442 W.startLine() << "Augmentation: '" << AugmentationString << "'\n";
443}
444
446 uint64_t *Offset) {
447 auto HeaderError = [Offset = *Offset](Error E) {
449 "parsing .debug_names header at 0x%" PRIx64 ": %s",
450 Offset, toString(std::move(E)).c_str());
451 };
452
454 std::tie(UnitLength, Format) = AS.getInitialLength(C);
455
456 Version = AS.getU16(C);
457 AS.skip(C, 2); // padding
458 CompUnitCount = AS.getU32(C);
459 LocalTypeUnitCount = AS.getU32(C);
460 ForeignTypeUnitCount = AS.getU32(C);
461 BucketCount = AS.getU32(C);
462 NameCount = AS.getU32(C);
463 AbbrevTableSize = AS.getU32(C);
464 AugmentationStringSize = alignTo(AS.getU32(C), 4);
465
466 if (!C)
467 return HeaderError(C.takeError());
468
469 if (!AS.isValidOffsetForDataOfSize(C.tell(), AugmentationStringSize))
471 "cannot read header augmentation"));
472 AugmentationString.resize(AugmentationStringSize);
473 AS.getU8(C, reinterpret_cast<uint8_t *>(AugmentationString.data()),
474 AugmentationStringSize);
475 *Offset = C.tell();
476 return C.takeError();
477}
478
480 DictScope AbbrevScope(W, ("Abbreviation 0x" + Twine::utohexstr(Code)).str());
481 W.startLine() << formatv("Tag: {0}\n", Tag);
482
483 for (const auto &Attr : Attributes)
484 W.startLine() << formatv("{0}: {1}\n", Attr.Index, Attr.Form);
485}
486
488 return {dwarf::Index(0), dwarf::Form(0)};
489}
490
492 return AE == sentinelAttrEnc();
493}
494
496 return DWARFDebugNames::Abbrev(0, dwarf::Tag(0), {});
497}
498
499static bool isSentinel(const DWARFDebugNames::Abbrev &Abbr) {
500 return Abbr.Code == 0;
501}
502
503DWARFDebugNames::Abbrev DWARFDebugNames::AbbrevMapInfo::getEmptyKey() {
504 return sentinelAbbrev();
505}
506
507DWARFDebugNames::Abbrev DWARFDebugNames::AbbrevMapInfo::getTombstoneKey() {
508 return DWARFDebugNames::Abbrev(~0, dwarf::Tag(0), {});
509}
510
512DWARFDebugNames::NameIndex::extractAttributeEncoding(uint64_t *Offset) {
513 if (*Offset >= EntriesBase) {
515 "Incorrectly terminated abbreviation table.");
516 }
517
518 uint32_t Index = Section.AccelSection.getULEB128(Offset);
519 uint32_t Form = Section.AccelSection.getULEB128(Offset);
520 return AttributeEncoding(dwarf::Index(Index), dwarf::Form(Form));
521}
522
524DWARFDebugNames::NameIndex::extractAttributeEncodings(uint64_t *Offset) {
525 std::vector<AttributeEncoding> Result;
526 for (;;) {
527 auto AttrEncOr = extractAttributeEncoding(Offset);
528 if (!AttrEncOr)
529 return AttrEncOr.takeError();
530 if (isSentinel(*AttrEncOr))
531 return std::move(Result);
532
533 Result.emplace_back(*AttrEncOr);
534 }
535}
536
538DWARFDebugNames::NameIndex::extractAbbrev(uint64_t *Offset) {
539 if (*Offset >= EntriesBase) {
541 "Incorrectly terminated abbreviation table.");
542 }
543
544 uint32_t Code = Section.AccelSection.getULEB128(Offset);
545 if (Code == 0)
546 return sentinelAbbrev();
547
548 uint32_t Tag = Section.AccelSection.getULEB128(Offset);
549 auto AttrEncOr = extractAttributeEncodings(Offset);
550 if (!AttrEncOr)
551 return AttrEncOr.takeError();
552 return Abbrev(Code, dwarf::Tag(Tag), std::move(*AttrEncOr));
553}
554
556 const DWARFDataExtractor &AS = Section.AccelSection;
558 if (Error E = Hdr.extract(AS, &Offset))
559 return E;
560
561 const unsigned SectionOffsetSize = dwarf::getDwarfOffsetByteSize(Hdr.Format);
562 CUsBase = Offset;
563 Offset += Hdr.CompUnitCount * SectionOffsetSize;
564 Offset += Hdr.LocalTypeUnitCount * SectionOffsetSize;
565 Offset += Hdr.ForeignTypeUnitCount * 8;
566 BucketsBase = Offset;
567 Offset += Hdr.BucketCount * 4;
568 HashesBase = Offset;
569 if (Hdr.BucketCount > 0)
570 Offset += Hdr.NameCount * 4;
571 StringOffsetsBase = Offset;
572 Offset += Hdr.NameCount * SectionOffsetSize;
573 EntryOffsetsBase = Offset;
574 Offset += Hdr.NameCount * SectionOffsetSize;
575
576 if (!AS.isValidOffsetForDataOfSize(Offset, Hdr.AbbrevTableSize))
578 "Section too small: cannot read abbreviations.");
579
580 EntriesBase = Offset + Hdr.AbbrevTableSize;
581
582 for (;;) {
583 auto AbbrevOr = extractAbbrev(&Offset);
584 if (!AbbrevOr)
585 return AbbrevOr.takeError();
586 if (isSentinel(*AbbrevOr))
587 return Error::success();
588
589 if (!Abbrevs.insert(std::move(*AbbrevOr)).second)
591 "Duplicate abbreviation code.");
592 }
593}
594
595DWARFDebugNames::Entry::Entry(const NameIndex &NameIdx, const Abbrev &Abbr)
596 : NameIdx(&NameIdx), Abbr(&Abbr) {
597 // This merely creates form values. It is up to the caller
598 // (NameIndex::getEntry) to populate them.
599 Values.reserve(Abbr.Attributes.size());
600 for (const auto &Attr : Abbr.Attributes)
601 Values.emplace_back(Attr.Form);
602}
603
604std::optional<DWARFFormValue>
606 assert(Abbr->Attributes.size() == Values.size());
607 for (auto Tuple : zip_first(Abbr->Attributes, Values)) {
608 if (std::get<0>(Tuple).Index == Index)
609 return std::get<1>(Tuple);
610 }
611 return std::nullopt;
612}
613
614std::optional<uint64_t> DWARFDebugNames::Entry::getDIEUnitOffset() const {
615 if (std::optional<DWARFFormValue> Off = lookup(dwarf::DW_IDX_die_offset))
616 return Off->getAsReferenceUVal();
617 return std::nullopt;
618}
619
620std::optional<uint64_t> DWARFDebugNames::Entry::getCUIndex() const {
621 if (std::optional<DWARFFormValue> Off = lookup(dwarf::DW_IDX_compile_unit))
622 return Off->getAsUnsignedConstant();
623 // In a per-CU index, the entries without a DW_IDX_compile_unit attribute
624 // implicitly refer to the single CU.
625 if (NameIdx->getCUCount() == 1)
626 return 0;
627 return std::nullopt;
628}
629
630std::optional<uint64_t> DWARFDebugNames::Entry::getCUOffset() const {
631 std::optional<uint64_t> Index = getCUIndex();
632 if (!Index || *Index >= NameIdx->getCUCount())
633 return std::nullopt;
634 return NameIdx->getCUOffset(*Index);
635}
636
638 W.printHex("Abbrev", Abbr->Code);
639 W.startLine() << formatv("Tag: {0}\n", Abbr->Tag);
640 assert(Abbr->Attributes.size() == Values.size());
641 for (auto Tuple : zip_first(Abbr->Attributes, Values)) {
642 W.startLine() << formatv("{0}: ", std::get<0>(Tuple).Index);
643 std::get<1>(Tuple).dump(W.getOStream());
644 W.getOStream() << '\n';
645 }
646}
647
650 return inconvertibleErrorCode();
651}
652
654 assert(CU < Hdr.CompUnitCount);
655 const unsigned SectionOffsetSize = dwarf::getDwarfOffsetByteSize(Hdr.Format);
656 uint64_t Offset = CUsBase + SectionOffsetSize * CU;
657 return Section.AccelSection.getRelocatedValue(SectionOffsetSize, &Offset);
658}
659
661 assert(TU < Hdr.LocalTypeUnitCount);
662 const unsigned SectionOffsetSize = dwarf::getDwarfOffsetByteSize(Hdr.Format);
663 uint64_t Offset = CUsBase + SectionOffsetSize * (Hdr.CompUnitCount + TU);
664 return Section.AccelSection.getRelocatedValue(SectionOffsetSize, &Offset);
665}
666
668 assert(TU < Hdr.ForeignTypeUnitCount);
669 const unsigned SectionOffsetSize = dwarf::getDwarfOffsetByteSize(Hdr.Format);
671 CUsBase +
672 SectionOffsetSize * (Hdr.CompUnitCount + Hdr.LocalTypeUnitCount) + 8 * TU;
673 return Section.AccelSection.getU64(&Offset);
674}
675
678 const DWARFDataExtractor &AS = Section.AccelSection;
679 if (!AS.isValidOffset(*Offset))
681 "Incorrectly terminated entry list.");
682
683 uint32_t AbbrevCode = AS.getULEB128(Offset);
684 if (AbbrevCode == 0)
685 return make_error<SentinelError>();
686
687 const auto AbbrevIt = Abbrevs.find_as(AbbrevCode);
688 if (AbbrevIt == Abbrevs.end())
689 return createStringError(errc::invalid_argument, "Invalid abbreviation.");
690
691 Entry E(*this, *AbbrevIt);
692
693 dwarf::FormParams FormParams = {Hdr.Version, 0, Hdr.Format};
694 for (auto &Value : E.Values) {
695 if (!Value.extractValue(AS, Offset, FormParams))
697 "Error extracting index attribute values.");
698 }
699 return std::move(E);
700}
701
704 assert(0 < Index && Index <= Hdr.NameCount);
705 const unsigned SectionOffsetSize = dwarf::getDwarfOffsetByteSize(Hdr.Format);
706 uint64_t StringOffsetOffset =
707 StringOffsetsBase + SectionOffsetSize * (Index - 1);
708 uint64_t EntryOffsetOffset =
709 EntryOffsetsBase + SectionOffsetSize * (Index - 1);
710 const DWARFDataExtractor &AS = Section.AccelSection;
711
712 uint64_t StringOffset =
713 AS.getRelocatedValue(SectionOffsetSize, &StringOffsetOffset);
714 uint64_t EntryOffset = AS.getUnsigned(&EntryOffsetOffset, SectionOffsetSize);
715 EntryOffset += EntriesBase;
716 return {Section.StringSection, Index, StringOffset, EntryOffset};
717}
718
721 assert(Bucket < Hdr.BucketCount);
722 uint64_t BucketOffset = BucketsBase + 4 * Bucket;
723 return Section.AccelSection.getU32(&BucketOffset);
724}
725
727 assert(0 < Index && Index <= Hdr.NameCount);
728 uint64_t HashOffset = HashesBase + 4 * (Index - 1);
729 return Section.AccelSection.getU32(&HashOffset);
730}
731
732// Returns true if we should continue scanning for entries, false if this is the
733// last (sentinel) entry). In case of a parsing error we also return false, as
734// it's not possible to recover this entry list (but the other lists may still
735// parse OK).
736bool DWARFDebugNames::NameIndex::dumpEntry(ScopedPrinter &W,
737 uint64_t *Offset) const {
738 uint64_t EntryId = *Offset;
739 auto EntryOr = getEntry(Offset);
740 if (!EntryOr) {
741 handleAllErrors(EntryOr.takeError(), [](const SentinelError &) {},
742 [&W](const ErrorInfoBase &EI) { EI.log(W.startLine()); });
743 return false;
744 }
745
746 DictScope EntryScope(W, ("Entry @ 0x" + Twine::utohexstr(EntryId)).str());
747 EntryOr->dump(W);
748 return true;
749}
750
751void DWARFDebugNames::NameIndex::dumpName(ScopedPrinter &W,
752 const NameTableEntry &NTE,
753 std::optional<uint32_t> Hash) const {
754 DictScope NameScope(W, ("Name " + Twine(NTE.getIndex())).str());
755 if (Hash)
756 W.printHex("Hash", *Hash);
757
758 W.startLine() << format("String: 0x%08" PRIx64, NTE.getStringOffset());
759 W.getOStream() << " \"" << NTE.getString() << "\"\n";
760
761 uint64_t EntryOffset = NTE.getEntryOffset();
762 while (dumpEntry(W, &EntryOffset))
763 /*empty*/;
764}
765
766void DWARFDebugNames::NameIndex::dumpCUs(ScopedPrinter &W) const {
767 ListScope CUScope(W, "Compilation Unit offsets");
768 for (uint32_t CU = 0; CU < Hdr.CompUnitCount; ++CU)
769 W.startLine() << format("CU[%u]: 0x%08" PRIx64 "\n", CU, getCUOffset(CU));
770}
771
772void DWARFDebugNames::NameIndex::dumpLocalTUs(ScopedPrinter &W) const {
773 if (Hdr.LocalTypeUnitCount == 0)
774 return;
775
776 ListScope TUScope(W, "Local Type Unit offsets");
777 for (uint32_t TU = 0; TU < Hdr.LocalTypeUnitCount; ++TU)
778 W.startLine() << format("LocalTU[%u]: 0x%08" PRIx64 "\n", TU,
779 getLocalTUOffset(TU));
780}
781
782void DWARFDebugNames::NameIndex::dumpForeignTUs(ScopedPrinter &W) const {
783 if (Hdr.ForeignTypeUnitCount == 0)
784 return;
785
786 ListScope TUScope(W, "Foreign Type Unit signatures");
787 for (uint32_t TU = 0; TU < Hdr.ForeignTypeUnitCount; ++TU) {
788 W.startLine() << format("ForeignTU[%u]: 0x%016" PRIx64 "\n", TU,
789 getForeignTUSignature(TU));
790 }
791}
792
793void DWARFDebugNames::NameIndex::dumpAbbreviations(ScopedPrinter &W) const {
794 ListScope AbbrevsScope(W, "Abbreviations");
795 for (const auto &Abbr : Abbrevs)
796 Abbr.dump(W);
797}
798
799void DWARFDebugNames::NameIndex::dumpBucket(ScopedPrinter &W,
800 uint32_t Bucket) const {
801 ListScope BucketScope(W, ("Bucket " + Twine(Bucket)).str());
802 uint32_t Index = getBucketArrayEntry(Bucket);
803 if (Index == 0) {
804 W.printString("EMPTY");
805 return;
806 }
807 if (Index > Hdr.NameCount) {
808 W.printString("Name index is invalid");
809 return;
810 }
811
812 for (; Index <= Hdr.NameCount; ++Index) {
813 uint32_t Hash = getHashArrayEntry(Index);
814 if (Hash % Hdr.BucketCount != Bucket)
815 break;
816
817 dumpName(W, getNameTableEntry(Index), Hash);
818 }
819}
820
822 DictScope UnitScope(W, ("Name Index @ 0x" + Twine::utohexstr(Base)).str());
823 Hdr.dump(W);
824 dumpCUs(W);
825 dumpLocalTUs(W);
826 dumpForeignTUs(W);
827 dumpAbbreviations(W);
828
829 if (Hdr.BucketCount > 0) {
830 for (uint32_t Bucket = 0; Bucket < Hdr.BucketCount; ++Bucket)
831 dumpBucket(W, Bucket);
832 return;
833 }
834
835 W.startLine() << "Hash table not present\n";
836 for (const NameTableEntry &NTE : *this)
837 dumpName(W, NTE, std::nullopt);
838}
839
841 uint64_t Offset = 0;
843 NameIndex Next(*this, Offset);
844 if (Error E = Next.extract())
845 return E;
846 Offset = Next.getNextUnitOffset();
847 NameIndices.push_back(std::move(Next));
848 }
849 return Error::success();
850}
851
854 return make_range(ValueIterator(*this, Key), ValueIterator());
855}
856
858 ScopedPrinter W(OS);
859 for (const NameIndex &NI : NameIndices)
860 NI.dump(W);
861}
862
863std::optional<uint64_t>
864DWARFDebugNames::ValueIterator::findEntryOffsetInCurrentIndex() {
865 const Header &Hdr = CurrentIndex->Hdr;
866 if (Hdr.BucketCount == 0) {
867 // No Hash Table, We need to search through all names in the Name Index.
868 for (const NameTableEntry &NTE : *CurrentIndex) {
869 if (NTE.getString() == Key)
870 return NTE.getEntryOffset();
871 }
872 return std::nullopt;
873 }
874
875 // The Name Index has a Hash Table, so use that to speed up the search.
876 // Compute the Key Hash, if it has not been done already.
877 if (!Hash)
878 Hash = caseFoldingDjbHash(Key);
879 uint32_t Bucket = *Hash % Hdr.BucketCount;
880 uint32_t Index = CurrentIndex->getBucketArrayEntry(Bucket);
881 if (Index == 0)
882 return std::nullopt; // Empty bucket
883
884 for (; Index <= Hdr.NameCount; ++Index) {
885 uint32_t Hash = CurrentIndex->getHashArrayEntry(Index);
886 if (Hash % Hdr.BucketCount != Bucket)
887 return std::nullopt; // End of bucket
888
889 NameTableEntry NTE = CurrentIndex->getNameTableEntry(Index);
890 if (NTE.getString() == Key)
891 return NTE.getEntryOffset();
892 }
893 return std::nullopt;
894}
895
896bool DWARFDebugNames::ValueIterator::getEntryAtCurrentOffset() {
897 auto EntryOr = CurrentIndex->getEntry(&DataOffset);
898 if (!EntryOr) {
899 consumeError(EntryOr.takeError());
900 return false;
901 }
902 CurrentEntry = std::move(*EntryOr);
903 return true;
904}
905
906bool DWARFDebugNames::ValueIterator::findInCurrentIndex() {
907 std::optional<uint64_t> Offset = findEntryOffsetInCurrentIndex();
908 if (!Offset)
909 return false;
910 DataOffset = *Offset;
911 return getEntryAtCurrentOffset();
912}
913
914void DWARFDebugNames::ValueIterator::searchFromStartOfCurrentIndex() {
915 for (const NameIndex *End = CurrentIndex->Section.NameIndices.end();
916 CurrentIndex != End; ++CurrentIndex) {
917 if (findInCurrentIndex())
918 return;
919 }
920 setEnd();
921}
922
923void DWARFDebugNames::ValueIterator::next() {
924 assert(CurrentIndex && "Incrementing an end() iterator?");
925
926 // First try the next entry in the current Index.
927 if (getEntryAtCurrentOffset())
928 return;
929
930 // If we're a local iterator or we have reached the last Index, we're done.
931 if (IsLocal || CurrentIndex == &CurrentIndex->Section.NameIndices.back()) {
932 setEnd();
933 return;
934 }
935
936 // Otherwise, try the next index.
937 ++CurrentIndex;
938 searchFromStartOfCurrentIndex();
939}
940
942 StringRef Key)
943 : CurrentIndex(AccelTable.NameIndices.begin()), IsLocal(false),
944 Key(std::string(Key)) {
945 searchFromStartOfCurrentIndex();
946}
947
950 : CurrentIndex(&NI), IsLocal(true), Key(std::string(Key)) {
951 if (!findInCurrentIndex())
952 setEnd();
953}
954
957 if (NameIndices.empty())
959 return make_range(ValueIterator(*this, Key), ValueIterator());
960}
961
964 if (CUToNameIndex.size() == 0 && NameIndices.size() > 0) {
965 for (const auto &NI : *this) {
966 for (uint32_t CU = 0; CU < NI.getCUCount(); ++CU)
967 CUToNameIndex.try_emplace(NI.getCUOffset(CU), &NI);
968 }
969 }
970 return CUToNameIndex.lookup(CUOffset);
971}
972
974 return Name.size() > 2 && (Name[0] == '-' || Name[0] == '+') &&
975 (Name[1] == '[');
976}
977
978std::optional<ObjCSelectorNames> llvm::getObjCNamesIfSelector(StringRef Name) {
979 if (!isObjCSelector(Name))
980 return std::nullopt;
981 // "-[Atom setMass:]"
982 StringRef ClassNameStart(Name.drop_front(2));
983 size_t FirstSpace = ClassNameStart.find(' ');
984 if (FirstSpace == StringRef::npos)
985 return std::nullopt;
986
987 StringRef SelectorStart = ClassNameStart.drop_front(FirstSpace + 1);
988 if (!SelectorStart.size())
989 return std::nullopt;
990
992 Ans.ClassName = ClassNameStart.take_front(FirstSpace);
993 Ans.Selector = SelectorStart.drop_back(); // drop ']';
994
995 // "-[Class(Category) selector :withArg ...]"
996 if (Ans.ClassName.back() == ')') {
997 size_t OpenParens = Ans.ClassName.find('(');
998 if (OpenParens != StringRef::npos) {
999 Ans.ClassNameNoCategory = Ans.ClassName.take_front(OpenParens);
1000
1001 Ans.MethodNameNoCategory = Name.take_front(OpenParens + 2);
1002 // FIXME: The missing space here may be a bug, but dsymutil-classic also
1003 // does it this way.
1004 append_range(*Ans.MethodNameNoCategory, SelectorStart);
1005 }
1006 }
1007 return Ans;
1008}
1009
1011 // We are looking for template parameters to strip from Name. e.g.
1012 //
1013 // operator<<B>
1014 //
1015 // We look for > at the end but if it does not contain any < then we
1016 // have something like operator>>. We check for the operator<=> case.
1017 if (!Name.endswith(">") || Name.count("<") == 0 || Name.endswith("<=>"))
1018 return {};
1019
1020 // How many < until we have the start of the template parameters.
1021 size_t NumLeftAnglesToSkip = 1;
1022
1023 // If we have operator<=> then we need to skip its < as well.
1024 NumLeftAnglesToSkip += Name.count("<=>");
1025
1026 size_t RightAngleCount = Name.count('>');
1027 size_t LeftAngleCount = Name.count('<');
1028
1029 // If we have more < than > we have operator< or operator<<
1030 // we to account for their < as well.
1031 if (LeftAngleCount > RightAngleCount)
1032 NumLeftAnglesToSkip += LeftAngleCount - RightAngleCount;
1033
1034 size_t StartOfTemplate = 0;
1035 while (NumLeftAnglesToSkip--)
1036 StartOfTemplate = Name.find('<', StartOfTemplate) + 1;
1037
1038 return Name.substr(0, StartOfTemplate - 1);
1039}
for(const MachineOperand &MO :llvm::drop_begin(OldMI.operands(), Desc.getNumOperands()))
AMDGPU Kernel Attributes
#define offsetof(TYPE, MEMBER)
basic Basic Alias true
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
Definition: Compiler.h:510
static constexpr DWARFDebugNames::AttributeEncoding sentinelAttrEnc()
static bool isSentinel(const DWARFDebugNames::AttributeEncoding &AE)
static DWARFDebugNames::Abbrev sentinelAbbrev()
static bool isObjCSelector(StringRef Name)
static Atom formatAtom(unsigned Atom)
This file contains constants used for implementing Dwarf debug support.
std::string Name
bool End
Definition: ELF_riscv.cpp:469
static bool lookup(const GsymReader &GR, DataExtractor &Data, uint64_t &Offset, uint64_t BaseAddr, uint64_t Addr, SourceLocations &SrcLocs, llvm::Error &Err)
A Lookup helper functions.
Definition: InlineInfo.cpp:109
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
This file defines the SmallVector class.
This class holds an abstract representation of an Accelerator Table, consisting of a sequence of buck...
Definition: AccelTable.h:193
std::optional< DWARFFormValue > lookup(HeaderData::AtomType Atom) const
Returns the value of the Atom in this Accelerator Entry, if the Entry contains such Atom.
std::optional< uint64_t > getDIESectionOffset() const
Returns the Section Offset of the Debug Info Entry associated with this Accelerator Entry or std::nul...
std::optional< dwarf::Tag > getTag() const override
Returns the Tag of the Debug Info Entry associated with this Accelerator Entry or std::nullopt if the...
std::optional< uint64_t > getCUOffset() const override
Returns the Offset of the Compilation Unit associated with this Accelerator Entry or std::nullopt if ...
Iterator(const AppleAcceleratorTable &Table, bool SetEnd=false)
An iterator for Entries all having the same string as key.
SameNameIterator(const AppleAcceleratorTable &AccelTable, uint64_t DataOffset)
Construct a new iterator for the entries at DataOffset.
This implements the Apple accelerator table format, a precursor of the DWARF 5 accelerator table form...
iterator_range< SameNameIterator > equal_range(StringRef Key) const
Look up all entries in the accelerator table matching Key.
std::pair< uint64_t, dwarf::Tag > readAtoms(uint64_t *HashDataOffset)
Return information related to the DWARF DIE we're looking for when performing a lookup by name.
uint32_t getHashDataEntryLength() const
Returns the size of one HashData entry.
void dump(raw_ostream &OS) const override
ArrayRef< std::pair< HeaderData::AtomType, HeaderData::Form > > getAtomsDesc()
Return the Atom description, which can be used to interpret the raw values of the Accelerator Entries...
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
SmallVector< DWARFFormValue, 3 > Values
A DataExtractor (typically for an in-memory copy of an object-file section) plus a relocation map for...
std::pair< uint64_t, dwarf::DwarfFormat > getInitialLength(uint64_t *Off, Error *Err=nullptr) const
Extracts the DWARF "initial length" field, which can either be a 32-bit value smaller than 0xfffffff0...
uint64_t getRelocatedValue(uint32_t Size, uint64_t *Off, uint64_t *SectionIndex=nullptr, Error *Err=nullptr) const
Extracts a value and applies a relocation to the result if one exists for the given offset.
DWARF v5-specific implementation of an Accelerator Entry.
std::optional< uint64_t > getCUIndex() const
Returns the Index into the Compilation Unit list of the owning Name Index or std::nullopt if this Acc...
std::optional< uint64_t > getCUOffset() const override
Returns the Offset of the Compilation Unit associated with this Accelerator Entry or std::nullopt if ...
std::optional< uint64_t > getDIEUnitOffset() const
Returns the Offset of the DIE within the containing CU or TU.
std::optional< DWARFFormValue > lookup(dwarf::Index Index) const
Returns the value of the Index Attribute in this Accelerator Entry, if the Entry contains such Attrib...
void dump(ScopedPrinter &W) const
Represents a single accelerator table within the DWARF v5 .debug_names section.
uint32_t getHashArrayEntry(uint32_t Index) const
Reads an entry in the Hash Array for the given Index.
uint64_t getLocalTUOffset(uint32_t TU) const
Reads offset of local type unit TU, TU is 0-based.
uint32_t getBucketArrayEntry(uint32_t Bucket) const
Reads an entry in the Bucket Array for the given Bucket.
void dump(ScopedPrinter &W) const
iterator_range< ValueIterator > equal_range(StringRef Key) const
Look up all entries in this Name Index matching Key.
uint64_t getCUOffset(uint32_t CU) const
Reads offset of compilation unit CU. CU is 0-based.
Expected< Entry > getEntry(uint64_t *Offset) const
NameTableEntry getNameTableEntry(uint32_t Index) const
Reads an entry in the Name Table for the given Index.
uint64_t getForeignTUSignature(uint32_t TU) const
Reads signature of foreign type unit TU. TU is 0-based.
A single entry in the Name Table (DWARF v5 sect.
Error returned by NameIndex::getEntry to report it has reached the end of the entry list.
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
ValueIterator()=default
End marker.
.debug_names section consists of one or more units.
const NameIndex * getCUNameIndex(uint64_t CUOffset)
Return the Name Index covering the compile unit at CUOffset, or nullptr if there is no Name Index cov...
const_iterator begin() const
iterator_range< ValueIterator > equal_range(StringRef Key) const
Look up all entries in the accelerator table matching Key.
void dump(raw_ostream &OS) const override
bool isFormClass(FormClass FC) const
bool extractValue(const DWARFDataExtractor &Data, uint64_t *OffsetPtr, dwarf::FormParams FormParams, const DWARFContext *Context=nullptr, const DWARFUnit *Unit=nullptr)
Extracts a value in Data at offset *OffsetPtr.
std::optional< uint64_t > getAsUnsignedConstant() const
dwarf::Form getForm() const
A class representing a position in a DataExtractor, as well as any error encountered during extractio...
Definition: DataExtractor.h:54
uint32_t getU32(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint32_t value from *offset_ptr.
size_t size() const
Return the number of bytes in the underlying buffer.
const char * getCStr(uint64_t *OffsetPtr, Error *Err=nullptr) const
Extract a C string from *offset_ptr.
StringRef getCStrRef(uint64_t *OffsetPtr, Error *Err=nullptr) const
Extract a C string from *offset_ptr.
uint8_t getU8(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint8_t value from *offset_ptr.
uint64_t getULEB128(uint64_t *offset_ptr, llvm::Error *Err=nullptr) const
Extract a unsigned LEB128 value from *offset_ptr.
uint16_t getU16(uint64_t *offset_ptr, Error *Err=nullptr) const
Extract a uint16_t value from *offset_ptr.
void skip(Cursor &C, uint64_t Length) const
Advance the Cursor position by the given number of bytes.
bool isValidOffset(uint64_t offset) const
Test the validity of offset.
bool isValidOffsetForDataOfSize(uint64_t offset, uint64_t length) const
Test the availability of length bytes of data from offset.
Base class for error info classes.
Definition: Error.h:45
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:334
Tagged union holding either a T or a Error.
Definition: Error.h:474
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:577
void push_back(const T &Elt)
Definition: SmallVector.h:416
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
StringRef drop_front(size_t N=1) const
Return a StringRef equal to 'this' but with the first N elements dropped.
Definition: StringRef.h:613
char back() const
back - Get the last character in the string.
Definition: StringRef.h:146
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
StringRef take_front(size_t N=1) const
Return a StringRef equal to 'this' but with only the first N elements remaining.
Definition: StringRef.h:584
size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:301
static constexpr size_t npos
Definition: StringRef.h:52
StringRef drop_back(size_t N=1) const
Return a StringRef equal to 'this' but with the last N elements dropped.
Definition: StringRef.h:620
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
static Twine utohexstr(const uint64_t &Val)
Definition: Twine.h:416
LLVM Value Representation.
Definition: Value.h:74
A range adaptor for a pair of iterators.
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
StringRef FormEncodingString(unsigned Encoding)
Definition: Dwarf.cpp:105
StringRef AtomTypeString(unsigned Atom)
Definition: Dwarf.cpp:622
StringRef FormatString(DwarfFormat Format)
Definition: Dwarf.cpp:826
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
StringRef AtomValueString(uint16_t Atom, unsigned Val)
Returns the symbolic string representing Val when used as a value for atom Atom.
Definition: Dwarf.cpp:707
std::optional< const char * > toString(const std::optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract a string value from it.
@ DWARF32
Definition: Dwarf.h:91
const uint32_t DW_INVALID_OFFSET
Identifier of an invalid DIE offset in the .debug_info section.
Definition: Dwarf.h:101
std::optional< uint8_t > getFixedFormByteSize(dwarf::Form Form, FormParams Params)
Get the fixed byte size for a given form.
Definition: Dwarf.cpp:729
uint8_t getDwarfOffsetByteSize(DwarfFormat Format)
The size of a reference determined by the DWARF 32/64-bit format.
Definition: Dwarf.h:730
@ DW_ATOM_type_flags
Definition: Dwarf.h:599
@ DW_ATOM_die_tag
Definition: Dwarf.h:598
@ DW_ATOM_die_offset
Marker as the end of a list of atoms.
Definition: Dwarf.h:595
@ DW_ATOM_cu_offset
Definition: Dwarf.h:596
NodeAddr< CodeNode * > Code
Definition: RDFGraph.h:388
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:440
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
detail::zippy< detail::zip_first, T, U, Args... > zip_equal(T &&t, U &&u, Args &&...args)
zip iterator that assumes that all iteratees have the same length.
Definition: STLExtras.h:873
void handleAllErrors(Error E, HandlerTs &&... Handlers)
Behaves the same as handleErrors, except that by contract all errors must be handled by the given han...
Definition: Error.h:970
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:90
SmallVectorImpl< T >::const_pointer c_str(SmallVectorImpl< T > &str)
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
Definition: STLExtras.h:2037
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1244
@ illegal_byte_sequence
detail::zippy< detail::zip_first, T, U, Args... > zip_first(T &&t, U &&u, Args &&...args)
zip iterator that, for the sake of efficiency, assumes the first iteratee to be the shortest.
Definition: STLExtras.h:886
std::optional< StringRef > StripTemplateParameters(StringRef Name)
If Name is the name of a templated function that includes template parameters, returns a substring of...
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:125
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
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:155
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:292
uint32_t djbHash(StringRef Buffer, uint32_t H=5381)
The Bernstein hash function used by the DWARF accelerator tables.
Definition: DJB.h:21
std::optional< ObjCSelectorNames > getObjCNamesIfSelector(StringRef Name)
If Name is the AT_name of a DIE which refers to an Objective-C selector, returns an instance of ObjCS...
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1041
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
Abbreviation describing the encoding of Name Index entries.
void dump(ScopedPrinter &W) const
uint32_t Code
Abbreviation code.
std::vector< AttributeEncoding > Attributes
List of index attributes.
dwarf::Tag Tag
Dwarf Tag of the described entity.
Index attribute and its encoding.
Error extract(const DWARFDataExtractor &AS, uint64_t *Offset)
void dump(ScopedPrinter &W) const
StringRef ClassName
For "-[A(Category) method:]", this would be "A(category)".
std::optional< std::string > MethodNameNoCategory
For "-[A(Category) method:]", this would be "A method:".
StringRef Selector
For "-[A(Category) method:]", this would be "method:".
std::optional< StringRef > ClassNameNoCategory
For "-[A(Category) method:]", this would be "A".
A helper struct providing information about the byte size of DW_FORM values that vary in size dependi...
Definition: Dwarf.h:743