Restoring authorship annotation for <orivej@yandex-team.ru>. Commit 1 of 2.

1 files changed, 905 insertions, 905 deletions

diff --git a/contrib/libs/llvm12/lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp b/contrib/libs/llvm12/lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp
index 28d35b609c..88566eecd5 100644
--- a/contrib/libs/llvm12/lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp
+++ b/contrib/libs/llvm12/lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp
@@ -1,905 +1,905 @@
-//===- DWARFAcceleratorTable.cpp ------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
-
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/BinaryFormat/Dwarf.h"
-#include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/DJB.h"
-#include "llvm/Support/Errc.h"
-#include "llvm/Support/Format.h"
-#include "llvm/Support/FormatVariadic.h"
-#include "llvm/Support/ScopedPrinter.h"
-#include "llvm/Support/raw_ostream.h"
-#include <cstddef>
-#include <cstdint>
-#include <utility>
-
-using namespace llvm;
-
-namespace {
-struct Atom {
-  unsigned Value;
-};
-
-static raw_ostream &operator<<(raw_ostream &OS, const Atom &A) {
-  StringRef Str = dwarf::AtomTypeString(A.Value);
-  if (!Str.empty())
-    return OS << Str;
-  return OS << "DW_ATOM_unknown_" << format("%x", A.Value);
-}
-} // namespace
-
-static Atom formatAtom(unsigned Atom) { return {Atom}; }
-
-DWARFAcceleratorTable::~DWARFAcceleratorTable() = default;
-
-Error AppleAcceleratorTable::extract() {
-  uint64_t Offset = 0;
-
-  // Check that we can at least read the header.
-  if (!AccelSection.isValidOffset(offsetof(Header, HeaderDataLength) + 4))
-    return createStringError(errc::illegal_byte_sequence,
-                             "Section too small: cannot read header.");
-
-  Hdr.Magic = AccelSection.getU32(&Offset);
-  Hdr.Version = AccelSection.getU16(&Offset);
-  Hdr.HashFunction = AccelSection.getU16(&Offset);
-  Hdr.BucketCount = AccelSection.getU32(&Offset);
-  Hdr.HashCount = AccelSection.getU32(&Offset);
-  Hdr.HeaderDataLength = AccelSection.getU32(&Offset);
-
-  // Check that we can read all the hashes and offsets from the
-  // section (see SourceLevelDebugging.rst for the structure of the index).
-  // We need to substract one because we're checking for an *offset* which is
-  // equal to the size for an empty table and hence pointer after the section.
-  if (!AccelSection.isValidOffset(sizeof(Hdr) + Hdr.HeaderDataLength +
-                                  Hdr.BucketCount * 4 + Hdr.HashCount * 8 - 1))
-    return createStringError(
-        errc::illegal_byte_sequence,
-        "Section too small: cannot read buckets and hashes.");
-
-  HdrData.DIEOffsetBase = AccelSection.getU32(&Offset);
-  uint32_t NumAtoms = AccelSection.getU32(&Offset);
-
-  for (unsigned i = 0; i < NumAtoms; ++i) {
-    uint16_t AtomType = AccelSection.getU16(&Offset);
-    auto AtomForm = static_cast<dwarf::Form>(AccelSection.getU16(&Offset));
-    HdrData.Atoms.push_back(std::make_pair(AtomType, AtomForm));
-  }
-
-  IsValid = true;
-  return Error::success();
-}
-
-uint32_t AppleAcceleratorTable::getNumBuckets() { return Hdr.BucketCount; }
-uint32_t AppleAcceleratorTable::getNumHashes() { return Hdr.HashCount; }
-uint32_t AppleAcceleratorTable::getSizeHdr() { return sizeof(Hdr); }
-uint32_t AppleAcceleratorTable::getHeaderDataLength() {
-  return Hdr.HeaderDataLength;
-}
-
-ArrayRef<std::pair<AppleAcceleratorTable::HeaderData::AtomType,
-                   AppleAcceleratorTable::HeaderData::Form>>
-AppleAcceleratorTable::getAtomsDesc() {
-  return HdrData.Atoms;
-}
-
-bool AppleAcceleratorTable::validateForms() {
-  for (auto Atom : getAtomsDesc()) {
-    DWARFFormValue FormValue(Atom.second);
-    switch (Atom.first) {
-    case dwarf::DW_ATOM_die_offset:
-    case dwarf::DW_ATOM_die_tag:
-    case dwarf::DW_ATOM_type_flags:
-      if ((!FormValue.isFormClass(DWARFFormValue::FC_Constant) &&
-           !FormValue.isFormClass(DWARFFormValue::FC_Flag)) ||
-          FormValue.getForm() == dwarf::DW_FORM_sdata)
-        return false;
-      break;
-    default:
-      break;
-    }
-  }
-  return true;
-}
-
-std::pair<uint64_t, dwarf::Tag>
-AppleAcceleratorTable::readAtoms(uint64_t *HashDataOffset) {
-  uint64_t DieOffset = dwarf::DW_INVALID_OFFSET;
-  dwarf::Tag DieTag = dwarf::DW_TAG_null;
-  dwarf::FormParams FormParams = {Hdr.Version, 0, dwarf::DwarfFormat::DWARF32};
-
-  for (auto Atom : getAtomsDesc()) {
-    DWARFFormValue FormValue(Atom.second);
-    FormValue.extractValue(AccelSection, HashDataOffset, FormParams);
-    switch (Atom.first) {
-    case dwarf::DW_ATOM_die_offset:
-      DieOffset = *FormValue.getAsUnsignedConstant();
-      break;
-    case dwarf::DW_ATOM_die_tag:
-      DieTag = (dwarf::Tag)*FormValue.getAsUnsignedConstant();
-      break;
-    default:
-      break;
-    }
-  }
-  return {DieOffset, DieTag};
-}
-
-void AppleAcceleratorTable::Header::dump(ScopedPrinter &W) const {
-  DictScope HeaderScope(W, "Header");
-  W.printHex("Magic", Magic);
-  W.printHex("Version", Version);
-  W.printHex("Hash function", HashFunction);
-  W.printNumber("Bucket count", BucketCount);
-  W.printNumber("Hashes count", HashCount);
-  W.printNumber("HeaderData length", HeaderDataLength);
-}
-
-Optional<uint64_t> AppleAcceleratorTable::HeaderData::extractOffset(
-    Optional<DWARFFormValue> Value) const {
-  if (!Value)
-    return None;
-
-  switch (Value->getForm()) {
-  case dwarf::DW_FORM_ref1:
-  case dwarf::DW_FORM_ref2:
-  case dwarf::DW_FORM_ref4:
-  case dwarf::DW_FORM_ref8:
-  case dwarf::DW_FORM_ref_udata:
-    return Value->getRawUValue() + DIEOffsetBase;
-  default:
-    return Value->getAsSectionOffset();
-  }
-}
-
-bool AppleAcceleratorTable::dumpName(ScopedPrinter &W,
-                                     SmallVectorImpl<DWARFFormValue> &AtomForms,
-                                     uint64_t *DataOffset) const {
-  dwarf::FormParams FormParams = {Hdr.Version, 0, dwarf::DwarfFormat::DWARF32};
-  uint64_t NameOffset = *DataOffset;
-  if (!AccelSection.isValidOffsetForDataOfSize(*DataOffset, 4)) {
-    W.printString("Incorrectly terminated list.");
-    return false;
-  }
-  uint64_t StringOffset = AccelSection.getRelocatedValue(4, DataOffset);
-  if (!StringOffset)
-    return false; // End of list
-
-  DictScope NameScope(W, ("Name@0x" + Twine::utohexstr(NameOffset)).str());
-  W.startLine() << format("String: 0x%08" PRIx64, StringOffset);
-  W.getOStream() << " \"" << StringSection.getCStr(&StringOffset) << "\"\n";
-
-  unsigned NumData = AccelSection.getU32(DataOffset);
-  for (unsigned Data = 0; Data < NumData; ++Data) {
-    ListScope DataScope(W, ("Data " + Twine(Data)).str());
-    unsigned i = 0;
-    for (auto &Atom : AtomForms) {
-      W.startLine() << format("Atom[%d]: ", i);
-      if (Atom.extractValue(AccelSection, DataOffset, FormParams)) {
-        Atom.dump(W.getOStream());
-        if (Optional<uint64_t> Val = Atom.getAsUnsignedConstant()) {
-          StringRef Str = dwarf::AtomValueString(HdrData.Atoms[i].first, *Val);
-          if (!Str.empty())
-            W.getOStream() << " (" << Str << ")";
-        }
-      } else
-        W.getOStream() << "Error extracting the value";
-      W.getOStream() << "\n";
-      i++;
-    }
-  }
-  return true; // more entries follow
-}
-
-LLVM_DUMP_METHOD void AppleAcceleratorTable::dump(raw_ostream &OS) const {
-  if (!IsValid)
-    return;
-
-  ScopedPrinter W(OS);
-
-  Hdr.dump(W);
-
-  W.printNumber("DIE offset base", HdrData.DIEOffsetBase);
-  W.printNumber("Number of atoms", uint64_t(HdrData.Atoms.size()));
-  SmallVector<DWARFFormValue, 3> AtomForms;
-  {
-    ListScope AtomsScope(W, "Atoms");
-    unsigned i = 0;
-    for (const auto &Atom : HdrData.Atoms) {
-      DictScope AtomScope(W, ("Atom " + Twine(i++)).str());
-      W.startLine() << "Type: " << formatAtom(Atom.first) << '\n';
-      W.startLine() << "Form: " << formatv("{0}", Atom.second) << '\n';
-      AtomForms.push_back(DWARFFormValue(Atom.second));
-    }
-  }
-
-  // Now go through the actual tables and dump them.
-  uint64_t Offset = sizeof(Hdr) + Hdr.HeaderDataLength;
-  uint64_t HashesBase = Offset + Hdr.BucketCount * 4;
-  uint64_t OffsetsBase = HashesBase + Hdr.HashCount * 4;
-
-  for (unsigned Bucket = 0; Bucket < Hdr.BucketCount; ++Bucket) {
-    unsigned Index = AccelSection.getU32(&Offset);
-
-    ListScope BucketScope(W, ("Bucket " + Twine(Bucket)).str());
-    if (Index == UINT32_MAX) {
-      W.printString("EMPTY");
-      continue;
-    }
-
-    for (unsigned HashIdx = Index; HashIdx < Hdr.HashCount; ++HashIdx) {
-      uint64_t HashOffset = HashesBase + HashIdx*4;
-      uint64_t OffsetsOffset = OffsetsBase + HashIdx*4;
-      uint32_t Hash = AccelSection.getU32(&HashOffset);
-
-      if (Hash % Hdr.BucketCount != Bucket)
-        break;
-
-      uint64_t DataOffset = AccelSection.getU32(&OffsetsOffset);
-      ListScope HashScope(W, ("Hash 0x" + Twine::utohexstr(Hash)).str());
-      if (!AccelSection.isValidOffset(DataOffset)) {
-        W.printString("Invalid section offset");
-        continue;
-      }
-      while (dumpName(W, AtomForms, &DataOffset))
-        /*empty*/;
-    }
-  }
-}
-
-AppleAcceleratorTable::Entry::Entry(
-    const AppleAcceleratorTable::HeaderData &HdrData)
-    : HdrData(&HdrData) {
-  Values.reserve(HdrData.Atoms.size());
-  for (const auto &Atom : HdrData.Atoms)
-    Values.push_back(DWARFFormValue(Atom.second));
-}
-
-void AppleAcceleratorTable::Entry::extract(
-    const AppleAcceleratorTable &AccelTable, uint64_t *Offset) {
-
-  dwarf::FormParams FormParams = {AccelTable.Hdr.Version, 0,
-                                  dwarf::DwarfFormat::DWARF32};
-  for (auto &Atom : Values)
-    Atom.extractValue(AccelTable.AccelSection, Offset, FormParams);
-}
-
-Optional<DWARFFormValue>
-AppleAcceleratorTable::Entry::lookup(HeaderData::AtomType Atom) const {
-  assert(HdrData && "Dereferencing end iterator?");
-  assert(HdrData->Atoms.size() == Values.size());
-  for (auto Tuple : zip_first(HdrData->Atoms, Values)) {
-    if (std::get<0>(Tuple).first == Atom)
-      return std::get<1>(Tuple);
-  }
-  return None;
-}
-
-Optional<uint64_t> AppleAcceleratorTable::Entry::getDIESectionOffset() const {
-  return HdrData->extractOffset(lookup(dwarf::DW_ATOM_die_offset));
-}
-
-Optional<uint64_t> AppleAcceleratorTable::Entry::getCUOffset() const {
-  return HdrData->extractOffset(lookup(dwarf::DW_ATOM_cu_offset));
-}
-
-Optional<dwarf::Tag> AppleAcceleratorTable::Entry::getTag() const {
-  Optional<DWARFFormValue> Tag = lookup(dwarf::DW_ATOM_die_tag);
-  if (!Tag)
-    return None;
-  if (Optional<uint64_t> Value = Tag->getAsUnsignedConstant())
-    return dwarf::Tag(*Value);
-  return None;
-}
-
-AppleAcceleratorTable::ValueIterator::ValueIterator(
-    const AppleAcceleratorTable &AccelTable, uint64_t Offset)
-    : AccelTable(&AccelTable), Current(AccelTable.HdrData), DataOffset(Offset) {
-  if (!AccelTable.AccelSection.isValidOffsetForDataOfSize(DataOffset, 4))
-    return;
-
-  // Read the first entry.
-  NumData = AccelTable.AccelSection.getU32(&DataOffset);
-  Next();
-}
-
-void AppleAcceleratorTable::ValueIterator::Next() {
-  assert(NumData > 0 && "attempted to increment iterator past the end");
-  auto &AccelSection = AccelTable->AccelSection;
-  if (Data >= NumData ||
-      !AccelSection.isValidOffsetForDataOfSize(DataOffset, 4)) {
-    NumData = 0;
-    DataOffset = 0;
-    return;
-  }
-  Current.extract(*AccelTable, &DataOffset);
-  ++Data;
-}
-
-iterator_range<AppleAcceleratorTable::ValueIterator>
-AppleAcceleratorTable::equal_range(StringRef Key) const {
-  if (!IsValid)
-    return make_range(ValueIterator(), ValueIterator());
-
-  // Find the bucket.
-  unsigned HashValue = djbHash(Key);
-  unsigned Bucket = HashValue % Hdr.BucketCount;
-  uint64_t BucketBase = sizeof(Hdr) + Hdr.HeaderDataLength;
-  uint64_t HashesBase = BucketBase + Hdr.BucketCount * 4;
-  uint64_t OffsetsBase = HashesBase + Hdr.HashCount * 4;
-
-  uint64_t BucketOffset = BucketBase + Bucket * 4;
-  unsigned Index = AccelSection.getU32(&BucketOffset);
-
-  // Search through all hashes in the bucket.
-  for (unsigned HashIdx = Index; HashIdx < Hdr.HashCount; ++HashIdx) {
-    uint64_t HashOffset = HashesBase + HashIdx * 4;
-    uint64_t OffsetsOffset = OffsetsBase + HashIdx * 4;
-    uint32_t Hash = AccelSection.getU32(&HashOffset);
-
-    if (Hash % Hdr.BucketCount != Bucket)
-      // We are already in the next bucket.
-      break;
-
-    uint64_t DataOffset = AccelSection.getU32(&OffsetsOffset);
-    uint64_t StringOffset = AccelSection.getRelocatedValue(4, &DataOffset);
-    if (!StringOffset)
-      break;
-
-    // Finally, compare the key.
-    if (Key == StringSection.getCStr(&StringOffset))
-      return make_range({*this, DataOffset}, ValueIterator());
-  }
-  return make_range(ValueIterator(), ValueIterator());
-}
-
-void DWARFDebugNames::Header::dump(ScopedPrinter &W) const {
-  DictScope HeaderScope(W, "Header");
-  W.printHex("Length", UnitLength);
-  W.printString("Format", dwarf::FormatString(Format));
-  W.printNumber("Version", Version);
-  W.printNumber("CU count", CompUnitCount);
-  W.printNumber("Local TU count", LocalTypeUnitCount);
-  W.printNumber("Foreign TU count", ForeignTypeUnitCount);
-  W.printNumber("Bucket count", BucketCount);
-  W.printNumber("Name count", NameCount);
-  W.printHex("Abbreviations table size", AbbrevTableSize);
-  W.startLine() << "Augmentation: '" << AugmentationString << "'\n";
-}
-
-Error DWARFDebugNames::Header::extract(const DWARFDataExtractor &AS,
-                                             uint64_t *Offset) {
-  auto HeaderError = [Offset = *Offset](Error E) {
-    return createStringError(errc::illegal_byte_sequence,
-                             "parsing .debug_names header at 0x%" PRIx64 ": %s",
-                             Offset, toString(std::move(E)).c_str());
-  };
-
-  DataExtractor::Cursor C(*Offset);
-  std::tie(UnitLength, Format) = AS.getInitialLength(C);
-
-  Version = AS.getU16(C);
-  AS.skip(C, 2); // padding
-  CompUnitCount = AS.getU32(C);
-  LocalTypeUnitCount = AS.getU32(C);
-  ForeignTypeUnitCount = AS.getU32(C);
-  BucketCount = AS.getU32(C);
-  NameCount = AS.getU32(C);
-  AbbrevTableSize = AS.getU32(C);
-  AugmentationStringSize = alignTo(AS.getU32(C), 4);
-
-  if (!C)
-    return HeaderError(C.takeError());
-
-  if (!AS.isValidOffsetForDataOfSize(C.tell(), AugmentationStringSize))
-    return HeaderError(createStringError(errc::illegal_byte_sequence,
-                                         "cannot read header augmentation"));
-  AugmentationString.resize(AugmentationStringSize);
-  AS.getU8(C, reinterpret_cast<uint8_t *>(AugmentationString.data()),
-           AugmentationStringSize);
-  *Offset = C.tell();
-  return C.takeError();
-}
-
-void DWARFDebugNames::Abbrev::dump(ScopedPrinter &W) const {
-  DictScope AbbrevScope(W, ("Abbreviation 0x" + Twine::utohexstr(Code)).str());
-  W.startLine() << formatv("Tag: {0}\n", Tag);
-
-  for (const auto &Attr : Attributes)
-    W.startLine() << formatv("{0}: {1}\n", Attr.Index, Attr.Form);
-}
-
-static constexpr DWARFDebugNames::AttributeEncoding sentinelAttrEnc() {
-  return {dwarf::Index(0), dwarf::Form(0)};
-}
-
-static bool isSentinel(const DWARFDebugNames::AttributeEncoding &AE) {
-  return AE == sentinelAttrEnc();
-}
-
-static DWARFDebugNames::Abbrev sentinelAbbrev() {
-  return DWARFDebugNames::Abbrev(0, dwarf::Tag(0), {});
-}
-
-static bool isSentinel(const DWARFDebugNames::Abbrev &Abbr) {
-  return Abbr.Code == 0;
-}
-
-DWARFDebugNames::Abbrev DWARFDebugNames::AbbrevMapInfo::getEmptyKey() {
-  return sentinelAbbrev();
-}
-
-DWARFDebugNames::Abbrev DWARFDebugNames::AbbrevMapInfo::getTombstoneKey() {
-  return DWARFDebugNames::Abbrev(~0, dwarf::Tag(0), {});
-}
-
-Expected<DWARFDebugNames::AttributeEncoding>
-DWARFDebugNames::NameIndex::extractAttributeEncoding(uint64_t *Offset) {
-  if (*Offset >= EntriesBase) {
-    return createStringError(errc::illegal_byte_sequence,
-                             "Incorrectly terminated abbreviation table.");
-  }
-
-  uint32_t Index = Section.AccelSection.getULEB128(Offset);
-  uint32_t Form = Section.AccelSection.getULEB128(Offset);
-  return AttributeEncoding(dwarf::Index(Index), dwarf::Form(Form));
-}
-
-Expected<std::vector<DWARFDebugNames::AttributeEncoding>>
-DWARFDebugNames::NameIndex::extractAttributeEncodings(uint64_t *Offset) {
-  std::vector<AttributeEncoding> Result;
-  for (;;) {
-    auto AttrEncOr = extractAttributeEncoding(Offset);
-    if (!AttrEncOr)
-      return AttrEncOr.takeError();
-    if (isSentinel(*AttrEncOr))
-      return std::move(Result);
-
-    Result.emplace_back(*AttrEncOr);
-  }
-}
-
-Expected<DWARFDebugNames::Abbrev>
-DWARFDebugNames::NameIndex::extractAbbrev(uint64_t *Offset) {
-  if (*Offset >= EntriesBase) {
-    return createStringError(errc::illegal_byte_sequence,
-                             "Incorrectly terminated abbreviation table.");
-  }
-
-  uint32_t Code = Section.AccelSection.getULEB128(Offset);
-  if (Code == 0)
-    return sentinelAbbrev();
-
-  uint32_t Tag = Section.AccelSection.getULEB128(Offset);
-  auto AttrEncOr = extractAttributeEncodings(Offset);
-  if (!AttrEncOr)
-    return AttrEncOr.takeError();
-  return Abbrev(Code, dwarf::Tag(Tag), std::move(*AttrEncOr));
-}
-
-Error DWARFDebugNames::NameIndex::extract() {
-  const DWARFDataExtractor &AS = Section.AccelSection;
-  uint64_t Offset = Base;
-  if (Error E = Hdr.extract(AS, &Offset))
-    return E;
-
-  const unsigned SectionOffsetSize = dwarf::getDwarfOffsetByteSize(Hdr.Format);
-  CUsBase = Offset;
-  Offset += Hdr.CompUnitCount * SectionOffsetSize;
-  Offset += Hdr.LocalTypeUnitCount * SectionOffsetSize;
-  Offset += Hdr.ForeignTypeUnitCount * 8;
-  BucketsBase = Offset;
-  Offset += Hdr.BucketCount * 4;
-  HashesBase = Offset;
-  if (Hdr.BucketCount > 0)
-    Offset += Hdr.NameCount * 4;
-  StringOffsetsBase = Offset;
-  Offset += Hdr.NameCount * SectionOffsetSize;
-  EntryOffsetsBase = Offset;
-  Offset += Hdr.NameCount * SectionOffsetSize;
-
-  if (!AS.isValidOffsetForDataOfSize(Offset, Hdr.AbbrevTableSize))
-    return createStringError(errc::illegal_byte_sequence,
-                             "Section too small: cannot read abbreviations.");
-
-  EntriesBase = Offset + Hdr.AbbrevTableSize;
-
-  for (;;) {
-    auto AbbrevOr = extractAbbrev(&Offset);
-    if (!AbbrevOr)
-      return AbbrevOr.takeError();
-    if (isSentinel(*AbbrevOr))
-      return Error::success();
-
-    if (!Abbrevs.insert(std::move(*AbbrevOr)).second)
-      return createStringError(errc::invalid_argument,
-                               "Duplicate abbreviation code.");
-  }
-}
-
-DWARFDebugNames::Entry::Entry(const NameIndex &NameIdx, const Abbrev &Abbr)
-    : NameIdx(&NameIdx), Abbr(&Abbr) {
-  // This merely creates form values. It is up to the caller
-  // (NameIndex::getEntry) to populate them.
-  Values.reserve(Abbr.Attributes.size());
-  for (const auto &Attr : Abbr.Attributes)
-    Values.emplace_back(Attr.Form);
-}
-
-Optional<DWARFFormValue>
-DWARFDebugNames::Entry::lookup(dwarf::Index Index) const {
-  assert(Abbr->Attributes.size() == Values.size());
-  for (auto Tuple : zip_first(Abbr->Attributes, Values)) {
-    if (std::get<0>(Tuple).Index == Index)
-      return std::get<1>(Tuple);
-  }
-  return None;
-}
-
-Optional<uint64_t> DWARFDebugNames::Entry::getDIEUnitOffset() const {
-  if (Optional<DWARFFormValue> Off = lookup(dwarf::DW_IDX_die_offset))
-    return Off->getAsReferenceUVal();
-  return None;
-}
-
-Optional<uint64_t> DWARFDebugNames::Entry::getCUIndex() const {
-  if (Optional<DWARFFormValue> Off = lookup(dwarf::DW_IDX_compile_unit))
-    return Off->getAsUnsignedConstant();
-  // In a per-CU index, the entries without a DW_IDX_compile_unit attribute
-  // implicitly refer to the single CU.
-  if (NameIdx->getCUCount() == 1)
-    return 0;
-  return None;
-}
-
-Optional<uint64_t> DWARFDebugNames::Entry::getCUOffset() const {
-  Optional<uint64_t> Index = getCUIndex();
-  if (!Index || *Index >= NameIdx->getCUCount())
-    return None;
-  return NameIdx->getCUOffset(*Index);
-}
-
-void DWARFDebugNames::Entry::dump(ScopedPrinter &W) const {
-  W.printHex("Abbrev", Abbr->Code);
-  W.startLine() << formatv("Tag: {0}\n", Abbr->Tag);
-  assert(Abbr->Attributes.size() == Values.size());
-  for (auto Tuple : zip_first(Abbr->Attributes, Values)) {
-    W.startLine() << formatv("{0}: ", std::get<0>(Tuple).Index);
-    std::get<1>(Tuple).dump(W.getOStream());
-    W.getOStream() << '\n';
-  }
-}
-
-char DWARFDebugNames::SentinelError::ID;
-std::error_code DWARFDebugNames::SentinelError::convertToErrorCode() const {
-  return inconvertibleErrorCode();
-}
-
-uint64_t DWARFDebugNames::NameIndex::getCUOffset(uint32_t CU) const {
-  assert(CU < Hdr.CompUnitCount);
-  const unsigned SectionOffsetSize = dwarf::getDwarfOffsetByteSize(Hdr.Format);
-  uint64_t Offset = CUsBase + SectionOffsetSize * CU;
-  return Section.AccelSection.getRelocatedValue(SectionOffsetSize, &Offset);
-}
-
-uint64_t DWARFDebugNames::NameIndex::getLocalTUOffset(uint32_t TU) const {
-  assert(TU < Hdr.LocalTypeUnitCount);
-  const unsigned SectionOffsetSize = dwarf::getDwarfOffsetByteSize(Hdr.Format);
-  uint64_t Offset = CUsBase + SectionOffsetSize * (Hdr.CompUnitCount + TU);
-  return Section.AccelSection.getRelocatedValue(SectionOffsetSize, &Offset);
-}
-
-uint64_t DWARFDebugNames::NameIndex::getForeignTUSignature(uint32_t TU) const {
-  assert(TU < Hdr.ForeignTypeUnitCount);
-  const unsigned SectionOffsetSize = dwarf::getDwarfOffsetByteSize(Hdr.Format);
-  uint64_t Offset =
-      CUsBase +
-      SectionOffsetSize * (Hdr.CompUnitCount + Hdr.LocalTypeUnitCount) + 8 * TU;
-  return Section.AccelSection.getU64(&Offset);
-}
-
-Expected<DWARFDebugNames::Entry>
-DWARFDebugNames::NameIndex::getEntry(uint64_t *Offset) const {
-  const DWARFDataExtractor &AS = Section.AccelSection;
-  if (!AS.isValidOffset(*Offset))
-    return createStringError(errc::illegal_byte_sequence,
-                             "Incorrectly terminated entry list.");
-
-  uint32_t AbbrevCode = AS.getULEB128(Offset);
-  if (AbbrevCode == 0)
-    return make_error<SentinelError>();
-
-  const auto AbbrevIt = Abbrevs.find_as(AbbrevCode);
-  if (AbbrevIt == Abbrevs.end())
-    return createStringError(errc::invalid_argument, "Invalid abbreviation.");
-
-  Entry E(*this, *AbbrevIt);
-
-  dwarf::FormParams FormParams = {Hdr.Version, 0, Hdr.Format};
-  for (auto &Value : E.Values) {
-    if (!Value.extractValue(AS, Offset, FormParams))
-      return createStringError(errc::io_error,
-                               "Error extracting index attribute values.");
-  }
-  return std::move(E);
-}
-
-DWARFDebugNames::NameTableEntry
-DWARFDebugNames::NameIndex::getNameTableEntry(uint32_t Index) const {
-  assert(0 < Index && Index <= Hdr.NameCount);
-  const unsigned SectionOffsetSize = dwarf::getDwarfOffsetByteSize(Hdr.Format);
-  uint64_t StringOffsetOffset =
-      StringOffsetsBase + SectionOffsetSize * (Index - 1);
-  uint64_t EntryOffsetOffset =
-      EntryOffsetsBase + SectionOffsetSize * (Index - 1);
-  const DWARFDataExtractor &AS = Section.AccelSection;
-
-  uint64_t StringOffset =
-      AS.getRelocatedValue(SectionOffsetSize, &StringOffsetOffset);
-  uint64_t EntryOffset = AS.getUnsigned(&EntryOffsetOffset, SectionOffsetSize);
-  EntryOffset += EntriesBase;
-  return {Section.StringSection, Index, StringOffset, EntryOffset};
-}
-
-uint32_t
-DWARFDebugNames::NameIndex::getBucketArrayEntry(uint32_t Bucket) const {
-  assert(Bucket < Hdr.BucketCount);
-  uint64_t BucketOffset = BucketsBase + 4 * Bucket;
-  return Section.AccelSection.getU32(&BucketOffset);
-}
-
-uint32_t DWARFDebugNames::NameIndex::getHashArrayEntry(uint32_t Index) const {
-  assert(0 < Index && Index <= Hdr.NameCount);
-  uint64_t HashOffset = HashesBase + 4 * (Index - 1);
-  return Section.AccelSection.getU32(&HashOffset);
-}
-
-// Returns true if we should continue scanning for entries, false if this is the
-// last (sentinel) entry). In case of a parsing error we also return false, as
-// it's not possible to recover this entry list (but the other lists may still
-// parse OK).
-bool DWARFDebugNames::NameIndex::dumpEntry(ScopedPrinter &W,
-                                           uint64_t *Offset) const {
-  uint64_t EntryId = *Offset;
-  auto EntryOr = getEntry(Offset);
-  if (!EntryOr) {
-    handleAllErrors(EntryOr.takeError(), [](const SentinelError &) {},
-                    [&W](const ErrorInfoBase &EI) { EI.log(W.startLine()); });
-    return false;
-  }
-
-  DictScope EntryScope(W, ("Entry @ 0x" + Twine::utohexstr(EntryId)).str());
-  EntryOr->dump(W);
-  return true;
-}
-
-void DWARFDebugNames::NameIndex::dumpName(ScopedPrinter &W,
-                                          const NameTableEntry &NTE,
-                                          Optional<uint32_t> Hash) const {
-  DictScope NameScope(W, ("Name " + Twine(NTE.getIndex())).str());
-  if (Hash)
-    W.printHex("Hash", *Hash);
-
-  W.startLine() << format("String: 0x%08" PRIx64, NTE.getStringOffset());
-  W.getOStream() << " \"" << NTE.getString() << "\"\n";
-
-  uint64_t EntryOffset = NTE.getEntryOffset();
-  while (dumpEntry(W, &EntryOffset))
-    /*empty*/;
-}
-
-void DWARFDebugNames::NameIndex::dumpCUs(ScopedPrinter &W) const {
-  ListScope CUScope(W, "Compilation Unit offsets");
-  for (uint32_t CU = 0; CU < Hdr.CompUnitCount; ++CU)
-    W.startLine() << format("CU[%u]: 0x%08" PRIx64 "\n", CU, getCUOffset(CU));
-}
-
-void DWARFDebugNames::NameIndex::dumpLocalTUs(ScopedPrinter &W) const {
-  if (Hdr.LocalTypeUnitCount == 0)
-    return;
-
-  ListScope TUScope(W, "Local Type Unit offsets");
-  for (uint32_t TU = 0; TU < Hdr.LocalTypeUnitCount; ++TU)
-    W.startLine() << format("LocalTU[%u]: 0x%08" PRIx64 "\n", TU,
-                            getLocalTUOffset(TU));
-}
-
-void DWARFDebugNames::NameIndex::dumpForeignTUs(ScopedPrinter &W) const {
-  if (Hdr.ForeignTypeUnitCount == 0)
-    return;
-
-  ListScope TUScope(W, "Foreign Type Unit signatures");
-  for (uint32_t TU = 0; TU < Hdr.ForeignTypeUnitCount; ++TU) {
-    W.startLine() << format("ForeignTU[%u]: 0x%016" PRIx64 "\n", TU,
-                            getForeignTUSignature(TU));
-  }
-}
-
-void DWARFDebugNames::NameIndex::dumpAbbreviations(ScopedPrinter &W) const {
-  ListScope AbbrevsScope(W, "Abbreviations");
-  for (const auto &Abbr : Abbrevs)
-    Abbr.dump(W);
-}
-
-void DWARFDebugNames::NameIndex::dumpBucket(ScopedPrinter &W,
-                                            uint32_t Bucket) const {
-  ListScope BucketScope(W, ("Bucket " + Twine(Bucket)).str());
-  uint32_t Index = getBucketArrayEntry(Bucket);
-  if (Index == 0) {
-    W.printString("EMPTY");
-    return;
-  }
-  if (Index > Hdr.NameCount) {
-    W.printString("Name index is invalid");
-    return;
-  }
-
-  for (; Index <= Hdr.NameCount; ++Index) {
-    uint32_t Hash = getHashArrayEntry(Index);
-    if (Hash % Hdr.BucketCount != Bucket)
-      break;
-
-    dumpName(W, getNameTableEntry(Index), Hash);
-  }
-}
-
-LLVM_DUMP_METHOD void DWARFDebugNames::NameIndex::dump(ScopedPrinter &W) const {
-  DictScope UnitScope(W, ("Name Index @ 0x" + Twine::utohexstr(Base)).str());
-  Hdr.dump(W);
-  dumpCUs(W);
-  dumpLocalTUs(W);
-  dumpForeignTUs(W);
-  dumpAbbreviations(W);
-
-  if (Hdr.BucketCount > 0) {
-    for (uint32_t Bucket = 0; Bucket < Hdr.BucketCount; ++Bucket)
-      dumpBucket(W, Bucket);
-    return;
-  }
-
-  W.startLine() << "Hash table not present\n";
-  for (NameTableEntry NTE : *this)
-    dumpName(W, NTE, None);
-}
-
-Error DWARFDebugNames::extract() {
-  uint64_t Offset = 0;
-  while (AccelSection.isValidOffset(Offset)) {
-    NameIndex Next(*this, Offset);
-    if (Error E = Next.extract())
-      return E;
-    Offset = Next.getNextUnitOffset();
-    NameIndices.push_back(std::move(Next));
-  }
-  return Error::success();
-}
-
-iterator_range<DWARFDebugNames::ValueIterator>
-DWARFDebugNames::NameIndex::equal_range(StringRef Key) const {
-  return make_range(ValueIterator(*this, Key), ValueIterator());
-}
-
-LLVM_DUMP_METHOD void DWARFDebugNames::dump(raw_ostream &OS) const {
-  ScopedPrinter W(OS);
-  for (const NameIndex &NI : NameIndices)
-    NI.dump(W);
-}
-
-Optional<uint64_t>
-DWARFDebugNames::ValueIterator::findEntryOffsetInCurrentIndex() {
-  const Header &Hdr = CurrentIndex->Hdr;
-  if (Hdr.BucketCount == 0) {
-    // No Hash Table, We need to search through all names in the Name Index.
-    for (NameTableEntry NTE : *CurrentIndex) {
-      if (NTE.getString() == Key)
-        return NTE.getEntryOffset();
-    }
-    return None;
-  }
-
-  // The Name Index has a Hash Table, so use that to speed up the search.
-  // Compute the Key Hash, if it has not been done already.
-  if (!Hash)
-    Hash = caseFoldingDjbHash(Key);
-  uint32_t Bucket = *Hash % Hdr.BucketCount;
-  uint32_t Index = CurrentIndex->getBucketArrayEntry(Bucket);
-  if (Index == 0)
-    return None; // Empty bucket
-
-  for (; Index <= Hdr.NameCount; ++Index) {
-    uint32_t Hash = CurrentIndex->getHashArrayEntry(Index);
-    if (Hash % Hdr.BucketCount != Bucket)
-      return None; // End of bucket
-
-    NameTableEntry NTE = CurrentIndex->getNameTableEntry(Index);
-    if (NTE.getString() == Key)
-      return NTE.getEntryOffset();
-  }
-  return None;
-}
-
-bool DWARFDebugNames::ValueIterator::getEntryAtCurrentOffset() {
-  auto EntryOr = CurrentIndex->getEntry(&DataOffset);
-  if (!EntryOr) {
-    consumeError(EntryOr.takeError());
-    return false;
-  }
-  CurrentEntry = std::move(*EntryOr);
-  return true;
-}
-
-bool DWARFDebugNames::ValueIterator::findInCurrentIndex() {
-  Optional<uint64_t> Offset = findEntryOffsetInCurrentIndex();
-  if (!Offset)
-    return false;
-  DataOffset = *Offset;
-  return getEntryAtCurrentOffset();
-}
-
-void DWARFDebugNames::ValueIterator::searchFromStartOfCurrentIndex() {
-  for (const NameIndex *End = CurrentIndex->Section.NameIndices.end();
-       CurrentIndex != End; ++CurrentIndex) {
-    if (findInCurrentIndex())
-      return;
-  }
-  setEnd();
-}
-
-void DWARFDebugNames::ValueIterator::next() {
-  assert(CurrentIndex && "Incrementing an end() iterator?");
-
-  // First try the next entry in the current Index.
-  if (getEntryAtCurrentOffset())
-    return;
-
-  // If we're a local iterator or we have reached the last Index, we're done.
-  if (IsLocal || CurrentIndex == &CurrentIndex->Section.NameIndices.back()) {
-    setEnd();
-    return;
-  }
-
-  // Otherwise, try the next index.
-  ++CurrentIndex;
-  searchFromStartOfCurrentIndex();
-}
-
-DWARFDebugNames::ValueIterator::ValueIterator(const DWARFDebugNames &AccelTable,
-                                              StringRef Key)
-    : CurrentIndex(AccelTable.NameIndices.begin()), IsLocal(false),
-      Key(std::string(Key)) {
-  searchFromStartOfCurrentIndex();
-}
-
-DWARFDebugNames::ValueIterator::ValueIterator(
-    const DWARFDebugNames::NameIndex &NI, StringRef Key)
-    : CurrentIndex(&NI), IsLocal(true), Key(std::string(Key)) {
-  if (!findInCurrentIndex())
-    setEnd();
-}
-
-iterator_range<DWARFDebugNames::ValueIterator>
-DWARFDebugNames::equal_range(StringRef Key) const {
-  if (NameIndices.empty())
-    return make_range(ValueIterator(), ValueIterator());
-  return make_range(ValueIterator(*this, Key), ValueIterator());
-}
-
-const DWARFDebugNames::NameIndex *
-DWARFDebugNames::getCUNameIndex(uint64_t CUOffset) {
-  if (CUToNameIndex.size() == 0 && NameIndices.size() > 0) {
-    for (const auto &NI : *this) {
-      for (uint32_t CU = 0; CU < NI.getCUCount(); ++CU)
-        CUToNameIndex.try_emplace(NI.getCUOffset(CU), &NI);
-    }
-  }
-  return CUToNameIndex.lookup(CUOffset);
-}
+//===- DWARFAcceleratorTable.cpp ------------------------------------------===// 
+// 
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
+// See https://llvm.org/LICENSE.txt for license information. 
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h" 
+ 
+#include "llvm/ADT/SmallVector.h" 
+#include "llvm/BinaryFormat/Dwarf.h" 
+#include "llvm/DebugInfo/DWARF/DWARFRelocMap.h" 
+#include "llvm/Support/Compiler.h" 
+#include "llvm/Support/DJB.h" 
+#include "llvm/Support/Errc.h" 
+#include "llvm/Support/Format.h" 
+#include "llvm/Support/FormatVariadic.h" 
+#include "llvm/Support/ScopedPrinter.h" 
+#include "llvm/Support/raw_ostream.h" 
+#include <cstddef> 
+#include <cstdint> 
+#include <utility> 
+ 
+using namespace llvm; 
+ 
+namespace { 
+struct Atom { 
+  unsigned Value; 
+}; 
+ 
+static raw_ostream &operator<<(raw_ostream &OS, const Atom &A) { 
+  StringRef Str = dwarf::AtomTypeString(A.Value); 
+  if (!Str.empty()) 
+    return OS << Str; 
+  return OS << "DW_ATOM_unknown_" << format("%x", A.Value); 
+} 
+} // namespace 
+ 
+static Atom formatAtom(unsigned Atom) { return {Atom}; } 
+ 
+DWARFAcceleratorTable::~DWARFAcceleratorTable() = default; 
+ 
+Error AppleAcceleratorTable::extract() { 
+  uint64_t Offset = 0; 
+ 
+  // Check that we can at least read the header. 
+  if (!AccelSection.isValidOffset(offsetof(Header, HeaderDataLength) + 4)) 
+    return createStringError(errc::illegal_byte_sequence, 
+                             "Section too small: cannot read header."); 
+ 
+  Hdr.Magic = AccelSection.getU32(&Offset); 
+  Hdr.Version = AccelSection.getU16(&Offset); 
+  Hdr.HashFunction = AccelSection.getU16(&Offset); 
+  Hdr.BucketCount = AccelSection.getU32(&Offset); 
+  Hdr.HashCount = AccelSection.getU32(&Offset); 
+  Hdr.HeaderDataLength = AccelSection.getU32(&Offset); 
+ 
+  // Check that we can read all the hashes and offsets from the 
+  // section (see SourceLevelDebugging.rst for the structure of the index). 
+  // We need to substract one because we're checking for an *offset* which is 
+  // equal to the size for an empty table and hence pointer after the section. 
+  if (!AccelSection.isValidOffset(sizeof(Hdr) + Hdr.HeaderDataLength + 
+                                  Hdr.BucketCount * 4 + Hdr.HashCount * 8 - 1)) 
+    return createStringError( 
+        errc::illegal_byte_sequence, 
+        "Section too small: cannot read buckets and hashes."); 
+ 
+  HdrData.DIEOffsetBase = AccelSection.getU32(&Offset); 
+  uint32_t NumAtoms = AccelSection.getU32(&Offset); 
+ 
+  for (unsigned i = 0; i < NumAtoms; ++i) { 
+    uint16_t AtomType = AccelSection.getU16(&Offset); 
+    auto AtomForm = static_cast<dwarf::Form>(AccelSection.getU16(&Offset)); 
+    HdrData.Atoms.push_back(std::make_pair(AtomType, AtomForm)); 
+  } 
+ 
+  IsValid = true; 
+  return Error::success(); 
+} 
+ 
+uint32_t AppleAcceleratorTable::getNumBuckets() { return Hdr.BucketCount; } 
+uint32_t AppleAcceleratorTable::getNumHashes() { return Hdr.HashCount; } 
+uint32_t AppleAcceleratorTable::getSizeHdr() { return sizeof(Hdr); } 
+uint32_t AppleAcceleratorTable::getHeaderDataLength() { 
+  return Hdr.HeaderDataLength; 
+} 
+ 
+ArrayRef<std::pair<AppleAcceleratorTable::HeaderData::AtomType, 
+                   AppleAcceleratorTable::HeaderData::Form>> 
+AppleAcceleratorTable::getAtomsDesc() { 
+  return HdrData.Atoms; 
+} 
+ 
+bool AppleAcceleratorTable::validateForms() { 
+  for (auto Atom : getAtomsDesc()) { 
+    DWARFFormValue FormValue(Atom.second); 
+    switch (Atom.first) { 
+    case dwarf::DW_ATOM_die_offset: 
+    case dwarf::DW_ATOM_die_tag: 
+    case dwarf::DW_ATOM_type_flags: 
+      if ((!FormValue.isFormClass(DWARFFormValue::FC_Constant) && 
+           !FormValue.isFormClass(DWARFFormValue::FC_Flag)) || 
+          FormValue.getForm() == dwarf::DW_FORM_sdata) 
+        return false; 
+      break; 
+    default: 
+      break; 
+    } 
+  } 
+  return true; 
+} 
+ 
+std::pair<uint64_t, dwarf::Tag> 
+AppleAcceleratorTable::readAtoms(uint64_t *HashDataOffset) { 
+  uint64_t DieOffset = dwarf::DW_INVALID_OFFSET; 
+  dwarf::Tag DieTag = dwarf::DW_TAG_null; 
+  dwarf::FormParams FormParams = {Hdr.Version, 0, dwarf::DwarfFormat::DWARF32}; 
+ 
+  for (auto Atom : getAtomsDesc()) { 
+    DWARFFormValue FormValue(Atom.second); 
+    FormValue.extractValue(AccelSection, HashDataOffset, FormParams); 
+    switch (Atom.first) { 
+    case dwarf::DW_ATOM_die_offset: 
+      DieOffset = *FormValue.getAsUnsignedConstant(); 
+      break; 
+    case dwarf::DW_ATOM_die_tag: 
+      DieTag = (dwarf::Tag)*FormValue.getAsUnsignedConstant(); 
+      break; 
+    default: 
+      break; 
+    } 
+  } 
+  return {DieOffset, DieTag}; 
+} 
+ 
+void AppleAcceleratorTable::Header::dump(ScopedPrinter &W) const { 
+  DictScope HeaderScope(W, "Header"); 
+  W.printHex("Magic", Magic); 
+  W.printHex("Version", Version); 
+  W.printHex("Hash function", HashFunction); 
+  W.printNumber("Bucket count", BucketCount); 
+  W.printNumber("Hashes count", HashCount); 
+  W.printNumber("HeaderData length", HeaderDataLength); 
+} 
+ 
+Optional<uint64_t> AppleAcceleratorTable::HeaderData::extractOffset( 
+    Optional<DWARFFormValue> Value) const { 
+  if (!Value) 
+    return None; 
+ 
+  switch (Value->getForm()) { 
+  case dwarf::DW_FORM_ref1: 
+  case dwarf::DW_FORM_ref2: 
+  case dwarf::DW_FORM_ref4: 
+  case dwarf::DW_FORM_ref8: 
+  case dwarf::DW_FORM_ref_udata: 
+    return Value->getRawUValue() + DIEOffsetBase; 
+  default: 
+    return Value->getAsSectionOffset(); 
+  } 
+} 
+ 
+bool AppleAcceleratorTable::dumpName(ScopedPrinter &W, 
+                                     SmallVectorImpl<DWARFFormValue> &AtomForms, 
+                                     uint64_t *DataOffset) const { 
+  dwarf::FormParams FormParams = {Hdr.Version, 0, dwarf::DwarfFormat::DWARF32}; 
+  uint64_t NameOffset = *DataOffset; 
+  if (!AccelSection.isValidOffsetForDataOfSize(*DataOffset, 4)) { 
+    W.printString("Incorrectly terminated list."); 
+    return false; 
+  } 
+  uint64_t StringOffset = AccelSection.getRelocatedValue(4, DataOffset); 
+  if (!StringOffset) 
+    return false; // End of list 
+ 
+  DictScope NameScope(W, ("Name@0x" + Twine::utohexstr(NameOffset)).str()); 
+  W.startLine() << format("String: 0x%08" PRIx64, StringOffset); 
+  W.getOStream() << " \"" << StringSection.getCStr(&StringOffset) << "\"\n"; 
+ 
+  unsigned NumData = AccelSection.getU32(DataOffset); 
+  for (unsigned Data = 0; Data < NumData; ++Data) { 
+    ListScope DataScope(W, ("Data " + Twine(Data)).str()); 
+    unsigned i = 0; 
+    for (auto &Atom : AtomForms) { 
+      W.startLine() << format("Atom[%d]: ", i); 
+      if (Atom.extractValue(AccelSection, DataOffset, FormParams)) { 
+        Atom.dump(W.getOStream()); 
+        if (Optional<uint64_t> Val = Atom.getAsUnsignedConstant()) { 
+          StringRef Str = dwarf::AtomValueString(HdrData.Atoms[i].first, *Val); 
+          if (!Str.empty()) 
+            W.getOStream() << " (" << Str << ")"; 
+        } 
+      } else 
+        W.getOStream() << "Error extracting the value"; 
+      W.getOStream() << "\n"; 
+      i++; 
+    } 
+  } 
+  return true; // more entries follow 
+} 
+ 
+LLVM_DUMP_METHOD void AppleAcceleratorTable::dump(raw_ostream &OS) const { 
+  if (!IsValid) 
+    return; 
+ 
+  ScopedPrinter W(OS); 
+ 
+  Hdr.dump(W); 
+ 
+  W.printNumber("DIE offset base", HdrData.DIEOffsetBase); 
+  W.printNumber("Number of atoms", uint64_t(HdrData.Atoms.size())); 
+  SmallVector<DWARFFormValue, 3> AtomForms; 
+  { 
+    ListScope AtomsScope(W, "Atoms"); 
+    unsigned i = 0; 
+    for (const auto &Atom : HdrData.Atoms) { 
+      DictScope AtomScope(W, ("Atom " + Twine(i++)).str()); 
+      W.startLine() << "Type: " << formatAtom(Atom.first) << '\n'; 
+      W.startLine() << "Form: " << formatv("{0}", Atom.second) << '\n'; 
+      AtomForms.push_back(DWARFFormValue(Atom.second)); 
+    } 
+  } 
+ 
+  // Now go through the actual tables and dump them. 
+  uint64_t Offset = sizeof(Hdr) + Hdr.HeaderDataLength; 
+  uint64_t HashesBase = Offset + Hdr.BucketCount * 4; 
+  uint64_t OffsetsBase = HashesBase + Hdr.HashCount * 4; 
+ 
+  for (unsigned Bucket = 0; Bucket < Hdr.BucketCount; ++Bucket) { 
+    unsigned Index = AccelSection.getU32(&Offset); 
+ 
+    ListScope BucketScope(W, ("Bucket " + Twine(Bucket)).str()); 
+    if (Index == UINT32_MAX) { 
+      W.printString("EMPTY"); 
+      continue; 
+    } 
+ 
+    for (unsigned HashIdx = Index; HashIdx < Hdr.HashCount; ++HashIdx) { 
+      uint64_t HashOffset = HashesBase + HashIdx*4; 
+      uint64_t OffsetsOffset = OffsetsBase + HashIdx*4; 
+      uint32_t Hash = AccelSection.getU32(&HashOffset); 
+ 
+      if (Hash % Hdr.BucketCount != Bucket) 
+        break; 
+ 
+      uint64_t DataOffset = AccelSection.getU32(&OffsetsOffset); 
+      ListScope HashScope(W, ("Hash 0x" + Twine::utohexstr(Hash)).str()); 
+      if (!AccelSection.isValidOffset(DataOffset)) { 
+        W.printString("Invalid section offset"); 
+        continue; 
+      } 
+      while (dumpName(W, AtomForms, &DataOffset)) 
+        /*empty*/; 
+    } 
+  } 
+} 
+ 
+AppleAcceleratorTable::Entry::Entry( 
+    const AppleAcceleratorTable::HeaderData &HdrData) 
+    : HdrData(&HdrData) { 
+  Values.reserve(HdrData.Atoms.size()); 
+  for (const auto &Atom : HdrData.Atoms) 
+    Values.push_back(DWARFFormValue(Atom.second)); 
+} 
+ 
+void AppleAcceleratorTable::Entry::extract( 
+    const AppleAcceleratorTable &AccelTable, uint64_t *Offset) { 
+ 
+  dwarf::FormParams FormParams = {AccelTable.Hdr.Version, 0, 
+                                  dwarf::DwarfFormat::DWARF32}; 
+  for (auto &Atom : Values) 
+    Atom.extractValue(AccelTable.AccelSection, Offset, FormParams); 
+} 
+ 
+Optional<DWARFFormValue> 
+AppleAcceleratorTable::Entry::lookup(HeaderData::AtomType Atom) const { 
+  assert(HdrData && "Dereferencing end iterator?"); 
+  assert(HdrData->Atoms.size() == Values.size()); 
+  for (auto Tuple : zip_first(HdrData->Atoms, Values)) { 
+    if (std::get<0>(Tuple).first == Atom) 
+      return std::get<1>(Tuple); 
+  } 
+  return None; 
+} 
+ 
+Optional<uint64_t> AppleAcceleratorTable::Entry::getDIESectionOffset() const { 
+  return HdrData->extractOffset(lookup(dwarf::DW_ATOM_die_offset)); 
+} 
+ 
+Optional<uint64_t> AppleAcceleratorTable::Entry::getCUOffset() const { 
+  return HdrData->extractOffset(lookup(dwarf::DW_ATOM_cu_offset)); 
+} 
+ 
+Optional<dwarf::Tag> AppleAcceleratorTable::Entry::getTag() const { 
+  Optional<DWARFFormValue> Tag = lookup(dwarf::DW_ATOM_die_tag); 
+  if (!Tag) 
+    return None; 
+  if (Optional<uint64_t> Value = Tag->getAsUnsignedConstant()) 
+    return dwarf::Tag(*Value); 
+  return None; 
+} 
+ 
+AppleAcceleratorTable::ValueIterator::ValueIterator( 
+    const AppleAcceleratorTable &AccelTable, uint64_t Offset) 
+    : AccelTable(&AccelTable), Current(AccelTable.HdrData), DataOffset(Offset) { 
+  if (!AccelTable.AccelSection.isValidOffsetForDataOfSize(DataOffset, 4)) 
+    return; 
+ 
+  // Read the first entry. 
+  NumData = AccelTable.AccelSection.getU32(&DataOffset); 
+  Next(); 
+} 
+ 
+void AppleAcceleratorTable::ValueIterator::Next() { 
+  assert(NumData > 0 && "attempted to increment iterator past the end"); 
+  auto &AccelSection = AccelTable->AccelSection; 
+  if (Data >= NumData || 
+      !AccelSection.isValidOffsetForDataOfSize(DataOffset, 4)) { 
+    NumData = 0; 
+    DataOffset = 0; 
+    return; 
+  } 
+  Current.extract(*AccelTable, &DataOffset); 
+  ++Data; 
+} 
+ 
+iterator_range<AppleAcceleratorTable::ValueIterator> 
+AppleAcceleratorTable::equal_range(StringRef Key) const { 
+  if (!IsValid) 
+    return make_range(ValueIterator(), ValueIterator()); 
+ 
+  // Find the bucket. 
+  unsigned HashValue = djbHash(Key); 
+  unsigned Bucket = HashValue % Hdr.BucketCount; 
+  uint64_t BucketBase = sizeof(Hdr) + Hdr.HeaderDataLength; 
+  uint64_t HashesBase = BucketBase + Hdr.BucketCount * 4; 
+  uint64_t OffsetsBase = HashesBase + Hdr.HashCount * 4; 
+ 
+  uint64_t BucketOffset = BucketBase + Bucket * 4; 
+  unsigned Index = AccelSection.getU32(&BucketOffset); 
+ 
+  // Search through all hashes in the bucket. 
+  for (unsigned HashIdx = Index; HashIdx < Hdr.HashCount; ++HashIdx) { 
+    uint64_t HashOffset = HashesBase + HashIdx * 4; 
+    uint64_t OffsetsOffset = OffsetsBase + HashIdx * 4; 
+    uint32_t Hash = AccelSection.getU32(&HashOffset); 
+ 
+    if (Hash % Hdr.BucketCount != Bucket) 
+      // We are already in the next bucket. 
+      break; 
+ 
+    uint64_t DataOffset = AccelSection.getU32(&OffsetsOffset); 
+    uint64_t StringOffset = AccelSection.getRelocatedValue(4, &DataOffset); 
+    if (!StringOffset) 
+      break; 
+ 
+    // Finally, compare the key. 
+    if (Key == StringSection.getCStr(&StringOffset)) 
+      return make_range({*this, DataOffset}, ValueIterator()); 
+  } 
+  return make_range(ValueIterator(), ValueIterator()); 
+} 
+ 
+void DWARFDebugNames::Header::dump(ScopedPrinter &W) const { 
+  DictScope HeaderScope(W, "Header"); 
+  W.printHex("Length", UnitLength); 
+  W.printString("Format", dwarf::FormatString(Format)); 
+  W.printNumber("Version", Version); 
+  W.printNumber("CU count", CompUnitCount); 
+  W.printNumber("Local TU count", LocalTypeUnitCount); 
+  W.printNumber("Foreign TU count", ForeignTypeUnitCount); 
+  W.printNumber("Bucket count", BucketCount); 
+  W.printNumber("Name count", NameCount); 
+  W.printHex("Abbreviations table size", AbbrevTableSize); 
+  W.startLine() << "Augmentation: '" << AugmentationString << "'\n"; 
+} 
+ 
+Error DWARFDebugNames::Header::extract(const DWARFDataExtractor &AS, 
+                                             uint64_t *Offset) { 
+  auto HeaderError = [Offset = *Offset](Error E) { 
+    return createStringError(errc::illegal_byte_sequence, 
+                             "parsing .debug_names header at 0x%" PRIx64 ": %s", 
+                             Offset, toString(std::move(E)).c_str()); 
+  }; 
+ 
+  DataExtractor::Cursor C(*Offset); 
+  std::tie(UnitLength, Format) = AS.getInitialLength(C); 
+ 
+  Version = AS.getU16(C); 
+  AS.skip(C, 2); // padding 
+  CompUnitCount = AS.getU32(C); 
+  LocalTypeUnitCount = AS.getU32(C); 
+  ForeignTypeUnitCount = AS.getU32(C); 
+  BucketCount = AS.getU32(C); 
+  NameCount = AS.getU32(C); 
+  AbbrevTableSize = AS.getU32(C); 
+  AugmentationStringSize = alignTo(AS.getU32(C), 4); 
+ 
+  if (!C) 
+    return HeaderError(C.takeError()); 
+ 
+  if (!AS.isValidOffsetForDataOfSize(C.tell(), AugmentationStringSize)) 
+    return HeaderError(createStringError(errc::illegal_byte_sequence, 
+                                         "cannot read header augmentation")); 
+  AugmentationString.resize(AugmentationStringSize); 
+  AS.getU8(C, reinterpret_cast<uint8_t *>(AugmentationString.data()), 
+           AugmentationStringSize); 
+  *Offset = C.tell(); 
+  return C.takeError(); 
+} 
+ 
+void DWARFDebugNames::Abbrev::dump(ScopedPrinter &W) const { 
+  DictScope AbbrevScope(W, ("Abbreviation 0x" + Twine::utohexstr(Code)).str()); 
+  W.startLine() << formatv("Tag: {0}\n", Tag); 
+ 
+  for (const auto &Attr : Attributes) 
+    W.startLine() << formatv("{0}: {1}\n", Attr.Index, Attr.Form); 
+} 
+ 
+static constexpr DWARFDebugNames::AttributeEncoding sentinelAttrEnc() { 
+  return {dwarf::Index(0), dwarf::Form(0)}; 
+} 
+ 
+static bool isSentinel(const DWARFDebugNames::AttributeEncoding &AE) { 
+  return AE == sentinelAttrEnc(); 
+} 
+ 
+static DWARFDebugNames::Abbrev sentinelAbbrev() { 
+  return DWARFDebugNames::Abbrev(0, dwarf::Tag(0), {}); 
+} 
+ 
+static bool isSentinel(const DWARFDebugNames::Abbrev &Abbr) { 
+  return Abbr.Code == 0; 
+} 
+ 
+DWARFDebugNames::Abbrev DWARFDebugNames::AbbrevMapInfo::getEmptyKey() { 
+  return sentinelAbbrev(); 
+} 
+ 
+DWARFDebugNames::Abbrev DWARFDebugNames::AbbrevMapInfo::getTombstoneKey() { 
+  return DWARFDebugNames::Abbrev(~0, dwarf::Tag(0), {}); 
+} 
+ 
+Expected<DWARFDebugNames::AttributeEncoding> 
+DWARFDebugNames::NameIndex::extractAttributeEncoding(uint64_t *Offset) { 
+  if (*Offset >= EntriesBase) { 
+    return createStringError(errc::illegal_byte_sequence, 
+                             "Incorrectly terminated abbreviation table."); 
+  } 
+ 
+  uint32_t Index = Section.AccelSection.getULEB128(Offset); 
+  uint32_t Form = Section.AccelSection.getULEB128(Offset); 
+  return AttributeEncoding(dwarf::Index(Index), dwarf::Form(Form)); 
+} 
+ 
+Expected<std::vector<DWARFDebugNames::AttributeEncoding>> 
+DWARFDebugNames::NameIndex::extractAttributeEncodings(uint64_t *Offset) { 
+  std::vector<AttributeEncoding> Result; 
+  for (;;) { 
+    auto AttrEncOr = extractAttributeEncoding(Offset); 
+    if (!AttrEncOr) 
+      return AttrEncOr.takeError(); 
+    if (isSentinel(*AttrEncOr)) 
+      return std::move(Result); 
+ 
+    Result.emplace_back(*AttrEncOr); 
+  } 
+} 
+ 
+Expected<DWARFDebugNames::Abbrev> 
+DWARFDebugNames::NameIndex::extractAbbrev(uint64_t *Offset) { 
+  if (*Offset >= EntriesBase) { 
+    return createStringError(errc::illegal_byte_sequence, 
+                             "Incorrectly terminated abbreviation table."); 
+  } 
+ 
+  uint32_t Code = Section.AccelSection.getULEB128(Offset); 
+  if (Code == 0) 
+    return sentinelAbbrev(); 
+ 
+  uint32_t Tag = Section.AccelSection.getULEB128(Offset); 
+  auto AttrEncOr = extractAttributeEncodings(Offset); 
+  if (!AttrEncOr) 
+    return AttrEncOr.takeError(); 
+  return Abbrev(Code, dwarf::Tag(Tag), std::move(*AttrEncOr)); 
+} 
+ 
+Error DWARFDebugNames::NameIndex::extract() { 
+  const DWARFDataExtractor &AS = Section.AccelSection; 
+  uint64_t Offset = Base; 
+  if (Error E = Hdr.extract(AS, &Offset)) 
+    return E; 
+ 
+  const unsigned SectionOffsetSize = dwarf::getDwarfOffsetByteSize(Hdr.Format); 
+  CUsBase = Offset; 
+  Offset += Hdr.CompUnitCount * SectionOffsetSize; 
+  Offset += Hdr.LocalTypeUnitCount * SectionOffsetSize; 
+  Offset += Hdr.ForeignTypeUnitCount * 8; 
+  BucketsBase = Offset; 
+  Offset += Hdr.BucketCount * 4; 
+  HashesBase = Offset; 
+  if (Hdr.BucketCount > 0) 
+    Offset += Hdr.NameCount * 4; 
+  StringOffsetsBase = Offset; 
+  Offset += Hdr.NameCount * SectionOffsetSize; 
+  EntryOffsetsBase = Offset; 
+  Offset += Hdr.NameCount * SectionOffsetSize; 
+ 
+  if (!AS.isValidOffsetForDataOfSize(Offset, Hdr.AbbrevTableSize)) 
+    return createStringError(errc::illegal_byte_sequence, 
+                             "Section too small: cannot read abbreviations."); 
+ 
+  EntriesBase = Offset + Hdr.AbbrevTableSize; 
+ 
+  for (;;) { 
+    auto AbbrevOr = extractAbbrev(&Offset); 
+    if (!AbbrevOr) 
+      return AbbrevOr.takeError(); 
+    if (isSentinel(*AbbrevOr)) 
+      return Error::success(); 
+ 
+    if (!Abbrevs.insert(std::move(*AbbrevOr)).second) 
+      return createStringError(errc::invalid_argument, 
+                               "Duplicate abbreviation code."); 
+  } 
+} 
+ 
+DWARFDebugNames::Entry::Entry(const NameIndex &NameIdx, const Abbrev &Abbr) 
+    : NameIdx(&NameIdx), Abbr(&Abbr) { 
+  // This merely creates form values. It is up to the caller 
+  // (NameIndex::getEntry) to populate them. 
+  Values.reserve(Abbr.Attributes.size()); 
+  for (const auto &Attr : Abbr.Attributes) 
+    Values.emplace_back(Attr.Form); 
+} 
+ 
+Optional<DWARFFormValue> 
+DWARFDebugNames::Entry::lookup(dwarf::Index Index) const { 
+  assert(Abbr->Attributes.size() == Values.size()); 
+  for (auto Tuple : zip_first(Abbr->Attributes, Values)) { 
+    if (std::get<0>(Tuple).Index == Index) 
+      return std::get<1>(Tuple); 
+  } 
+  return None; 
+} 
+ 
+Optional<uint64_t> DWARFDebugNames::Entry::getDIEUnitOffset() const { 
+  if (Optional<DWARFFormValue> Off = lookup(dwarf::DW_IDX_die_offset)) 
+    return Off->getAsReferenceUVal(); 
+  return None; 
+} 
+ 
+Optional<uint64_t> DWARFDebugNames::Entry::getCUIndex() const { 
+  if (Optional<DWARFFormValue> Off = lookup(dwarf::DW_IDX_compile_unit)) 
+    return Off->getAsUnsignedConstant(); 
+  // In a per-CU index, the entries without a DW_IDX_compile_unit attribute 
+  // implicitly refer to the single CU. 
+  if (NameIdx->getCUCount() == 1) 
+    return 0; 
+  return None; 
+} 
+ 
+Optional<uint64_t> DWARFDebugNames::Entry::getCUOffset() const { 
+  Optional<uint64_t> Index = getCUIndex(); 
+  if (!Index || *Index >= NameIdx->getCUCount()) 
+    return None; 
+  return NameIdx->getCUOffset(*Index); 
+} 
+ 
+void DWARFDebugNames::Entry::dump(ScopedPrinter &W) const { 
+  W.printHex("Abbrev", Abbr->Code); 
+  W.startLine() << formatv("Tag: {0}\n", Abbr->Tag); 
+  assert(Abbr->Attributes.size() == Values.size()); 
+  for (auto Tuple : zip_first(Abbr->Attributes, Values)) { 
+    W.startLine() << formatv("{0}: ", std::get<0>(Tuple).Index); 
+    std::get<1>(Tuple).dump(W.getOStream()); 
+    W.getOStream() << '\n'; 
+  } 
+} 
+ 
+char DWARFDebugNames::SentinelError::ID; 
+std::error_code DWARFDebugNames::SentinelError::convertToErrorCode() const { 
+  return inconvertibleErrorCode(); 
+} 
+ 
+uint64_t DWARFDebugNames::NameIndex::getCUOffset(uint32_t CU) const { 
+  assert(CU < Hdr.CompUnitCount); 
+  const unsigned SectionOffsetSize = dwarf::getDwarfOffsetByteSize(Hdr.Format); 
+  uint64_t Offset = CUsBase + SectionOffsetSize * CU; 
+  return Section.AccelSection.getRelocatedValue(SectionOffsetSize, &Offset); 
+} 
+ 
+uint64_t DWARFDebugNames::NameIndex::getLocalTUOffset(uint32_t TU) const { 
+  assert(TU < Hdr.LocalTypeUnitCount); 
+  const unsigned SectionOffsetSize = dwarf::getDwarfOffsetByteSize(Hdr.Format); 
+  uint64_t Offset = CUsBase + SectionOffsetSize * (Hdr.CompUnitCount + TU); 
+  return Section.AccelSection.getRelocatedValue(SectionOffsetSize, &Offset); 
+} 
+ 
+uint64_t DWARFDebugNames::NameIndex::getForeignTUSignature(uint32_t TU) const { 
+  assert(TU < Hdr.ForeignTypeUnitCount); 
+  const unsigned SectionOffsetSize = dwarf::getDwarfOffsetByteSize(Hdr.Format); 
+  uint64_t Offset = 
+      CUsBase + 
+      SectionOffsetSize * (Hdr.CompUnitCount + Hdr.LocalTypeUnitCount) + 8 * TU; 
+  return Section.AccelSection.getU64(&Offset); 
+} 
+ 
+Expected<DWARFDebugNames::Entry> 
+DWARFDebugNames::NameIndex::getEntry(uint64_t *Offset) const { 
+  const DWARFDataExtractor &AS = Section.AccelSection; 
+  if (!AS.isValidOffset(*Offset)) 
+    return createStringError(errc::illegal_byte_sequence, 
+                             "Incorrectly terminated entry list."); 
+ 
+  uint32_t AbbrevCode = AS.getULEB128(Offset); 
+  if (AbbrevCode == 0) 
+    return make_error<SentinelError>(); 
+ 
+  const auto AbbrevIt = Abbrevs.find_as(AbbrevCode); 
+  if (AbbrevIt == Abbrevs.end()) 
+    return createStringError(errc::invalid_argument, "Invalid abbreviation."); 
+ 
+  Entry E(*this, *AbbrevIt); 
+ 
+  dwarf::FormParams FormParams = {Hdr.Version, 0, Hdr.Format}; 
+  for (auto &Value : E.Values) { 
+    if (!Value.extractValue(AS, Offset, FormParams)) 
+      return createStringError(errc::io_error, 
+                               "Error extracting index attribute values."); 
+  } 
+  return std::move(E); 
+} 
+ 
+DWARFDebugNames::NameTableEntry 
+DWARFDebugNames::NameIndex::getNameTableEntry(uint32_t Index) const { 
+  assert(0 < Index && Index <= Hdr.NameCount); 
+  const unsigned SectionOffsetSize = dwarf::getDwarfOffsetByteSize(Hdr.Format); 
+  uint64_t StringOffsetOffset = 
+      StringOffsetsBase + SectionOffsetSize * (Index - 1); 
+  uint64_t EntryOffsetOffset = 
+      EntryOffsetsBase + SectionOffsetSize * (Index - 1); 
+  const DWARFDataExtractor &AS = Section.AccelSection; 
+ 
+  uint64_t StringOffset = 
+      AS.getRelocatedValue(SectionOffsetSize, &StringOffsetOffset); 
+  uint64_t EntryOffset = AS.getUnsigned(&EntryOffsetOffset, SectionOffsetSize); 
+  EntryOffset += EntriesBase; 
+  return {Section.StringSection, Index, StringOffset, EntryOffset}; 
+} 
+ 
+uint32_t 
+DWARFDebugNames::NameIndex::getBucketArrayEntry(uint32_t Bucket) const { 
+  assert(Bucket < Hdr.BucketCount); 
+  uint64_t BucketOffset = BucketsBase + 4 * Bucket; 
+  return Section.AccelSection.getU32(&BucketOffset); 
+} 
+ 
+uint32_t DWARFDebugNames::NameIndex::getHashArrayEntry(uint32_t Index) const { 
+  assert(0 < Index && Index <= Hdr.NameCount); 
+  uint64_t HashOffset = HashesBase + 4 * (Index - 1); 
+  return Section.AccelSection.getU32(&HashOffset); 
+} 
+ 
+// Returns true if we should continue scanning for entries, false if this is the 
+// last (sentinel) entry). In case of a parsing error we also return false, as 
+// it's not possible to recover this entry list (but the other lists may still 
+// parse OK). 
+bool DWARFDebugNames::NameIndex::dumpEntry(ScopedPrinter &W, 
+                                           uint64_t *Offset) const { 
+  uint64_t EntryId = *Offset; 
+  auto EntryOr = getEntry(Offset); 
+  if (!EntryOr) { 
+    handleAllErrors(EntryOr.takeError(), [](const SentinelError &) {}, 
+                    [&W](const ErrorInfoBase &EI) { EI.log(W.startLine()); }); 
+    return false; 
+  } 
+ 
+  DictScope EntryScope(W, ("Entry @ 0x" + Twine::utohexstr(EntryId)).str()); 
+  EntryOr->dump(W); 
+  return true; 
+} 
+ 
+void DWARFDebugNames::NameIndex::dumpName(ScopedPrinter &W, 
+                                          const NameTableEntry &NTE, 
+                                          Optional<uint32_t> Hash) const { 
+  DictScope NameScope(W, ("Name " + Twine(NTE.getIndex())).str()); 
+  if (Hash) 
+    W.printHex("Hash", *Hash); 
+ 
+  W.startLine() << format("String: 0x%08" PRIx64, NTE.getStringOffset()); 
+  W.getOStream() << " \"" << NTE.getString() << "\"\n"; 
+ 
+  uint64_t EntryOffset = NTE.getEntryOffset(); 
+  while (dumpEntry(W, &EntryOffset)) 
+    /*empty*/; 
+} 
+ 
+void DWARFDebugNames::NameIndex::dumpCUs(ScopedPrinter &W) const { 
+  ListScope CUScope(W, "Compilation Unit offsets"); 
+  for (uint32_t CU = 0; CU < Hdr.CompUnitCount; ++CU) 
+    W.startLine() << format("CU[%u]: 0x%08" PRIx64 "\n", CU, getCUOffset(CU)); 
+} 
+ 
+void DWARFDebugNames::NameIndex::dumpLocalTUs(ScopedPrinter &W) const { 
+  if (Hdr.LocalTypeUnitCount == 0) 
+    return; 
+ 
+  ListScope TUScope(W, "Local Type Unit offsets"); 
+  for (uint32_t TU = 0; TU < Hdr.LocalTypeUnitCount; ++TU) 
+    W.startLine() << format("LocalTU[%u]: 0x%08" PRIx64 "\n", TU, 
+                            getLocalTUOffset(TU)); 
+} 
+ 
+void DWARFDebugNames::NameIndex::dumpForeignTUs(ScopedPrinter &W) const { 
+  if (Hdr.ForeignTypeUnitCount == 0) 
+    return; 
+ 
+  ListScope TUScope(W, "Foreign Type Unit signatures"); 
+  for (uint32_t TU = 0; TU < Hdr.ForeignTypeUnitCount; ++TU) { 
+    W.startLine() << format("ForeignTU[%u]: 0x%016" PRIx64 "\n", TU, 
+                            getForeignTUSignature(TU)); 
+  } 
+} 
+ 
+void DWARFDebugNames::NameIndex::dumpAbbreviations(ScopedPrinter &W) const { 
+  ListScope AbbrevsScope(W, "Abbreviations"); 
+  for (const auto &Abbr : Abbrevs) 
+    Abbr.dump(W); 
+} 
+ 
+void DWARFDebugNames::NameIndex::dumpBucket(ScopedPrinter &W, 
+                                            uint32_t Bucket) const { 
+  ListScope BucketScope(W, ("Bucket " + Twine(Bucket)).str()); 
+  uint32_t Index = getBucketArrayEntry(Bucket); 
+  if (Index == 0) { 
+    W.printString("EMPTY"); 
+    return; 
+  } 
+  if (Index > Hdr.NameCount) { 
+    W.printString("Name index is invalid"); 
+    return; 
+  } 
+ 
+  for (; Index <= Hdr.NameCount; ++Index) { 
+    uint32_t Hash = getHashArrayEntry(Index); 
+    if (Hash % Hdr.BucketCount != Bucket) 
+      break; 
+ 
+    dumpName(W, getNameTableEntry(Index), Hash); 
+  } 
+} 
+ 
+LLVM_DUMP_METHOD void DWARFDebugNames::NameIndex::dump(ScopedPrinter &W) const { 
+  DictScope UnitScope(W, ("Name Index @ 0x" + Twine::utohexstr(Base)).str()); 
+  Hdr.dump(W); 
+  dumpCUs(W); 
+  dumpLocalTUs(W); 
+  dumpForeignTUs(W); 
+  dumpAbbreviations(W); 
+ 
+  if (Hdr.BucketCount > 0) { 
+    for (uint32_t Bucket = 0; Bucket < Hdr.BucketCount; ++Bucket) 
+      dumpBucket(W, Bucket); 
+    return; 
+  } 
+ 
+  W.startLine() << "Hash table not present\n"; 
+  for (NameTableEntry NTE : *this) 
+    dumpName(W, NTE, None); 
+} 
+ 
+Error DWARFDebugNames::extract() { 
+  uint64_t Offset = 0; 
+  while (AccelSection.isValidOffset(Offset)) { 
+    NameIndex Next(*this, Offset); 
+    if (Error E = Next.extract()) 
+      return E; 
+    Offset = Next.getNextUnitOffset(); 
+    NameIndices.push_back(std::move(Next)); 
+  } 
+  return Error::success(); 
+} 
+ 
+iterator_range<DWARFDebugNames::ValueIterator> 
+DWARFDebugNames::NameIndex::equal_range(StringRef Key) const { 
+  return make_range(ValueIterator(*this, Key), ValueIterator()); 
+} 
+ 
+LLVM_DUMP_METHOD void DWARFDebugNames::dump(raw_ostream &OS) const { 
+  ScopedPrinter W(OS); 
+  for (const NameIndex &NI : NameIndices) 
+    NI.dump(W); 
+} 
+ 
+Optional<uint64_t> 
+DWARFDebugNames::ValueIterator::findEntryOffsetInCurrentIndex() { 
+  const Header &Hdr = CurrentIndex->Hdr; 
+  if (Hdr.BucketCount == 0) { 
+    // No Hash Table, We need to search through all names in the Name Index. 
+    for (NameTableEntry NTE : *CurrentIndex) { 
+      if (NTE.getString() == Key) 
+        return NTE.getEntryOffset(); 
+    } 
+    return None; 
+  } 
+ 
+  // The Name Index has a Hash Table, so use that to speed up the search. 
+  // Compute the Key Hash, if it has not been done already. 
+  if (!Hash) 
+    Hash = caseFoldingDjbHash(Key); 
+  uint32_t Bucket = *Hash % Hdr.BucketCount; 
+  uint32_t Index = CurrentIndex->getBucketArrayEntry(Bucket); 
+  if (Index == 0) 
+    return None; // Empty bucket 
+ 
+  for (; Index <= Hdr.NameCount; ++Index) { 
+    uint32_t Hash = CurrentIndex->getHashArrayEntry(Index); 
+    if (Hash % Hdr.BucketCount != Bucket) 
+      return None; // End of bucket 
+ 
+    NameTableEntry NTE = CurrentIndex->getNameTableEntry(Index); 
+    if (NTE.getString() == Key) 
+      return NTE.getEntryOffset(); 
+  } 
+  return None; 
+} 
+ 
+bool DWARFDebugNames::ValueIterator::getEntryAtCurrentOffset() { 
+  auto EntryOr = CurrentIndex->getEntry(&DataOffset); 
+  if (!EntryOr) { 
+    consumeError(EntryOr.takeError()); 
+    return false; 
+  } 
+  CurrentEntry = std::move(*EntryOr); 
+  return true; 
+} 
+ 
+bool DWARFDebugNames::ValueIterator::findInCurrentIndex() { 
+  Optional<uint64_t> Offset = findEntryOffsetInCurrentIndex(); 
+  if (!Offset) 
+    return false; 
+  DataOffset = *Offset; 
+  return getEntryAtCurrentOffset(); 
+} 
+ 
+void DWARFDebugNames::ValueIterator::searchFromStartOfCurrentIndex() { 
+  for (const NameIndex *End = CurrentIndex->Section.NameIndices.end(); 
+       CurrentIndex != End; ++CurrentIndex) { 
+    if (findInCurrentIndex()) 
+      return; 
+  } 
+  setEnd(); 
+} 
+ 
+void DWARFDebugNames::ValueIterator::next() { 
+  assert(CurrentIndex && "Incrementing an end() iterator?"); 
+ 
+  // First try the next entry in the current Index. 
+  if (getEntryAtCurrentOffset()) 
+    return; 
+ 
+  // If we're a local iterator or we have reached the last Index, we're done. 
+  if (IsLocal || CurrentIndex == &CurrentIndex->Section.NameIndices.back()) { 
+    setEnd(); 
+    return; 
+  } 
+ 
+  // Otherwise, try the next index. 
+  ++CurrentIndex; 
+  searchFromStartOfCurrentIndex(); 
+} 
+ 
+DWARFDebugNames::ValueIterator::ValueIterator(const DWARFDebugNames &AccelTable, 
+                                              StringRef Key) 
+    : CurrentIndex(AccelTable.NameIndices.begin()), IsLocal(false), 
+      Key(std::string(Key)) { 
+  searchFromStartOfCurrentIndex(); 
+} 
+ 
+DWARFDebugNames::ValueIterator::ValueIterator( 
+    const DWARFDebugNames::NameIndex &NI, StringRef Key) 
+    : CurrentIndex(&NI), IsLocal(true), Key(std::string(Key)) { 
+  if (!findInCurrentIndex()) 
+    setEnd(); 
+} 
+ 
+iterator_range<DWARFDebugNames::ValueIterator> 
+DWARFDebugNames::equal_range(StringRef Key) const { 
+  if (NameIndices.empty()) 
+    return make_range(ValueIterator(), ValueIterator()); 
+  return make_range(ValueIterator(*this, Key), ValueIterator()); 
+} 
+ 
+const DWARFDebugNames::NameIndex * 
+DWARFDebugNames::getCUNameIndex(uint64_t CUOffset) { 
+  if (CUToNameIndex.size() == 0 && NameIndices.size() > 0) { 
+    for (const auto &NI : *this) { 
+      for (uint32_t CU = 0; CU < NI.getCUCount(); ++CU) 
+        CUToNameIndex.try_emplace(NI.getCUOffset(CU), &NI); 
+    } 
+  } 
+  return CUToNameIndex.lookup(CUOffset); 
+}