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

1 files changed, 1497 insertions, 1497 deletions

diff --git a/contrib/libs/llvm12/lib/DebugInfo/DWARF/DWARFVerifier.cpp b/contrib/libs/llvm12/lib/DebugInfo/DWARF/DWARFVerifier.cpp
index ac624ec8b8..ece067244e 100644
--- a/contrib/libs/llvm12/lib/DebugInfo/DWARF/DWARFVerifier.cpp
+++ b/contrib/libs/llvm12/lib/DebugInfo/DWARF/DWARFVerifier.cpp
@@ -1,177 +1,177 @@
-//===- DWARFVerifier.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/DWARFVerifier.h"
-#include "llvm/ADT/SmallSet.h"
-#include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
-#include "llvm/DebugInfo/DWARF/DWARFContext.h"
-#include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
-#include "llvm/DebugInfo/DWARF/DWARFDie.h"
-#include "llvm/DebugInfo/DWARF/DWARFExpression.h"
-#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
-#include "llvm/DebugInfo/DWARF/DWARFSection.h"
-#include "llvm/Support/DJB.h"
-#include "llvm/Support/FormatVariadic.h"
-#include "llvm/Support/WithColor.h"
-#include "llvm/Support/raw_ostream.h"
-#include <map>
-#include <set>
-#include <vector>
-
-using namespace llvm;
-using namespace dwarf;
-using namespace object;
-
-Optional<DWARFAddressRange>
-DWARFVerifier::DieRangeInfo::insert(const DWARFAddressRange &R) {
-  auto Begin = Ranges.begin();
-  auto End = Ranges.end();
-  auto Pos = std::lower_bound(Begin, End, R);
-
-  if (Pos != End) {
-    DWARFAddressRange Range(*Pos);
-    if (Pos->merge(R))
-      return Range;
-  }
-  if (Pos != Begin) {
-    auto Iter = Pos - 1;
-    DWARFAddressRange Range(*Iter);
-    if (Iter->merge(R))
-      return Range;
-  }
-
-  Ranges.insert(Pos, R);
-  return None;
-}
-
-DWARFVerifier::DieRangeInfo::die_range_info_iterator
-DWARFVerifier::DieRangeInfo::insert(const DieRangeInfo &RI) {
-  auto End = Children.end();
-  auto Iter = Children.begin();
-  while (Iter != End) {
-    if (Iter->intersects(RI))
-      return Iter;
-    ++Iter;
-  }
-  Children.insert(RI);
-  return Children.end();
-}
-
-bool DWARFVerifier::DieRangeInfo::contains(const DieRangeInfo &RHS) const {
-  auto I1 = Ranges.begin(), E1 = Ranges.end();
-  auto I2 = RHS.Ranges.begin(), E2 = RHS.Ranges.end();
-  if (I2 == E2)
-    return true;
-
-  DWARFAddressRange R = *I2;
-  while (I1 != E1) {
-    bool Covered = I1->LowPC <= R.LowPC;
-    if (R.LowPC == R.HighPC || (Covered && R.HighPC <= I1->HighPC)) {
-      if (++I2 == E2)
-        return true;
-      R = *I2;
-      continue;
-    }
-    if (!Covered)
-      return false;
-    if (R.LowPC < I1->HighPC)
-      R.LowPC = I1->HighPC;
-    ++I1;
-  }
-  return false;
-}
-
-bool DWARFVerifier::DieRangeInfo::intersects(const DieRangeInfo &RHS) const {
-  auto I1 = Ranges.begin(), E1 = Ranges.end();
-  auto I2 = RHS.Ranges.begin(), E2 = RHS.Ranges.end();
-  while (I1 != E1 && I2 != E2) {
-    if (I1->intersects(*I2))
-      return true;
-    if (I1->LowPC < I2->LowPC)
-      ++I1;
-    else
-      ++I2;
-  }
-  return false;
-}
-
-bool DWARFVerifier::verifyUnitHeader(const DWARFDataExtractor DebugInfoData,
-                                     uint64_t *Offset, unsigned UnitIndex,
-                                     uint8_t &UnitType, bool &isUnitDWARF64) {
-  uint64_t AbbrOffset, Length;
-  uint8_t AddrSize = 0;
-  uint16_t Version;
-  bool Success = true;
-
-  bool ValidLength = false;
-  bool ValidVersion = false;
-  bool ValidAddrSize = false;
-  bool ValidType = true;
-  bool ValidAbbrevOffset = true;
-
-  uint64_t OffsetStart = *Offset;
-  DwarfFormat Format;
-  std::tie(Length, Format) = DebugInfoData.getInitialLength(Offset);
-  isUnitDWARF64 = Format == DWARF64;
-  Version = DebugInfoData.getU16(Offset);
-
-  if (Version >= 5) {
-    UnitType = DebugInfoData.getU8(Offset);
-    AddrSize = DebugInfoData.getU8(Offset);
-    AbbrOffset = isUnitDWARF64 ? DebugInfoData.getU64(Offset) : DebugInfoData.getU32(Offset);
-    ValidType = dwarf::isUnitType(UnitType);
-  } else {
-    UnitType = 0;
-    AbbrOffset = isUnitDWARF64 ? DebugInfoData.getU64(Offset) : DebugInfoData.getU32(Offset);
-    AddrSize = DebugInfoData.getU8(Offset);
-  }
-
-  if (!DCtx.getDebugAbbrev()->getAbbreviationDeclarationSet(AbbrOffset))
-    ValidAbbrevOffset = false;
-
-  ValidLength = DebugInfoData.isValidOffset(OffsetStart + Length + 3);
-  ValidVersion = DWARFContext::isSupportedVersion(Version);
-  ValidAddrSize = DWARFContext::isAddressSizeSupported(AddrSize);
-  if (!ValidLength || !ValidVersion || !ValidAddrSize || !ValidAbbrevOffset ||
-      !ValidType) {
-    Success = false;
-    error() << format("Units[%d] - start offset: 0x%08" PRIx64 " \n", UnitIndex,
-                      OffsetStart);
-    if (!ValidLength)
-      note() << "The length for this unit is too "
-                "large for the .debug_info provided.\n";
-    if (!ValidVersion)
-      note() << "The 16 bit unit header version is not valid.\n";
-    if (!ValidType)
-      note() << "The unit type encoding is not valid.\n";
-    if (!ValidAbbrevOffset)
-      note() << "The offset into the .debug_abbrev section is "
-                "not valid.\n";
-    if (!ValidAddrSize)
-      note() << "The address size is unsupported.\n";
-  }
-  *Offset = OffsetStart + Length + (isUnitDWARF64 ? 12 : 4);
-  return Success;
-}
-
-unsigned DWARFVerifier::verifyUnitContents(DWARFUnit &Unit) {
-  unsigned NumUnitErrors = 0;
-  unsigned NumDies = Unit.getNumDIEs();
-  for (unsigned I = 0; I < NumDies; ++I) {
-    auto Die = Unit.getDIEAtIndex(I);
-
-    if (Die.getTag() == DW_TAG_null)
-      continue;
-
-    for (auto AttrValue : Die.attributes()) {
-      NumUnitErrors += verifyDebugInfoAttribute(Die, AttrValue);
-      NumUnitErrors += verifyDebugInfoForm(Die, AttrValue);
-    }
-
+//===- DWARFVerifier.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/DWARFVerifier.h" 
+#include "llvm/ADT/SmallSet.h" 
+#include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h" 
+#include "llvm/DebugInfo/DWARF/DWARFContext.h" 
+#include "llvm/DebugInfo/DWARF/DWARFDebugLine.h" 
+#include "llvm/DebugInfo/DWARF/DWARFDie.h" 
+#include "llvm/DebugInfo/DWARF/DWARFExpression.h" 
+#include "llvm/DebugInfo/DWARF/DWARFFormValue.h" 
+#include "llvm/DebugInfo/DWARF/DWARFSection.h" 
+#include "llvm/Support/DJB.h" 
+#include "llvm/Support/FormatVariadic.h" 
+#include "llvm/Support/WithColor.h" 
+#include "llvm/Support/raw_ostream.h" 
+#include <map> 
+#include <set> 
+#include <vector> 
+ 
+using namespace llvm; 
+using namespace dwarf; 
+using namespace object; 
+ 
+Optional<DWARFAddressRange> 
+DWARFVerifier::DieRangeInfo::insert(const DWARFAddressRange &R) { 
+  auto Begin = Ranges.begin(); 
+  auto End = Ranges.end(); 
+  auto Pos = std::lower_bound(Begin, End, R); 
+ 
+  if (Pos != End) { 
+    DWARFAddressRange Range(*Pos); 
+    if (Pos->merge(R)) 
+      return Range; 
+  } 
+  if (Pos != Begin) { 
+    auto Iter = Pos - 1; 
+    DWARFAddressRange Range(*Iter); 
+    if (Iter->merge(R)) 
+      return Range; 
+  } 
+ 
+  Ranges.insert(Pos, R); 
+  return None; 
+} 
+ 
+DWARFVerifier::DieRangeInfo::die_range_info_iterator 
+DWARFVerifier::DieRangeInfo::insert(const DieRangeInfo &RI) { 
+  auto End = Children.end(); 
+  auto Iter = Children.begin(); 
+  while (Iter != End) { 
+    if (Iter->intersects(RI)) 
+      return Iter; 
+    ++Iter; 
+  } 
+  Children.insert(RI); 
+  return Children.end(); 
+} 
+ 
+bool DWARFVerifier::DieRangeInfo::contains(const DieRangeInfo &RHS) const { 
+  auto I1 = Ranges.begin(), E1 = Ranges.end(); 
+  auto I2 = RHS.Ranges.begin(), E2 = RHS.Ranges.end(); 
+  if (I2 == E2) 
+    return true; 
+ 
+  DWARFAddressRange R = *I2; 
+  while (I1 != E1) { 
+    bool Covered = I1->LowPC <= R.LowPC; 
+    if (R.LowPC == R.HighPC || (Covered && R.HighPC <= I1->HighPC)) { 
+      if (++I2 == E2) 
+        return true; 
+      R = *I2; 
+      continue; 
+    } 
+    if (!Covered) 
+      return false; 
+    if (R.LowPC < I1->HighPC) 
+      R.LowPC = I1->HighPC; 
+    ++I1; 
+  } 
+  return false; 
+} 
+ 
+bool DWARFVerifier::DieRangeInfo::intersects(const DieRangeInfo &RHS) const { 
+  auto I1 = Ranges.begin(), E1 = Ranges.end(); 
+  auto I2 = RHS.Ranges.begin(), E2 = RHS.Ranges.end(); 
+  while (I1 != E1 && I2 != E2) { 
+    if (I1->intersects(*I2)) 
+      return true; 
+    if (I1->LowPC < I2->LowPC) 
+      ++I1; 
+    else 
+      ++I2; 
+  } 
+  return false; 
+} 
+ 
+bool DWARFVerifier::verifyUnitHeader(const DWARFDataExtractor DebugInfoData, 
+                                     uint64_t *Offset, unsigned UnitIndex, 
+                                     uint8_t &UnitType, bool &isUnitDWARF64) { 
+  uint64_t AbbrOffset, Length; 
+  uint8_t AddrSize = 0; 
+  uint16_t Version; 
+  bool Success = true; 
+ 
+  bool ValidLength = false; 
+  bool ValidVersion = false; 
+  bool ValidAddrSize = false; 
+  bool ValidType = true; 
+  bool ValidAbbrevOffset = true; 
+ 
+  uint64_t OffsetStart = *Offset; 
+  DwarfFormat Format; 
+  std::tie(Length, Format) = DebugInfoData.getInitialLength(Offset); 
+  isUnitDWARF64 = Format == DWARF64; 
+  Version = DebugInfoData.getU16(Offset); 
+ 
+  if (Version >= 5) { 
+    UnitType = DebugInfoData.getU8(Offset); 
+    AddrSize = DebugInfoData.getU8(Offset); 
+    AbbrOffset = isUnitDWARF64 ? DebugInfoData.getU64(Offset) : DebugInfoData.getU32(Offset); 
+    ValidType = dwarf::isUnitType(UnitType); 
+  } else { 
+    UnitType = 0; 
+    AbbrOffset = isUnitDWARF64 ? DebugInfoData.getU64(Offset) : DebugInfoData.getU32(Offset); 
+    AddrSize = DebugInfoData.getU8(Offset); 
+  } 
+ 
+  if (!DCtx.getDebugAbbrev()->getAbbreviationDeclarationSet(AbbrOffset)) 
+    ValidAbbrevOffset = false; 
+ 
+  ValidLength = DebugInfoData.isValidOffset(OffsetStart + Length + 3); 
+  ValidVersion = DWARFContext::isSupportedVersion(Version); 
+  ValidAddrSize = DWARFContext::isAddressSizeSupported(AddrSize); 
+  if (!ValidLength || !ValidVersion || !ValidAddrSize || !ValidAbbrevOffset || 
+      !ValidType) { 
+    Success = false; 
+    error() << format("Units[%d] - start offset: 0x%08" PRIx64 " \n", UnitIndex, 
+                      OffsetStart); 
+    if (!ValidLength) 
+      note() << "The length for this unit is too " 
+                "large for the .debug_info provided.\n"; 
+    if (!ValidVersion) 
+      note() << "The 16 bit unit header version is not valid.\n"; 
+    if (!ValidType) 
+      note() << "The unit type encoding is not valid.\n"; 
+    if (!ValidAbbrevOffset) 
+      note() << "The offset into the .debug_abbrev section is " 
+                "not valid.\n"; 
+    if (!ValidAddrSize) 
+      note() << "The address size is unsupported.\n"; 
+  } 
+  *Offset = OffsetStart + Length + (isUnitDWARF64 ? 12 : 4); 
+  return Success; 
+} 
+ 
+unsigned DWARFVerifier::verifyUnitContents(DWARFUnit &Unit) { 
+  unsigned NumUnitErrors = 0; 
+  unsigned NumDies = Unit.getNumDIEs(); 
+  for (unsigned I = 0; I < NumDies; ++I) { 
+    auto Die = Unit.getDIEAtIndex(I); 
+ 
+    if (Die.getTag() == DW_TAG_null) 
+      continue; 
+ 
+    for (auto AttrValue : Die.attributes()) { 
+      NumUnitErrors += verifyDebugInfoAttribute(Die, AttrValue); 
+      NumUnitErrors += verifyDebugInfoForm(Die, AttrValue); 
+    } 
+ 
     if (Die.hasChildren()) {
       if (Die.getFirstChild().isValid() &&
           Die.getFirstChild().getTag() == DW_TAG_null) {
@@ -181,372 +181,372 @@ unsigned DWARFVerifier::verifyUnitContents(DWARFUnit &Unit) {
       }
     }
 
-    NumUnitErrors += verifyDebugInfoCallSite(Die);
-  }
-
-  DWARFDie Die = Unit.getUnitDIE(/* ExtractUnitDIEOnly = */ false);
-  if (!Die) {
-    error() << "Compilation unit without DIE.\n";
-    NumUnitErrors++;
-    return NumUnitErrors;
-  }
-
-  if (!dwarf::isUnitType(Die.getTag())) {
-    error() << "Compilation unit root DIE is not a unit DIE: "
-            << dwarf::TagString(Die.getTag()) << ".\n";
-    NumUnitErrors++;
-  }
-
-  uint8_t UnitType = Unit.getUnitType();
-  if (!DWARFUnit::isMatchingUnitTypeAndTag(UnitType, Die.getTag())) {
-    error() << "Compilation unit type (" << dwarf::UnitTypeString(UnitType)
-            << ") and root DIE (" << dwarf::TagString(Die.getTag())
-            << ") do not match.\n";
-    NumUnitErrors++;
-  }
-
-  //  According to DWARF Debugging Information Format Version 5,
-  //  3.1.2 Skeleton Compilation Unit Entries:
-  //  "A skeleton compilation unit has no children."
-  if (Die.getTag() == dwarf::DW_TAG_skeleton_unit && Die.hasChildren()) {
-    error() << "Skeleton compilation unit has children.\n";
-    NumUnitErrors++;
-  }
-
-  DieRangeInfo RI;
-  NumUnitErrors += verifyDieRanges(Die, RI);
-
-  return NumUnitErrors;
-}
-
-unsigned DWARFVerifier::verifyDebugInfoCallSite(const DWARFDie &Die) {
-  if (Die.getTag() != DW_TAG_call_site && Die.getTag() != DW_TAG_GNU_call_site)
-    return 0;
-
-  DWARFDie Curr = Die.getParent();
-  for (; Curr.isValid() && !Curr.isSubprogramDIE(); Curr = Die.getParent()) {
-    if (Curr.getTag() == DW_TAG_inlined_subroutine) {
-      error() << "Call site entry nested within inlined subroutine:";
-      Curr.dump(OS);
-      return 1;
-    }
-  }
-
-  if (!Curr.isValid()) {
-    error() << "Call site entry not nested within a valid subprogram:";
-    Die.dump(OS);
-    return 1;
-  }
-
-  Optional<DWARFFormValue> CallAttr =
-      Curr.find({DW_AT_call_all_calls, DW_AT_call_all_source_calls,
-                 DW_AT_call_all_tail_calls, DW_AT_GNU_all_call_sites,
-                 DW_AT_GNU_all_source_call_sites,
-                 DW_AT_GNU_all_tail_call_sites});
-  if (!CallAttr) {
-    error() << "Subprogram with call site entry has no DW_AT_call attribute:";
-    Curr.dump(OS);
-    Die.dump(OS, /*indent*/ 1);
-    return 1;
-  }
-
-  return 0;
-}
-
-unsigned DWARFVerifier::verifyAbbrevSection(const DWARFDebugAbbrev *Abbrev) {
-  unsigned NumErrors = 0;
-  if (Abbrev) {
-    const DWARFAbbreviationDeclarationSet *AbbrDecls =
-        Abbrev->getAbbreviationDeclarationSet(0);
-    for (auto AbbrDecl : *AbbrDecls) {
-      SmallDenseSet<uint16_t> AttributeSet;
-      for (auto Attribute : AbbrDecl.attributes()) {
-        auto Result = AttributeSet.insert(Attribute.Attr);
-        if (!Result.second) {
-          error() << "Abbreviation declaration contains multiple "
-                  << AttributeString(Attribute.Attr) << " attributes.\n";
-          AbbrDecl.dump(OS);
-          ++NumErrors;
-        }
-      }
-    }
-  }
-  return NumErrors;
-}
-
-bool DWARFVerifier::handleDebugAbbrev() {
-  OS << "Verifying .debug_abbrev...\n";
-
-  const DWARFObject &DObj = DCtx.getDWARFObj();
-  unsigned NumErrors = 0;
-  if (!DObj.getAbbrevSection().empty())
-    NumErrors += verifyAbbrevSection(DCtx.getDebugAbbrev());
-  if (!DObj.getAbbrevDWOSection().empty())
-    NumErrors += verifyAbbrevSection(DCtx.getDebugAbbrevDWO());
-
-  return NumErrors == 0;
-}
-
-unsigned DWARFVerifier::verifyUnitSection(const DWARFSection &S,
-                                          DWARFSectionKind SectionKind) {
-  const DWARFObject &DObj = DCtx.getDWARFObj();
-  DWARFDataExtractor DebugInfoData(DObj, S, DCtx.isLittleEndian(), 0);
-  unsigned NumDebugInfoErrors = 0;
-  uint64_t OffsetStart = 0, Offset = 0, UnitIdx = 0;
-  uint8_t UnitType = 0;
-  bool isUnitDWARF64 = false;
-  bool isHeaderChainValid = true;
-  bool hasDIE = DebugInfoData.isValidOffset(Offset);
-  DWARFUnitVector TypeUnitVector;
-  DWARFUnitVector CompileUnitVector;
-  while (hasDIE) {
-    OffsetStart = Offset;
-    if (!verifyUnitHeader(DebugInfoData, &Offset, UnitIdx, UnitType,
-                          isUnitDWARF64)) {
-      isHeaderChainValid = false;
-      if (isUnitDWARF64)
-        break;
-    } else {
-      DWARFUnitHeader Header;
-      Header.extract(DCtx, DebugInfoData, &OffsetStart, SectionKind);
-      DWARFUnit *Unit;
-      switch (UnitType) {
-      case dwarf::DW_UT_type:
-      case dwarf::DW_UT_split_type: {
-        Unit = TypeUnitVector.addUnit(std::make_unique<DWARFTypeUnit>(
-            DCtx, S, Header, DCtx.getDebugAbbrev(), &DObj.getRangesSection(),
-            &DObj.getLocSection(), DObj.getStrSection(),
-            DObj.getStrOffsetsSection(), &DObj.getAddrSection(),
-            DObj.getLineSection(), DCtx.isLittleEndian(), false,
-            TypeUnitVector));
-        break;
-      }
-      case dwarf::DW_UT_skeleton:
-      case dwarf::DW_UT_split_compile:
-      case dwarf::DW_UT_compile:
-      case dwarf::DW_UT_partial:
-      // UnitType = 0 means that we are verifying a compile unit in DWARF v4.
-      case 0: {
-        Unit = CompileUnitVector.addUnit(std::make_unique<DWARFCompileUnit>(
-            DCtx, S, Header, DCtx.getDebugAbbrev(), &DObj.getRangesSection(),
-            &DObj.getLocSection(), DObj.getStrSection(),
-            DObj.getStrOffsetsSection(), &DObj.getAddrSection(),
-            DObj.getLineSection(), DCtx.isLittleEndian(), false,
-            CompileUnitVector));
-        break;
-      }
-      default: { llvm_unreachable("Invalid UnitType."); }
-      }
-      NumDebugInfoErrors += verifyUnitContents(*Unit);
-    }
-    hasDIE = DebugInfoData.isValidOffset(Offset);
-    ++UnitIdx;
-  }
-  if (UnitIdx == 0 && !hasDIE) {
-    warn() << "Section is empty.\n";
-    isHeaderChainValid = true;
-  }
-  if (!isHeaderChainValid)
-    ++NumDebugInfoErrors;
-  NumDebugInfoErrors += verifyDebugInfoReferences();
-  return NumDebugInfoErrors;
-}
-
-bool DWARFVerifier::handleDebugInfo() {
-  const DWARFObject &DObj = DCtx.getDWARFObj();
-  unsigned NumErrors = 0;
-
-  OS << "Verifying .debug_info Unit Header Chain...\n";
-  DObj.forEachInfoSections([&](const DWARFSection &S) {
-    NumErrors += verifyUnitSection(S, DW_SECT_INFO);
-  });
-
-  OS << "Verifying .debug_types Unit Header Chain...\n";
-  DObj.forEachTypesSections([&](const DWARFSection &S) {
-    NumErrors += verifyUnitSection(S, DW_SECT_EXT_TYPES);
-  });
-  return NumErrors == 0;
-}
-
-unsigned DWARFVerifier::verifyDieRanges(const DWARFDie &Die,
-                                        DieRangeInfo &ParentRI) {
-  unsigned NumErrors = 0;
-
-  if (!Die.isValid())
-    return NumErrors;
-
-  auto RangesOrError = Die.getAddressRanges();
-  if (!RangesOrError) {
-    // FIXME: Report the error.
-    ++NumErrors;
-    llvm::consumeError(RangesOrError.takeError());
-    return NumErrors;
-  }
-
-  DWARFAddressRangesVector Ranges = RangesOrError.get();
-  // Build RI for this DIE and check that ranges within this DIE do not
-  // overlap.
-  DieRangeInfo RI(Die);
-
-  // TODO support object files better
-  //
-  // Some object file formats (i.e. non-MachO) support COMDAT.  ELF in
-  // particular does so by placing each function into a section.  The DWARF data
-  // for the function at that point uses a section relative DW_FORM_addrp for
-  // the DW_AT_low_pc and a DW_FORM_data4 for the offset as the DW_AT_high_pc.
-  // In such a case, when the Die is the CU, the ranges will overlap, and we
-  // will flag valid conflicting ranges as invalid.
-  //
-  // For such targets, we should read the ranges from the CU and partition them
-  // by the section id.  The ranges within a particular section should be
-  // disjoint, although the ranges across sections may overlap.  We would map
-  // the child die to the entity that it references and the section with which
-  // it is associated.  The child would then be checked against the range
-  // information for the associated section.
-  //
-  // For now, simply elide the range verification for the CU DIEs if we are
-  // processing an object file.
-
-  if (!IsObjectFile || IsMachOObject || Die.getTag() != DW_TAG_compile_unit) {
-    bool DumpDieAfterError = false;
-    for (auto Range : Ranges) {
-      if (!Range.valid()) {
-        ++NumErrors;
-        error() << "Invalid address range " << Range << "\n";
-        DumpDieAfterError = true;
-        continue;
-      }
-
-      // Verify that ranges don't intersect and also build up the DieRangeInfo
-      // address ranges. Don't break out of the loop below early, or we will
-      // think this DIE doesn't have all of the address ranges it is supposed
-      // to have. Compile units often have DW_AT_ranges that can contain one or
-      // more dead stripped address ranges which tend to all be at the same
-      // address: 0 or -1.
-      if (auto PrevRange = RI.insert(Range)) {
-        ++NumErrors;
-        error() << "DIE has overlapping ranges in DW_AT_ranges attribute: "
-                << *PrevRange << " and " << Range << '\n';
-        DumpDieAfterError = true;
-      }
-    }
-    if (DumpDieAfterError)
-      dump(Die, 2) << '\n';
-  }
-
-  // Verify that children don't intersect.
-  const auto IntersectingChild = ParentRI.insert(RI);
-  if (IntersectingChild != ParentRI.Children.end()) {
-    ++NumErrors;
-    error() << "DIEs have overlapping address ranges:";
-    dump(Die);
-    dump(IntersectingChild->Die) << '\n';
-  }
-
-  // Verify that ranges are contained within their parent.
-  bool ShouldBeContained = !Ranges.empty() && !ParentRI.Ranges.empty() &&
-                           !(Die.getTag() == DW_TAG_subprogram &&
-                             ParentRI.Die.getTag() == DW_TAG_subprogram);
-  if (ShouldBeContained && !ParentRI.contains(RI)) {
-    ++NumErrors;
-    error() << "DIE address ranges are not contained in its parent's ranges:";
-    dump(ParentRI.Die);
-    dump(Die, 2) << '\n';
-  }
-
-  // Recursively check children.
-  for (DWARFDie Child : Die)
-    NumErrors += verifyDieRanges(Child, RI);
-
-  return NumErrors;
-}
-
-unsigned DWARFVerifier::verifyDebugInfoAttribute(const DWARFDie &Die,
-                                                 DWARFAttribute &AttrValue) {
-  unsigned NumErrors = 0;
-  auto ReportError = [&](const Twine &TitleMsg) {
-    ++NumErrors;
-    error() << TitleMsg << '\n';
-    dump(Die) << '\n';
-  };
-
-  const DWARFObject &DObj = DCtx.getDWARFObj();
-  const auto Attr = AttrValue.Attr;
-  switch (Attr) {
-  case DW_AT_ranges:
-    // Make sure the offset in the DW_AT_ranges attribute is valid.
-    if (auto SectionOffset = AttrValue.Value.getAsSectionOffset()) {
-      unsigned DwarfVersion = Die.getDwarfUnit()->getVersion();
-      const DWARFSection &RangeSection = DwarfVersion < 5
-                                             ? DObj.getRangesSection()
-                                             : DObj.getRnglistsSection();
-      if (*SectionOffset >= RangeSection.Data.size())
-        ReportError(
-            "DW_AT_ranges offset is beyond " +
-            StringRef(DwarfVersion < 5 ? ".debug_ranges" : ".debug_rnglists") +
-            " bounds: " + llvm::formatv("{0:x8}", *SectionOffset));
-      break;
-    }
-    ReportError("DIE has invalid DW_AT_ranges encoding:");
-    break;
-  case DW_AT_stmt_list:
-    // Make sure the offset in the DW_AT_stmt_list attribute is valid.
-    if (auto SectionOffset = AttrValue.Value.getAsSectionOffset()) {
-      if (*SectionOffset >= DObj.getLineSection().Data.size())
-        ReportError("DW_AT_stmt_list offset is beyond .debug_line bounds: " +
-                    llvm::formatv("{0:x8}", *SectionOffset));
-      break;
-    }
-    ReportError("DIE has invalid DW_AT_stmt_list encoding:");
-    break;
-  case DW_AT_location: {
-    if (Expected<std::vector<DWARFLocationExpression>> Loc =
-            Die.getLocations(DW_AT_location)) {
-      DWARFUnit *U = Die.getDwarfUnit();
-      for (const auto &Entry : *Loc) {
-        DataExtractor Data(toStringRef(Entry.Expr), DCtx.isLittleEndian(), 0);
-        DWARFExpression Expression(Data, U->getAddressByteSize(),
-                                   U->getFormParams().Format);
-        bool Error = any_of(Expression, [](DWARFExpression::Operation &Op) {
-          return Op.isError();
-        });
-        if (Error || !Expression.verify(U))
-          ReportError("DIE contains invalid DWARF expression:");
-      }
-    } else
-      ReportError(toString(Loc.takeError()));
-    break;
-  }
-  case DW_AT_specification:
-  case DW_AT_abstract_origin: {
-    if (auto ReferencedDie = Die.getAttributeValueAsReferencedDie(Attr)) {
-      auto DieTag = Die.getTag();
-      auto RefTag = ReferencedDie.getTag();
-      if (DieTag == RefTag)
-        break;
-      if (DieTag == DW_TAG_inlined_subroutine && RefTag == DW_TAG_subprogram)
-        break;
-      if (DieTag == DW_TAG_variable && RefTag == DW_TAG_member)
-        break;
-      // This might be reference to a function declaration.
-      if (DieTag == DW_TAG_GNU_call_site && RefTag == DW_TAG_subprogram)
-        break;
-      ReportError("DIE with tag " + TagString(DieTag) + " has " +
-                  AttributeString(Attr) +
-                  " that points to DIE with "
-                  "incompatible tag " +
-                  TagString(RefTag));
-    }
-    break;
-  }
-  case DW_AT_type: {
-    DWARFDie TypeDie = Die.getAttributeValueAsReferencedDie(DW_AT_type);
-    if (TypeDie && !isType(TypeDie.getTag())) {
-      ReportError("DIE has " + AttributeString(Attr) +
-                  " with incompatible tag " + TagString(TypeDie.getTag()));
-    }
-    break;
-  }
+    NumUnitErrors += verifyDebugInfoCallSite(Die); 
+  } 
+ 
+  DWARFDie Die = Unit.getUnitDIE(/* ExtractUnitDIEOnly = */ false); 
+  if (!Die) { 
+    error() << "Compilation unit without DIE.\n"; 
+    NumUnitErrors++; 
+    return NumUnitErrors; 
+  } 
+ 
+  if (!dwarf::isUnitType(Die.getTag())) { 
+    error() << "Compilation unit root DIE is not a unit DIE: " 
+            << dwarf::TagString(Die.getTag()) << ".\n"; 
+    NumUnitErrors++; 
+  } 
+ 
+  uint8_t UnitType = Unit.getUnitType(); 
+  if (!DWARFUnit::isMatchingUnitTypeAndTag(UnitType, Die.getTag())) { 
+    error() << "Compilation unit type (" << dwarf::UnitTypeString(UnitType) 
+            << ") and root DIE (" << dwarf::TagString(Die.getTag()) 
+            << ") do not match.\n"; 
+    NumUnitErrors++; 
+  } 
+ 
+  //  According to DWARF Debugging Information Format Version 5, 
+  //  3.1.2 Skeleton Compilation Unit Entries: 
+  //  "A skeleton compilation unit has no children." 
+  if (Die.getTag() == dwarf::DW_TAG_skeleton_unit && Die.hasChildren()) { 
+    error() << "Skeleton compilation unit has children.\n"; 
+    NumUnitErrors++; 
+  } 
+ 
+  DieRangeInfo RI; 
+  NumUnitErrors += verifyDieRanges(Die, RI); 
+ 
+  return NumUnitErrors; 
+} 
+ 
+unsigned DWARFVerifier::verifyDebugInfoCallSite(const DWARFDie &Die) { 
+  if (Die.getTag() != DW_TAG_call_site && Die.getTag() != DW_TAG_GNU_call_site) 
+    return 0; 
+ 
+  DWARFDie Curr = Die.getParent(); 
+  for (; Curr.isValid() && !Curr.isSubprogramDIE(); Curr = Die.getParent()) { 
+    if (Curr.getTag() == DW_TAG_inlined_subroutine) { 
+      error() << "Call site entry nested within inlined subroutine:"; 
+      Curr.dump(OS); 
+      return 1; 
+    } 
+  } 
+ 
+  if (!Curr.isValid()) { 
+    error() << "Call site entry not nested within a valid subprogram:"; 
+    Die.dump(OS); 
+    return 1; 
+  } 
+ 
+  Optional<DWARFFormValue> CallAttr = 
+      Curr.find({DW_AT_call_all_calls, DW_AT_call_all_source_calls, 
+                 DW_AT_call_all_tail_calls, DW_AT_GNU_all_call_sites, 
+                 DW_AT_GNU_all_source_call_sites, 
+                 DW_AT_GNU_all_tail_call_sites}); 
+  if (!CallAttr) { 
+    error() << "Subprogram with call site entry has no DW_AT_call attribute:"; 
+    Curr.dump(OS); 
+    Die.dump(OS, /*indent*/ 1); 
+    return 1; 
+  } 
+ 
+  return 0; 
+} 
+ 
+unsigned DWARFVerifier::verifyAbbrevSection(const DWARFDebugAbbrev *Abbrev) { 
+  unsigned NumErrors = 0; 
+  if (Abbrev) { 
+    const DWARFAbbreviationDeclarationSet *AbbrDecls = 
+        Abbrev->getAbbreviationDeclarationSet(0); 
+    for (auto AbbrDecl : *AbbrDecls) { 
+      SmallDenseSet<uint16_t> AttributeSet; 
+      for (auto Attribute : AbbrDecl.attributes()) { 
+        auto Result = AttributeSet.insert(Attribute.Attr); 
+        if (!Result.second) { 
+          error() << "Abbreviation declaration contains multiple " 
+                  << AttributeString(Attribute.Attr) << " attributes.\n"; 
+          AbbrDecl.dump(OS); 
+          ++NumErrors; 
+        } 
+      } 
+    } 
+  } 
+  return NumErrors; 
+} 
+ 
+bool DWARFVerifier::handleDebugAbbrev() { 
+  OS << "Verifying .debug_abbrev...\n"; 
+ 
+  const DWARFObject &DObj = DCtx.getDWARFObj(); 
+  unsigned NumErrors = 0; 
+  if (!DObj.getAbbrevSection().empty()) 
+    NumErrors += verifyAbbrevSection(DCtx.getDebugAbbrev()); 
+  if (!DObj.getAbbrevDWOSection().empty()) 
+    NumErrors += verifyAbbrevSection(DCtx.getDebugAbbrevDWO()); 
+ 
+  return NumErrors == 0; 
+} 
+ 
+unsigned DWARFVerifier::verifyUnitSection(const DWARFSection &S, 
+                                          DWARFSectionKind SectionKind) { 
+  const DWARFObject &DObj = DCtx.getDWARFObj(); 
+  DWARFDataExtractor DebugInfoData(DObj, S, DCtx.isLittleEndian(), 0); 
+  unsigned NumDebugInfoErrors = 0; 
+  uint64_t OffsetStart = 0, Offset = 0, UnitIdx = 0; 
+  uint8_t UnitType = 0; 
+  bool isUnitDWARF64 = false; 
+  bool isHeaderChainValid = true; 
+  bool hasDIE = DebugInfoData.isValidOffset(Offset); 
+  DWARFUnitVector TypeUnitVector; 
+  DWARFUnitVector CompileUnitVector; 
+  while (hasDIE) { 
+    OffsetStart = Offset; 
+    if (!verifyUnitHeader(DebugInfoData, &Offset, UnitIdx, UnitType, 
+                          isUnitDWARF64)) { 
+      isHeaderChainValid = false; 
+      if (isUnitDWARF64) 
+        break; 
+    } else { 
+      DWARFUnitHeader Header; 
+      Header.extract(DCtx, DebugInfoData, &OffsetStart, SectionKind); 
+      DWARFUnit *Unit; 
+      switch (UnitType) { 
+      case dwarf::DW_UT_type: 
+      case dwarf::DW_UT_split_type: { 
+        Unit = TypeUnitVector.addUnit(std::make_unique<DWARFTypeUnit>( 
+            DCtx, S, Header, DCtx.getDebugAbbrev(), &DObj.getRangesSection(), 
+            &DObj.getLocSection(), DObj.getStrSection(), 
+            DObj.getStrOffsetsSection(), &DObj.getAddrSection(), 
+            DObj.getLineSection(), DCtx.isLittleEndian(), false, 
+            TypeUnitVector)); 
+        break; 
+      } 
+      case dwarf::DW_UT_skeleton: 
+      case dwarf::DW_UT_split_compile: 
+      case dwarf::DW_UT_compile: 
+      case dwarf::DW_UT_partial: 
+      // UnitType = 0 means that we are verifying a compile unit in DWARF v4. 
+      case 0: { 
+        Unit = CompileUnitVector.addUnit(std::make_unique<DWARFCompileUnit>( 
+            DCtx, S, Header, DCtx.getDebugAbbrev(), &DObj.getRangesSection(), 
+            &DObj.getLocSection(), DObj.getStrSection(), 
+            DObj.getStrOffsetsSection(), &DObj.getAddrSection(), 
+            DObj.getLineSection(), DCtx.isLittleEndian(), false, 
+            CompileUnitVector)); 
+        break; 
+      } 
+      default: { llvm_unreachable("Invalid UnitType."); } 
+      } 
+      NumDebugInfoErrors += verifyUnitContents(*Unit); 
+    } 
+    hasDIE = DebugInfoData.isValidOffset(Offset); 
+    ++UnitIdx; 
+  } 
+  if (UnitIdx == 0 && !hasDIE) { 
+    warn() << "Section is empty.\n"; 
+    isHeaderChainValid = true; 
+  } 
+  if (!isHeaderChainValid) 
+    ++NumDebugInfoErrors; 
+  NumDebugInfoErrors += verifyDebugInfoReferences(); 
+  return NumDebugInfoErrors; 
+} 
+ 
+bool DWARFVerifier::handleDebugInfo() { 
+  const DWARFObject &DObj = DCtx.getDWARFObj(); 
+  unsigned NumErrors = 0; 
+ 
+  OS << "Verifying .debug_info Unit Header Chain...\n"; 
+  DObj.forEachInfoSections([&](const DWARFSection &S) { 
+    NumErrors += verifyUnitSection(S, DW_SECT_INFO); 
+  }); 
+ 
+  OS << "Verifying .debug_types Unit Header Chain...\n"; 
+  DObj.forEachTypesSections([&](const DWARFSection &S) { 
+    NumErrors += verifyUnitSection(S, DW_SECT_EXT_TYPES); 
+  }); 
+  return NumErrors == 0; 
+} 
+ 
+unsigned DWARFVerifier::verifyDieRanges(const DWARFDie &Die, 
+                                        DieRangeInfo &ParentRI) { 
+  unsigned NumErrors = 0; 
+ 
+  if (!Die.isValid()) 
+    return NumErrors; 
+ 
+  auto RangesOrError = Die.getAddressRanges(); 
+  if (!RangesOrError) { 
+    // FIXME: Report the error. 
+    ++NumErrors; 
+    llvm::consumeError(RangesOrError.takeError()); 
+    return NumErrors; 
+  } 
+ 
+  DWARFAddressRangesVector Ranges = RangesOrError.get(); 
+  // Build RI for this DIE and check that ranges within this DIE do not 
+  // overlap. 
+  DieRangeInfo RI(Die); 
+ 
+  // TODO support object files better 
+  // 
+  // Some object file formats (i.e. non-MachO) support COMDAT.  ELF in 
+  // particular does so by placing each function into a section.  The DWARF data 
+  // for the function at that point uses a section relative DW_FORM_addrp for 
+  // the DW_AT_low_pc and a DW_FORM_data4 for the offset as the DW_AT_high_pc. 
+  // In such a case, when the Die is the CU, the ranges will overlap, and we 
+  // will flag valid conflicting ranges as invalid. 
+  // 
+  // For such targets, we should read the ranges from the CU and partition them 
+  // by the section id.  The ranges within a particular section should be 
+  // disjoint, although the ranges across sections may overlap.  We would map 
+  // the child die to the entity that it references and the section with which 
+  // it is associated.  The child would then be checked against the range 
+  // information for the associated section. 
+  // 
+  // For now, simply elide the range verification for the CU DIEs if we are 
+  // processing an object file. 
+ 
+  if (!IsObjectFile || IsMachOObject || Die.getTag() != DW_TAG_compile_unit) { 
+    bool DumpDieAfterError = false; 
+    for (auto Range : Ranges) { 
+      if (!Range.valid()) { 
+        ++NumErrors; 
+        error() << "Invalid address range " << Range << "\n"; 
+        DumpDieAfterError = true; 
+        continue; 
+      } 
+ 
+      // Verify that ranges don't intersect and also build up the DieRangeInfo 
+      // address ranges. Don't break out of the loop below early, or we will 
+      // think this DIE doesn't have all of the address ranges it is supposed 
+      // to have. Compile units often have DW_AT_ranges that can contain one or 
+      // more dead stripped address ranges which tend to all be at the same 
+      // address: 0 or -1. 
+      if (auto PrevRange = RI.insert(Range)) { 
+        ++NumErrors; 
+        error() << "DIE has overlapping ranges in DW_AT_ranges attribute: " 
+                << *PrevRange << " and " << Range << '\n'; 
+        DumpDieAfterError = true; 
+      } 
+    } 
+    if (DumpDieAfterError) 
+      dump(Die, 2) << '\n'; 
+  } 
+ 
+  // Verify that children don't intersect. 
+  const auto IntersectingChild = ParentRI.insert(RI); 
+  if (IntersectingChild != ParentRI.Children.end()) { 
+    ++NumErrors; 
+    error() << "DIEs have overlapping address ranges:"; 
+    dump(Die); 
+    dump(IntersectingChild->Die) << '\n'; 
+  } 
+ 
+  // Verify that ranges are contained within their parent. 
+  bool ShouldBeContained = !Ranges.empty() && !ParentRI.Ranges.empty() && 
+                           !(Die.getTag() == DW_TAG_subprogram && 
+                             ParentRI.Die.getTag() == DW_TAG_subprogram); 
+  if (ShouldBeContained && !ParentRI.contains(RI)) { 
+    ++NumErrors; 
+    error() << "DIE address ranges are not contained in its parent's ranges:"; 
+    dump(ParentRI.Die); 
+    dump(Die, 2) << '\n'; 
+  } 
+ 
+  // Recursively check children. 
+  for (DWARFDie Child : Die) 
+    NumErrors += verifyDieRanges(Child, RI); 
+ 
+  return NumErrors; 
+} 
+ 
+unsigned DWARFVerifier::verifyDebugInfoAttribute(const DWARFDie &Die, 
+                                                 DWARFAttribute &AttrValue) { 
+  unsigned NumErrors = 0; 
+  auto ReportError = [&](const Twine &TitleMsg) { 
+    ++NumErrors; 
+    error() << TitleMsg << '\n'; 
+    dump(Die) << '\n'; 
+  }; 
+ 
+  const DWARFObject &DObj = DCtx.getDWARFObj(); 
+  const auto Attr = AttrValue.Attr; 
+  switch (Attr) { 
+  case DW_AT_ranges: 
+    // Make sure the offset in the DW_AT_ranges attribute is valid. 
+    if (auto SectionOffset = AttrValue.Value.getAsSectionOffset()) { 
+      unsigned DwarfVersion = Die.getDwarfUnit()->getVersion(); 
+      const DWARFSection &RangeSection = DwarfVersion < 5 
+                                             ? DObj.getRangesSection() 
+                                             : DObj.getRnglistsSection(); 
+      if (*SectionOffset >= RangeSection.Data.size()) 
+        ReportError( 
+            "DW_AT_ranges offset is beyond " + 
+            StringRef(DwarfVersion < 5 ? ".debug_ranges" : ".debug_rnglists") + 
+            " bounds: " + llvm::formatv("{0:x8}", *SectionOffset)); 
+      break; 
+    } 
+    ReportError("DIE has invalid DW_AT_ranges encoding:"); 
+    break; 
+  case DW_AT_stmt_list: 
+    // Make sure the offset in the DW_AT_stmt_list attribute is valid. 
+    if (auto SectionOffset = AttrValue.Value.getAsSectionOffset()) { 
+      if (*SectionOffset >= DObj.getLineSection().Data.size()) 
+        ReportError("DW_AT_stmt_list offset is beyond .debug_line bounds: " + 
+                    llvm::formatv("{0:x8}", *SectionOffset)); 
+      break; 
+    } 
+    ReportError("DIE has invalid DW_AT_stmt_list encoding:"); 
+    break; 
+  case DW_AT_location: { 
+    if (Expected<std::vector<DWARFLocationExpression>> Loc = 
+            Die.getLocations(DW_AT_location)) { 
+      DWARFUnit *U = Die.getDwarfUnit(); 
+      for (const auto &Entry : *Loc) { 
+        DataExtractor Data(toStringRef(Entry.Expr), DCtx.isLittleEndian(), 0); 
+        DWARFExpression Expression(Data, U->getAddressByteSize(), 
+                                   U->getFormParams().Format); 
+        bool Error = any_of(Expression, [](DWARFExpression::Operation &Op) { 
+          return Op.isError(); 
+        }); 
+        if (Error || !Expression.verify(U)) 
+          ReportError("DIE contains invalid DWARF expression:"); 
+      } 
+    } else 
+      ReportError(toString(Loc.takeError())); 
+    break; 
+  } 
+  case DW_AT_specification: 
+  case DW_AT_abstract_origin: { 
+    if (auto ReferencedDie = Die.getAttributeValueAsReferencedDie(Attr)) { 
+      auto DieTag = Die.getTag(); 
+      auto RefTag = ReferencedDie.getTag(); 
+      if (DieTag == RefTag) 
+        break; 
+      if (DieTag == DW_TAG_inlined_subroutine && RefTag == DW_TAG_subprogram) 
+        break; 
+      if (DieTag == DW_TAG_variable && RefTag == DW_TAG_member) 
+        break; 
+      // This might be reference to a function declaration. 
+      if (DieTag == DW_TAG_GNU_call_site && RefTag == DW_TAG_subprogram) 
+        break; 
+      ReportError("DIE with tag " + TagString(DieTag) + " has " + 
+                  AttributeString(Attr) + 
+                  " that points to DIE with " 
+                  "incompatible tag " + 
+                  TagString(RefTag)); 
+    } 
+    break; 
+  } 
+  case DW_AT_type: { 
+    DWARFDie TypeDie = Die.getAttributeValueAsReferencedDie(DW_AT_type); 
+    if (TypeDie && !isType(TypeDie.getTag())) { 
+      ReportError("DIE has " + AttributeString(Attr) + 
+                  " with incompatible tag " + TagString(TypeDie.getTag())); 
+    } 
+    break; 
+  } 
   case DW_AT_call_file:
   case DW_AT_decl_file: {
     if (auto FileIdx = AttrValue.Value.getAsUnsignedConstant()) {
@@ -580,960 +580,960 @@ unsigned DWARFVerifier::verifyDebugInfoAttribute(const DWARFDie &Die,
     }
     break;
   }
-  default:
-    break;
-  }
-  return NumErrors;
-}
-
-unsigned DWARFVerifier::verifyDebugInfoForm(const DWARFDie &Die,
-                                            DWARFAttribute &AttrValue) {
-  const DWARFObject &DObj = DCtx.getDWARFObj();
-  auto DieCU = Die.getDwarfUnit();
-  unsigned NumErrors = 0;
-  const auto Form = AttrValue.Value.getForm();
-  switch (Form) {
-  case DW_FORM_ref1:
-  case DW_FORM_ref2:
-  case DW_FORM_ref4:
-  case DW_FORM_ref8:
-  case DW_FORM_ref_udata: {
-    // Verify all CU relative references are valid CU offsets.
-    Optional<uint64_t> RefVal = AttrValue.Value.getAsReference();
-    assert(RefVal);
-    if (RefVal) {
-      auto CUSize = DieCU->getNextUnitOffset() - DieCU->getOffset();
-      auto CUOffset = AttrValue.Value.getRawUValue();
-      if (CUOffset >= CUSize) {
-        ++NumErrors;
-        error() << FormEncodingString(Form) << " CU offset "
-                << format("0x%08" PRIx64, CUOffset)
-                << " is invalid (must be less than CU size of "
-                << format("0x%08" PRIx64, CUSize) << "):\n";
-        Die.dump(OS, 0, DumpOpts);
-        dump(Die) << '\n';
-      } else {
-        // Valid reference, but we will verify it points to an actual
-        // DIE later.
-        ReferenceToDIEOffsets[*RefVal].insert(Die.getOffset());
-      }
-    }
-    break;
-  }
-  case DW_FORM_ref_addr: {
-    // Verify all absolute DIE references have valid offsets in the
-    // .debug_info section.
-    Optional<uint64_t> RefVal = AttrValue.Value.getAsReference();
-    assert(RefVal);
-    if (RefVal) {
-      if (*RefVal >= DieCU->getInfoSection().Data.size()) {
-        ++NumErrors;
-        error() << "DW_FORM_ref_addr offset beyond .debug_info "
-                   "bounds:\n";
-        dump(Die) << '\n';
-      } else {
-        // Valid reference, but we will verify it points to an actual
-        // DIE later.
-        ReferenceToDIEOffsets[*RefVal].insert(Die.getOffset());
-      }
-    }
-    break;
-  }
-  case DW_FORM_strp: {
-    auto SecOffset = AttrValue.Value.getAsSectionOffset();
-    assert(SecOffset); // DW_FORM_strp is a section offset.
-    if (SecOffset && *SecOffset >= DObj.getStrSection().size()) {
-      ++NumErrors;
-      error() << "DW_FORM_strp offset beyond .debug_str bounds:\n";
-      dump(Die) << '\n';
-    }
-    break;
-  }
-  case DW_FORM_strx:
-  case DW_FORM_strx1:
-  case DW_FORM_strx2:
-  case DW_FORM_strx3:
-  case DW_FORM_strx4: {
-    auto Index = AttrValue.Value.getRawUValue();
-    auto DieCU = Die.getDwarfUnit();
-    // Check that we have a valid DWARF v5 string offsets table.
-    if (!DieCU->getStringOffsetsTableContribution()) {
-      ++NumErrors;
-      error() << FormEncodingString(Form)
-              << " used without a valid string offsets table:\n";
-      dump(Die) << '\n';
-      break;
-    }
-    // Check that the index is within the bounds of the section.
-    unsigned ItemSize = DieCU->getDwarfStringOffsetsByteSize();
-    // Use a 64-bit type to calculate the offset to guard against overflow.
-    uint64_t Offset =
-        (uint64_t)DieCU->getStringOffsetsBase() + Index * ItemSize;
-    if (DObj.getStrOffsetsSection().Data.size() < Offset + ItemSize) {
-      ++NumErrors;
-      error() << FormEncodingString(Form) << " uses index "
-              << format("%" PRIu64, Index) << ", which is too large:\n";
-      dump(Die) << '\n';
-      break;
-    }
-    // Check that the string offset is valid.
-    uint64_t StringOffset = *DieCU->getStringOffsetSectionItem(Index);
-    if (StringOffset >= DObj.getStrSection().size()) {
-      ++NumErrors;
-      error() << FormEncodingString(Form) << " uses index "
-              << format("%" PRIu64, Index)
-              << ", but the referenced string"
-                 " offset is beyond .debug_str bounds:\n";
-      dump(Die) << '\n';
-    }
-    break;
-  }
-  default:
-    break;
-  }
-  return NumErrors;
-}
-
-unsigned DWARFVerifier::verifyDebugInfoReferences() {
-  // Take all references and make sure they point to an actual DIE by
-  // getting the DIE by offset and emitting an error
-  OS << "Verifying .debug_info references...\n";
-  unsigned NumErrors = 0;
-  for (const std::pair<const uint64_t, std::set<uint64_t>> &Pair :
-       ReferenceToDIEOffsets) {
-    if (DCtx.getDIEForOffset(Pair.first))
-      continue;
-    ++NumErrors;
-    error() << "invalid DIE reference " << format("0x%08" PRIx64, Pair.first)
-            << ". Offset is in between DIEs:\n";
-    for (auto Offset : Pair.second)
-      dump(DCtx.getDIEForOffset(Offset)) << '\n';
-    OS << "\n";
-  }
-  return NumErrors;
-}
-
-void DWARFVerifier::verifyDebugLineStmtOffsets() {
-  std::map<uint64_t, DWARFDie> StmtListToDie;
-  for (const auto &CU : DCtx.compile_units()) {
-    auto Die = CU->getUnitDIE();
-    // Get the attribute value as a section offset. No need to produce an
-    // error here if the encoding isn't correct because we validate this in
-    // the .debug_info verifier.
-    auto StmtSectionOffset = toSectionOffset(Die.find(DW_AT_stmt_list));
-    if (!StmtSectionOffset)
-      continue;
-    const uint64_t LineTableOffset = *StmtSectionOffset;
-    auto LineTable = DCtx.getLineTableForUnit(CU.get());
-    if (LineTableOffset < DCtx.getDWARFObj().getLineSection().Data.size()) {
-      if (!LineTable) {
-        ++NumDebugLineErrors;
-        error() << ".debug_line[" << format("0x%08" PRIx64, LineTableOffset)
-                << "] was not able to be parsed for CU:\n";
-        dump(Die) << '\n';
-        continue;
-      }
-    } else {
-      // Make sure we don't get a valid line table back if the offset is wrong.
-      assert(LineTable == nullptr);
-      // Skip this line table as it isn't valid. No need to create an error
-      // here because we validate this in the .debug_info verifier.
-      continue;
-    }
-    auto Iter = StmtListToDie.find(LineTableOffset);
-    if (Iter != StmtListToDie.end()) {
-      ++NumDebugLineErrors;
-      error() << "two compile unit DIEs, "
-              << format("0x%08" PRIx64, Iter->second.getOffset()) << " and "
-              << format("0x%08" PRIx64, Die.getOffset())
-              << ", have the same DW_AT_stmt_list section offset:\n";
-      dump(Iter->second);
-      dump(Die) << '\n';
-      // Already verified this line table before, no need to do it again.
-      continue;
-    }
-    StmtListToDie[LineTableOffset] = Die;
-  }
-}
-
-void DWARFVerifier::verifyDebugLineRows() {
-  for (const auto &CU : DCtx.compile_units()) {
-    auto Die = CU->getUnitDIE();
-    auto LineTable = DCtx.getLineTableForUnit(CU.get());
-    // If there is no line table we will have created an error in the
-    // .debug_info verifier or in verifyDebugLineStmtOffsets().
-    if (!LineTable)
-      continue;
-
-    // Verify prologue.
-    uint32_t MaxDirIndex = LineTable->Prologue.IncludeDirectories.size();
-    uint32_t FileIndex = 1;
-    StringMap<uint16_t> FullPathMap;
-    for (const auto &FileName : LineTable->Prologue.FileNames) {
-      // Verify directory index.
-      if (FileName.DirIdx > MaxDirIndex) {
-        ++NumDebugLineErrors;
-        error() << ".debug_line["
-                << format("0x%08" PRIx64,
-                          *toSectionOffset(Die.find(DW_AT_stmt_list)))
-                << "].prologue.file_names[" << FileIndex
-                << "].dir_idx contains an invalid index: " << FileName.DirIdx
-                << "\n";
-      }
-
-      // Check file paths for duplicates.
-      std::string FullPath;
-      const bool HasFullPath = LineTable->getFileNameByIndex(
-          FileIndex, CU->getCompilationDir(),
-          DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, FullPath);
-      assert(HasFullPath && "Invalid index?");
-      (void)HasFullPath;
-      auto It = FullPathMap.find(FullPath);
-      if (It == FullPathMap.end())
-        FullPathMap[FullPath] = FileIndex;
-      else if (It->second != FileIndex) {
-        warn() << ".debug_line["
-               << format("0x%08" PRIx64,
-                         *toSectionOffset(Die.find(DW_AT_stmt_list)))
-               << "].prologue.file_names[" << FileIndex
-               << "] is a duplicate of file_names[" << It->second << "]\n";
-      }
-
-      FileIndex++;
-    }
-
-    // Verify rows.
-    uint64_t PrevAddress = 0;
-    uint32_t RowIndex = 0;
-    for (const auto &Row : LineTable->Rows) {
-      // Verify row address.
-      if (Row.Address.Address < PrevAddress) {
-        ++NumDebugLineErrors;
-        error() << ".debug_line["
-                << format("0x%08" PRIx64,
-                          *toSectionOffset(Die.find(DW_AT_stmt_list)))
-                << "] row[" << RowIndex
-                << "] decreases in address from previous row:\n";
-
-        DWARFDebugLine::Row::dumpTableHeader(OS, 0);
-        if (RowIndex > 0)
-          LineTable->Rows[RowIndex - 1].dump(OS);
-        Row.dump(OS);
-        OS << '\n';
-      }
-
-      // Verify file index.
-      if (!LineTable->hasFileAtIndex(Row.File)) {
-        ++NumDebugLineErrors;
-        bool isDWARF5 = LineTable->Prologue.getVersion() >= 5;
-        error() << ".debug_line["
-                << format("0x%08" PRIx64,
-                          *toSectionOffset(Die.find(DW_AT_stmt_list)))
-                << "][" << RowIndex << "] has invalid file index " << Row.File
-                << " (valid values are [" << (isDWARF5 ? "0," : "1,")
-                << LineTable->Prologue.FileNames.size()
-                << (isDWARF5 ? ")" : "]") << "):\n";
-        DWARFDebugLine::Row::dumpTableHeader(OS, 0);
-        Row.dump(OS);
-        OS << '\n';
-      }
-      if (Row.EndSequence)
-        PrevAddress = 0;
-      else
-        PrevAddress = Row.Address.Address;
-      ++RowIndex;
-    }
-  }
-}
-
-DWARFVerifier::DWARFVerifier(raw_ostream &S, DWARFContext &D,
-                             DIDumpOptions DumpOpts)
-    : OS(S), DCtx(D), DumpOpts(std::move(DumpOpts)), IsObjectFile(false),
-      IsMachOObject(false) {
-  if (const auto *F = DCtx.getDWARFObj().getFile()) {
-    IsObjectFile = F->isRelocatableObject();
-    IsMachOObject = F->isMachO();
-  }
-}
-
-bool DWARFVerifier::handleDebugLine() {
-  NumDebugLineErrors = 0;
-  OS << "Verifying .debug_line...\n";
-  verifyDebugLineStmtOffsets();
-  verifyDebugLineRows();
-  return NumDebugLineErrors == 0;
-}
-
-unsigned DWARFVerifier::verifyAppleAccelTable(const DWARFSection *AccelSection,
-                                              DataExtractor *StrData,
-                                              const char *SectionName) {
-  unsigned NumErrors = 0;
-  DWARFDataExtractor AccelSectionData(DCtx.getDWARFObj(), *AccelSection,
-                                      DCtx.isLittleEndian(), 0);
-  AppleAcceleratorTable AccelTable(AccelSectionData, *StrData);
-
-  OS << "Verifying " << SectionName << "...\n";
-
-  // Verify that the fixed part of the header is not too short.
-  if (!AccelSectionData.isValidOffset(AccelTable.getSizeHdr())) {
-    error() << "Section is too small to fit a section header.\n";
-    return 1;
-  }
-
-  // Verify that the section is not too short.
-  if (Error E = AccelTable.extract()) {
-    error() << toString(std::move(E)) << '\n';
-    return 1;
-  }
-
-  // Verify that all buckets have a valid hash index or are empty.
-  uint32_t NumBuckets = AccelTable.getNumBuckets();
-  uint32_t NumHashes = AccelTable.getNumHashes();
-
-  uint64_t BucketsOffset =
-      AccelTable.getSizeHdr() + AccelTable.getHeaderDataLength();
-  uint64_t HashesBase = BucketsOffset + NumBuckets * 4;
-  uint64_t OffsetsBase = HashesBase + NumHashes * 4;
-  for (uint32_t BucketIdx = 0; BucketIdx < NumBuckets; ++BucketIdx) {
-    uint32_t HashIdx = AccelSectionData.getU32(&BucketsOffset);
-    if (HashIdx >= NumHashes && HashIdx != UINT32_MAX) {
-      error() << format("Bucket[%d] has invalid hash index: %u.\n", BucketIdx,
-                        HashIdx);
-      ++NumErrors;
-    }
-  }
-  uint32_t NumAtoms = AccelTable.getAtomsDesc().size();
-  if (NumAtoms == 0) {
-    error() << "No atoms: failed to read HashData.\n";
-    return 1;
-  }
-  if (!AccelTable.validateForms()) {
-    error() << "Unsupported form: failed to read HashData.\n";
-    return 1;
-  }
-
-  for (uint32_t HashIdx = 0; HashIdx < NumHashes; ++HashIdx) {
-    uint64_t HashOffset = HashesBase + 4 * HashIdx;
-    uint64_t DataOffset = OffsetsBase + 4 * HashIdx;
-    uint32_t Hash = AccelSectionData.getU32(&HashOffset);
-    uint64_t HashDataOffset = AccelSectionData.getU32(&DataOffset);
-    if (!AccelSectionData.isValidOffsetForDataOfSize(HashDataOffset,
-                                                     sizeof(uint64_t))) {
-      error() << format("Hash[%d] has invalid HashData offset: "
-                        "0x%08" PRIx64 ".\n",
-                        HashIdx, HashDataOffset);
-      ++NumErrors;
-    }
-
-    uint64_t StrpOffset;
-    uint64_t StringOffset;
-    uint32_t StringCount = 0;
-    uint64_t Offset;
-    unsigned Tag;
-    while ((StrpOffset = AccelSectionData.getU32(&HashDataOffset)) != 0) {
-      const uint32_t NumHashDataObjects =
-          AccelSectionData.getU32(&HashDataOffset);
-      for (uint32_t HashDataIdx = 0; HashDataIdx < NumHashDataObjects;
-           ++HashDataIdx) {
-        std::tie(Offset, Tag) = AccelTable.readAtoms(&HashDataOffset);
-        auto Die = DCtx.getDIEForOffset(Offset);
-        if (!Die) {
-          const uint32_t BucketIdx =
-              NumBuckets ? (Hash % NumBuckets) : UINT32_MAX;
-          StringOffset = StrpOffset;
-          const char *Name = StrData->getCStr(&StringOffset);
-          if (!Name)
-            Name = "<NULL>";
-
-          error() << format(
-              "%s Bucket[%d] Hash[%d] = 0x%08x "
-              "Str[%u] = 0x%08" PRIx64 " DIE[%d] = 0x%08" PRIx64 " "
-              "is not a valid DIE offset for \"%s\".\n",
-              SectionName, BucketIdx, HashIdx, Hash, StringCount, StrpOffset,
-              HashDataIdx, Offset, Name);
-
-          ++NumErrors;
-          continue;
-        }
-        if ((Tag != dwarf::DW_TAG_null) && (Die.getTag() != Tag)) {
-          error() << "Tag " << dwarf::TagString(Tag)
-                  << " in accelerator table does not match Tag "
-                  << dwarf::TagString(Die.getTag()) << " of DIE[" << HashDataIdx
-                  << "].\n";
-          ++NumErrors;
-        }
-      }
-      ++StringCount;
-    }
-  }
-  return NumErrors;
-}
-
-unsigned
-DWARFVerifier::verifyDebugNamesCULists(const DWARFDebugNames &AccelTable) {
-  // A map from CU offset to the (first) Name Index offset which claims to index
-  // this CU.
-  DenseMap<uint64_t, uint64_t> CUMap;
-  const uint64_t NotIndexed = std::numeric_limits<uint64_t>::max();
-
-  CUMap.reserve(DCtx.getNumCompileUnits());
-  for (const auto &CU : DCtx.compile_units())
-    CUMap[CU->getOffset()] = NotIndexed;
-
-  unsigned NumErrors = 0;
-  for (const DWARFDebugNames::NameIndex &NI : AccelTable) {
-    if (NI.getCUCount() == 0) {
-      error() << formatv("Name Index @ {0:x} does not index any CU\n",
-                         NI.getUnitOffset());
-      ++NumErrors;
-      continue;
-    }
-    for (uint32_t CU = 0, End = NI.getCUCount(); CU < End; ++CU) {
-      uint64_t Offset = NI.getCUOffset(CU);
-      auto Iter = CUMap.find(Offset);
-
-      if (Iter == CUMap.end()) {
-        error() << formatv(
-            "Name Index @ {0:x} references a non-existing CU @ {1:x}\n",
-            NI.getUnitOffset(), Offset);
-        ++NumErrors;
-        continue;
-      }
-
-      if (Iter->second != NotIndexed) {
-        error() << formatv("Name Index @ {0:x} references a CU @ {1:x}, but "
-                           "this CU is already indexed by Name Index @ {2:x}\n",
-                           NI.getUnitOffset(), Offset, Iter->second);
-        continue;
-      }
-      Iter->second = NI.getUnitOffset();
-    }
-  }
-
-  for (const auto &KV : CUMap) {
-    if (KV.second == NotIndexed)
-      warn() << formatv("CU @ {0:x} not covered by any Name Index\n", KV.first);
-  }
-
-  return NumErrors;
-}
-
-unsigned
-DWARFVerifier::verifyNameIndexBuckets(const DWARFDebugNames::NameIndex &NI,
-                                      const DataExtractor &StrData) {
-  struct BucketInfo {
-    uint32_t Bucket;
-    uint32_t Index;
-
-    constexpr BucketInfo(uint32_t Bucket, uint32_t Index)
-        : Bucket(Bucket), Index(Index) {}
-    bool operator<(const BucketInfo &RHS) const { return Index < RHS.Index; }
-  };
-
-  uint32_t NumErrors = 0;
-  if (NI.getBucketCount() == 0) {
-    warn() << formatv("Name Index @ {0:x} does not contain a hash table.\n",
-                      NI.getUnitOffset());
-    return NumErrors;
-  }
-
-  // Build up a list of (Bucket, Index) pairs. We use this later to verify that
-  // each Name is reachable from the appropriate bucket.
-  std::vector<BucketInfo> BucketStarts;
-  BucketStarts.reserve(NI.getBucketCount() + 1);
-  for (uint32_t Bucket = 0, End = NI.getBucketCount(); Bucket < End; ++Bucket) {
-    uint32_t Index = NI.getBucketArrayEntry(Bucket);
-    if (Index > NI.getNameCount()) {
-      error() << formatv("Bucket {0} of Name Index @ {1:x} contains invalid "
-                         "value {2}. Valid range is [0, {3}].\n",
-                         Bucket, NI.getUnitOffset(), Index, NI.getNameCount());
-      ++NumErrors;
-      continue;
-    }
-    if (Index > 0)
-      BucketStarts.emplace_back(Bucket, Index);
-  }
-
-  // If there were any buckets with invalid values, skip further checks as they
-  // will likely produce many errors which will only confuse the actual root
-  // problem.
-  if (NumErrors > 0)
-    return NumErrors;
-
-  // Sort the list in the order of increasing "Index" entries.
-  array_pod_sort(BucketStarts.begin(), BucketStarts.end());
-
-  // Insert a sentinel entry at the end, so we can check that the end of the
-  // table is covered in the loop below.
-  BucketStarts.emplace_back(NI.getBucketCount(), NI.getNameCount() + 1);
-
-  // Loop invariant: NextUncovered is the (1-based) index of the first Name
-  // which is not reachable by any of the buckets we processed so far (and
-  // hasn't been reported as uncovered).
-  uint32_t NextUncovered = 1;
-  for (const BucketInfo &B : BucketStarts) {
-    // Under normal circumstances B.Index be equal to NextUncovered, but it can
-    // be less if a bucket points to names which are already known to be in some
-    // bucket we processed earlier. In that case, we won't trigger this error,
-    // but report the mismatched hash value error instead. (We know the hash
-    // will not match because we have already verified that the name's hash
-    // puts it into the previous bucket.)
-    if (B.Index > NextUncovered) {
-      error() << formatv("Name Index @ {0:x}: Name table entries [{1}, {2}] "
-                         "are not covered by the hash table.\n",
-                         NI.getUnitOffset(), NextUncovered, B.Index - 1);
-      ++NumErrors;
-    }
-    uint32_t Idx = B.Index;
-
-    // The rest of the checks apply only to non-sentinel entries.
-    if (B.Bucket == NI.getBucketCount())
-      break;
-
-    // This triggers if a non-empty bucket points to a name with a mismatched
-    // hash. Clients are likely to interpret this as an empty bucket, because a
-    // mismatched hash signals the end of a bucket, but if this is indeed an
-    // empty bucket, the producer should have signalled this by marking the
-    // bucket as empty.
-    uint32_t FirstHash = NI.getHashArrayEntry(Idx);
-    if (FirstHash % NI.getBucketCount() != B.Bucket) {
-      error() << formatv(
-          "Name Index @ {0:x}: Bucket {1} is not empty but points to a "
-          "mismatched hash value {2:x} (belonging to bucket {3}).\n",
-          NI.getUnitOffset(), B.Bucket, FirstHash,
-          FirstHash % NI.getBucketCount());
-      ++NumErrors;
-    }
-
-    // This find the end of this bucket and also verifies that all the hashes in
-    // this bucket are correct by comparing the stored hashes to the ones we
-    // compute ourselves.
-    while (Idx <= NI.getNameCount()) {
-      uint32_t Hash = NI.getHashArrayEntry(Idx);
-      if (Hash % NI.getBucketCount() != B.Bucket)
-        break;
-
-      const char *Str = NI.getNameTableEntry(Idx).getString();
-      if (caseFoldingDjbHash(Str) != Hash) {
-        error() << formatv("Name Index @ {0:x}: String ({1}) at index {2} "
-                           "hashes to {3:x}, but "
-                           "the Name Index hash is {4:x}\n",
-                           NI.getUnitOffset(), Str, Idx,
-                           caseFoldingDjbHash(Str), Hash);
-        ++NumErrors;
-      }
-
-      ++Idx;
-    }
-    NextUncovered = std::max(NextUncovered, Idx);
-  }
-  return NumErrors;
-}
-
-unsigned DWARFVerifier::verifyNameIndexAttribute(
-    const DWARFDebugNames::NameIndex &NI, const DWARFDebugNames::Abbrev &Abbr,
-    DWARFDebugNames::AttributeEncoding AttrEnc) {
-  StringRef FormName = dwarf::FormEncodingString(AttrEnc.Form);
-  if (FormName.empty()) {
-    error() << formatv("NameIndex @ {0:x}: Abbreviation {1:x}: {2} uses an "
-                       "unknown form: {3}.\n",
-                       NI.getUnitOffset(), Abbr.Code, AttrEnc.Index,
-                       AttrEnc.Form);
-    return 1;
-  }
-
-  if (AttrEnc.Index == DW_IDX_type_hash) {
-    if (AttrEnc.Form != dwarf::DW_FORM_data8) {
-      error() << formatv(
-          "NameIndex @ {0:x}: Abbreviation {1:x}: DW_IDX_type_hash "
-          "uses an unexpected form {2} (should be {3}).\n",
-          NI.getUnitOffset(), Abbr.Code, AttrEnc.Form, dwarf::DW_FORM_data8);
-      return 1;
-    }
-  }
-
-  // A list of known index attributes and their expected form classes.
-  // DW_IDX_type_hash is handled specially in the check above, as it has a
-  // specific form (not just a form class) we should expect.
-  struct FormClassTable {
-    dwarf::Index Index;
-    DWARFFormValue::FormClass Class;
-    StringLiteral ClassName;
-  };
-  static constexpr FormClassTable Table[] = {
-      {dwarf::DW_IDX_compile_unit, DWARFFormValue::FC_Constant, {"constant"}},
-      {dwarf::DW_IDX_type_unit, DWARFFormValue::FC_Constant, {"constant"}},
-      {dwarf::DW_IDX_die_offset, DWARFFormValue::FC_Reference, {"reference"}},
-      {dwarf::DW_IDX_parent, DWARFFormValue::FC_Constant, {"constant"}},
-  };
-
-  ArrayRef<FormClassTable> TableRef(Table);
-  auto Iter = find_if(TableRef, [AttrEnc](const FormClassTable &T) {
-    return T.Index == AttrEnc.Index;
-  });
-  if (Iter == TableRef.end()) {
-    warn() << formatv("NameIndex @ {0:x}: Abbreviation {1:x} contains an "
-                      "unknown index attribute: {2}.\n",
-                      NI.getUnitOffset(), Abbr.Code, AttrEnc.Index);
-    return 0;
-  }
-
-  if (!DWARFFormValue(AttrEnc.Form).isFormClass(Iter->Class)) {
-    error() << formatv("NameIndex @ {0:x}: Abbreviation {1:x}: {2} uses an "
-                       "unexpected form {3} (expected form class {4}).\n",
-                       NI.getUnitOffset(), Abbr.Code, AttrEnc.Index,
-                       AttrEnc.Form, Iter->ClassName);
-    return 1;
-  }
-  return 0;
-}
-
-unsigned
-DWARFVerifier::verifyNameIndexAbbrevs(const DWARFDebugNames::NameIndex &NI) {
-  if (NI.getLocalTUCount() + NI.getForeignTUCount() > 0) {
-    warn() << formatv("Name Index @ {0:x}: Verifying indexes of type units is "
-                      "not currently supported.\n",
-                      NI.getUnitOffset());
-    return 0;
-  }
-
-  unsigned NumErrors = 0;
-  for (const auto &Abbrev : NI.getAbbrevs()) {
-    StringRef TagName = dwarf::TagString(Abbrev.Tag);
-    if (TagName.empty()) {
-      warn() << formatv("NameIndex @ {0:x}: Abbreviation {1:x} references an "
-                        "unknown tag: {2}.\n",
-                        NI.getUnitOffset(), Abbrev.Code, Abbrev.Tag);
-    }
-    SmallSet<unsigned, 5> Attributes;
-    for (const auto &AttrEnc : Abbrev.Attributes) {
-      if (!Attributes.insert(AttrEnc.Index).second) {
-        error() << formatv("NameIndex @ {0:x}: Abbreviation {1:x} contains "
-                           "multiple {2} attributes.\n",
-                           NI.getUnitOffset(), Abbrev.Code, AttrEnc.Index);
-        ++NumErrors;
-        continue;
-      }
-      NumErrors += verifyNameIndexAttribute(NI, Abbrev, AttrEnc);
-    }
-
-    if (NI.getCUCount() > 1 && !Attributes.count(dwarf::DW_IDX_compile_unit)) {
-      error() << formatv("NameIndex @ {0:x}: Indexing multiple compile units "
-                         "and abbreviation {1:x} has no {2} attribute.\n",
-                         NI.getUnitOffset(), Abbrev.Code,
-                         dwarf::DW_IDX_compile_unit);
-      ++NumErrors;
-    }
-    if (!Attributes.count(dwarf::DW_IDX_die_offset)) {
-      error() << formatv(
-          "NameIndex @ {0:x}: Abbreviation {1:x} has no {2} attribute.\n",
-          NI.getUnitOffset(), Abbrev.Code, dwarf::DW_IDX_die_offset);
-      ++NumErrors;
-    }
-  }
-  return NumErrors;
-}
-
-static SmallVector<StringRef, 2> getNames(const DWARFDie &DIE,
-                                          bool IncludeLinkageName = true) {
-  SmallVector<StringRef, 2> Result;
-  if (const char *Str = DIE.getName(DINameKind::ShortName))
-    Result.emplace_back(Str);
-  else if (DIE.getTag() == dwarf::DW_TAG_namespace)
-    Result.emplace_back("(anonymous namespace)");
-
-  if (IncludeLinkageName) {
-    if (const char *Str = DIE.getName(DINameKind::LinkageName)) {
-      if (Result.empty() || Result[0] != Str)
-        Result.emplace_back(Str);
-    }
-  }
-
-  return Result;
-}
-
-unsigned DWARFVerifier::verifyNameIndexEntries(
-    const DWARFDebugNames::NameIndex &NI,
-    const DWARFDebugNames::NameTableEntry &NTE) {
-  // Verifying type unit indexes not supported.
-  if (NI.getLocalTUCount() + NI.getForeignTUCount() > 0)
-    return 0;
-
-  const char *CStr = NTE.getString();
-  if (!CStr) {
-    error() << formatv(
-        "Name Index @ {0:x}: Unable to get string associated with name {1}.\n",
-        NI.getUnitOffset(), NTE.getIndex());
-    return 1;
-  }
-  StringRef Str(CStr);
-
-  unsigned NumErrors = 0;
-  unsigned NumEntries = 0;
-  uint64_t EntryID = NTE.getEntryOffset();
-  uint64_t NextEntryID = EntryID;
-  Expected<DWARFDebugNames::Entry> EntryOr = NI.getEntry(&NextEntryID);
-  for (; EntryOr; ++NumEntries, EntryID = NextEntryID,
-                                EntryOr = NI.getEntry(&NextEntryID)) {
-    uint32_t CUIndex = *EntryOr->getCUIndex();
-    if (CUIndex > NI.getCUCount()) {
-      error() << formatv("Name Index @ {0:x}: Entry @ {1:x} contains an "
-                         "invalid CU index ({2}).\n",
-                         NI.getUnitOffset(), EntryID, CUIndex);
-      ++NumErrors;
-      continue;
-    }
-    uint64_t CUOffset = NI.getCUOffset(CUIndex);
-    uint64_t DIEOffset = CUOffset + *EntryOr->getDIEUnitOffset();
-    DWARFDie DIE = DCtx.getDIEForOffset(DIEOffset);
-    if (!DIE) {
-      error() << formatv("Name Index @ {0:x}: Entry @ {1:x} references a "
-                         "non-existing DIE @ {2:x}.\n",
-                         NI.getUnitOffset(), EntryID, DIEOffset);
-      ++NumErrors;
-      continue;
-    }
-    if (DIE.getDwarfUnit()->getOffset() != CUOffset) {
-      error() << formatv("Name Index @ {0:x}: Entry @ {1:x}: mismatched CU of "
-                         "DIE @ {2:x}: index - {3:x}; debug_info - {4:x}.\n",
-                         NI.getUnitOffset(), EntryID, DIEOffset, CUOffset,
-                         DIE.getDwarfUnit()->getOffset());
-      ++NumErrors;
-    }
-    if (DIE.getTag() != EntryOr->tag()) {
-      error() << formatv("Name Index @ {0:x}: Entry @ {1:x}: mismatched Tag of "
-                         "DIE @ {2:x}: index - {3}; debug_info - {4}.\n",
-                         NI.getUnitOffset(), EntryID, DIEOffset, EntryOr->tag(),
-                         DIE.getTag());
-      ++NumErrors;
-    }
-
-    auto EntryNames = getNames(DIE);
-    if (!is_contained(EntryNames, Str)) {
-      error() << formatv("Name Index @ {0:x}: Entry @ {1:x}: mismatched Name "
-                         "of DIE @ {2:x}: index - {3}; debug_info - {4}.\n",
-                         NI.getUnitOffset(), EntryID, DIEOffset, Str,
-                         make_range(EntryNames.begin(), EntryNames.end()));
-      ++NumErrors;
-    }
-  }
-  handleAllErrors(EntryOr.takeError(),
-                  [&](const DWARFDebugNames::SentinelError &) {
-                    if (NumEntries > 0)
-                      return;
-                    error() << formatv("Name Index @ {0:x}: Name {1} ({2}) is "
-                                       "not associated with any entries.\n",
-                                       NI.getUnitOffset(), NTE.getIndex(), Str);
-                    ++NumErrors;
-                  },
-                  [&](const ErrorInfoBase &Info) {
-                    error()
-                        << formatv("Name Index @ {0:x}: Name {1} ({2}): {3}\n",
-                                   NI.getUnitOffset(), NTE.getIndex(), Str,
-                                   Info.message());
-                    ++NumErrors;
-                  });
-  return NumErrors;
-}
-
-static bool isVariableIndexable(const DWARFDie &Die, DWARFContext &DCtx) {
-  Expected<std::vector<DWARFLocationExpression>> Loc =
-      Die.getLocations(DW_AT_location);
-  if (!Loc) {
-    consumeError(Loc.takeError());
-    return false;
-  }
-  DWARFUnit *U = Die.getDwarfUnit();
-  for (const auto &Entry : *Loc) {
-    DataExtractor Data(toStringRef(Entry.Expr), DCtx.isLittleEndian(),
-                       U->getAddressByteSize());
-    DWARFExpression Expression(Data, U->getAddressByteSize(),
-                               U->getFormParams().Format);
-    bool IsInteresting = any_of(Expression, [](DWARFExpression::Operation &Op) {
-      return !Op.isError() && (Op.getCode() == DW_OP_addr ||
-                               Op.getCode() == DW_OP_form_tls_address ||
-                               Op.getCode() == DW_OP_GNU_push_tls_address);
-    });
-    if (IsInteresting)
-      return true;
-  }
-  return false;
-}
-
-unsigned DWARFVerifier::verifyNameIndexCompleteness(
-    const DWARFDie &Die, const DWARFDebugNames::NameIndex &NI) {
-
-  // First check, if the Die should be indexed. The code follows the DWARF v5
-  // wording as closely as possible.
-
-  // "All non-defining declarations (that is, debugging information entries
-  // with a DW_AT_declaration attribute) are excluded."
-  if (Die.find(DW_AT_declaration))
-    return 0;
-
-  // "DW_TAG_namespace debugging information entries without a DW_AT_name
-  // attribute are included with the name “(anonymous namespace)”.
-  // All other debugging information entries without a DW_AT_name attribute
-  // are excluded."
-  // "If a subprogram or inlined subroutine is included, and has a
-  // DW_AT_linkage_name attribute, there will be an additional index entry for
-  // the linkage name."
-  auto IncludeLinkageName = Die.getTag() == DW_TAG_subprogram ||
-                            Die.getTag() == DW_TAG_inlined_subroutine;
-  auto EntryNames = getNames(Die, IncludeLinkageName);
-  if (EntryNames.empty())
-    return 0;
-
-  // We deviate from the specification here, which says:
-  // "The name index must contain an entry for each debugging information entry
-  // that defines a named subprogram, label, variable, type, or namespace,
-  // subject to ..."
-  // Explicitly exclude all TAGs that we know shouldn't be indexed.
-  switch (Die.getTag()) {
-  // Compile units and modules have names but shouldn't be indexed.
-  case DW_TAG_compile_unit:
-  case DW_TAG_module:
-    return 0;
-
-  // Function and template parameters are not globally visible, so we shouldn't
-  // index them.
-  case DW_TAG_formal_parameter:
-  case DW_TAG_template_value_parameter:
-  case DW_TAG_template_type_parameter:
-  case DW_TAG_GNU_template_parameter_pack:
-  case DW_TAG_GNU_template_template_param:
-    return 0;
-
-  // Object members aren't globally visible.
-  case DW_TAG_member:
-    return 0;
-
-  // According to a strict reading of the specification, enumerators should not
-  // be indexed (and LLVM currently does not do that). However, this causes
-  // problems for the debuggers, so we may need to reconsider this.
-  case DW_TAG_enumerator:
-    return 0;
-
-  // Imported declarations should not be indexed according to the specification
-  // and LLVM currently does not do that.
-  case DW_TAG_imported_declaration:
-    return 0;
-
-  // "DW_TAG_subprogram, DW_TAG_inlined_subroutine, and DW_TAG_label debugging
-  // information entries without an address attribute (DW_AT_low_pc,
-  // DW_AT_high_pc, DW_AT_ranges, or DW_AT_entry_pc) are excluded."
-  case DW_TAG_subprogram:
-  case DW_TAG_inlined_subroutine:
-  case DW_TAG_label:
-    if (Die.findRecursively(
-            {DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_entry_pc}))
-      break;
-    return 0;
-
-  // "DW_TAG_variable debugging information entries with a DW_AT_location
-  // attribute that includes a DW_OP_addr or DW_OP_form_tls_address operator are
-  // included; otherwise, they are excluded."
-  //
-  // LLVM extension: We also add DW_OP_GNU_push_tls_address to this list.
-  case DW_TAG_variable:
-    if (isVariableIndexable(Die, DCtx))
-      break;
-    return 0;
-
-  default:
-    break;
-  }
-
-  // Now we know that our Die should be present in the Index. Let's check if
-  // that's the case.
-  unsigned NumErrors = 0;
-  uint64_t DieUnitOffset = Die.getOffset() - Die.getDwarfUnit()->getOffset();
-  for (StringRef Name : EntryNames) {
-    if (none_of(NI.equal_range(Name), [&](const DWARFDebugNames::Entry &E) {
-          return E.getDIEUnitOffset() == DieUnitOffset;
-        })) {
-      error() << formatv("Name Index @ {0:x}: Entry for DIE @ {1:x} ({2}) with "
-                         "name {3} missing.\n",
-                         NI.getUnitOffset(), Die.getOffset(), Die.getTag(),
-                         Name);
-      ++NumErrors;
-    }
-  }
-  return NumErrors;
-}
-
-unsigned DWARFVerifier::verifyDebugNames(const DWARFSection &AccelSection,
-                                         const DataExtractor &StrData) {
-  unsigned NumErrors = 0;
-  DWARFDataExtractor AccelSectionData(DCtx.getDWARFObj(), AccelSection,
-                                      DCtx.isLittleEndian(), 0);
-  DWARFDebugNames AccelTable(AccelSectionData, StrData);
-
-  OS << "Verifying .debug_names...\n";
-
-  // This verifies that we can read individual name indices and their
-  // abbreviation tables.
-  if (Error E = AccelTable.extract()) {
-    error() << toString(std::move(E)) << '\n';
-    return 1;
-  }
-
-  NumErrors += verifyDebugNamesCULists(AccelTable);
-  for (const auto &NI : AccelTable)
-    NumErrors += verifyNameIndexBuckets(NI, StrData);
-  for (const auto &NI : AccelTable)
-    NumErrors += verifyNameIndexAbbrevs(NI);
-
-  // Don't attempt Entry validation if any of the previous checks found errors
-  if (NumErrors > 0)
-    return NumErrors;
-  for (const auto &NI : AccelTable)
-    for (DWARFDebugNames::NameTableEntry NTE : NI)
-      NumErrors += verifyNameIndexEntries(NI, NTE);
-
-  if (NumErrors > 0)
-    return NumErrors;
-
-  for (const std::unique_ptr<DWARFUnit> &U : DCtx.compile_units()) {
-    if (const DWARFDebugNames::NameIndex *NI =
-            AccelTable.getCUNameIndex(U->getOffset())) {
-      auto *CU = cast<DWARFCompileUnit>(U.get());
-      for (const DWARFDebugInfoEntry &Die : CU->dies())
-        NumErrors += verifyNameIndexCompleteness(DWARFDie(CU, &Die), *NI);
-    }
-  }
-  return NumErrors;
-}
-
-bool DWARFVerifier::handleAccelTables() {
-  const DWARFObject &D = DCtx.getDWARFObj();
-  DataExtractor StrData(D.getStrSection(), DCtx.isLittleEndian(), 0);
-  unsigned NumErrors = 0;
-  if (!D.getAppleNamesSection().Data.empty())
-    NumErrors += verifyAppleAccelTable(&D.getAppleNamesSection(), &StrData,
-                                       ".apple_names");
-  if (!D.getAppleTypesSection().Data.empty())
-    NumErrors += verifyAppleAccelTable(&D.getAppleTypesSection(), &StrData,
-                                       ".apple_types");
-  if (!D.getAppleNamespacesSection().Data.empty())
-    NumErrors += verifyAppleAccelTable(&D.getAppleNamespacesSection(), &StrData,
-                                       ".apple_namespaces");
-  if (!D.getAppleObjCSection().Data.empty())
-    NumErrors += verifyAppleAccelTable(&D.getAppleObjCSection(), &StrData,
-                                       ".apple_objc");
-
-  if (!D.getNamesSection().Data.empty())
-    NumErrors += verifyDebugNames(D.getNamesSection(), StrData);
-  return NumErrors == 0;
-}
-
-raw_ostream &DWARFVerifier::error() const { return WithColor::error(OS); }
-
-raw_ostream &DWARFVerifier::warn() const { return WithColor::warning(OS); }
-
-raw_ostream &DWARFVerifier::note() const { return WithColor::note(OS); }
-
-raw_ostream &DWARFVerifier::dump(const DWARFDie &Die, unsigned indent) const {
-  Die.dump(OS, indent, DumpOpts);
-  return OS;
-}
+  default: 
+    break; 
+  } 
+  return NumErrors; 
+} 
+ 
+unsigned DWARFVerifier::verifyDebugInfoForm(const DWARFDie &Die, 
+                                            DWARFAttribute &AttrValue) { 
+  const DWARFObject &DObj = DCtx.getDWARFObj(); 
+  auto DieCU = Die.getDwarfUnit(); 
+  unsigned NumErrors = 0; 
+  const auto Form = AttrValue.Value.getForm(); 
+  switch (Form) { 
+  case DW_FORM_ref1: 
+  case DW_FORM_ref2: 
+  case DW_FORM_ref4: 
+  case DW_FORM_ref8: 
+  case DW_FORM_ref_udata: { 
+    // Verify all CU relative references are valid CU offsets. 
+    Optional<uint64_t> RefVal = AttrValue.Value.getAsReference(); 
+    assert(RefVal); 
+    if (RefVal) { 
+      auto CUSize = DieCU->getNextUnitOffset() - DieCU->getOffset(); 
+      auto CUOffset = AttrValue.Value.getRawUValue(); 
+      if (CUOffset >= CUSize) { 
+        ++NumErrors; 
+        error() << FormEncodingString(Form) << " CU offset " 
+                << format("0x%08" PRIx64, CUOffset) 
+                << " is invalid (must be less than CU size of " 
+                << format("0x%08" PRIx64, CUSize) << "):\n"; 
+        Die.dump(OS, 0, DumpOpts); 
+        dump(Die) << '\n'; 
+      } else { 
+        // Valid reference, but we will verify it points to an actual 
+        // DIE later. 
+        ReferenceToDIEOffsets[*RefVal].insert(Die.getOffset()); 
+      } 
+    } 
+    break; 
+  } 
+  case DW_FORM_ref_addr: { 
+    // Verify all absolute DIE references have valid offsets in the 
+    // .debug_info section. 
+    Optional<uint64_t> RefVal = AttrValue.Value.getAsReference(); 
+    assert(RefVal); 
+    if (RefVal) { 
+      if (*RefVal >= DieCU->getInfoSection().Data.size()) { 
+        ++NumErrors; 
+        error() << "DW_FORM_ref_addr offset beyond .debug_info " 
+                   "bounds:\n"; 
+        dump(Die) << '\n'; 
+      } else { 
+        // Valid reference, but we will verify it points to an actual 
+        // DIE later. 
+        ReferenceToDIEOffsets[*RefVal].insert(Die.getOffset()); 
+      } 
+    } 
+    break; 
+  } 
+  case DW_FORM_strp: { 
+    auto SecOffset = AttrValue.Value.getAsSectionOffset(); 
+    assert(SecOffset); // DW_FORM_strp is a section offset. 
+    if (SecOffset && *SecOffset >= DObj.getStrSection().size()) { 
+      ++NumErrors; 
+      error() << "DW_FORM_strp offset beyond .debug_str bounds:\n"; 
+      dump(Die) << '\n'; 
+    } 
+    break; 
+  } 
+  case DW_FORM_strx: 
+  case DW_FORM_strx1: 
+  case DW_FORM_strx2: 
+  case DW_FORM_strx3: 
+  case DW_FORM_strx4: { 
+    auto Index = AttrValue.Value.getRawUValue(); 
+    auto DieCU = Die.getDwarfUnit(); 
+    // Check that we have a valid DWARF v5 string offsets table. 
+    if (!DieCU->getStringOffsetsTableContribution()) { 
+      ++NumErrors; 
+      error() << FormEncodingString(Form) 
+              << " used without a valid string offsets table:\n"; 
+      dump(Die) << '\n'; 
+      break; 
+    } 
+    // Check that the index is within the bounds of the section. 
+    unsigned ItemSize = DieCU->getDwarfStringOffsetsByteSize(); 
+    // Use a 64-bit type to calculate the offset to guard against overflow. 
+    uint64_t Offset = 
+        (uint64_t)DieCU->getStringOffsetsBase() + Index * ItemSize; 
+    if (DObj.getStrOffsetsSection().Data.size() < Offset + ItemSize) { 
+      ++NumErrors; 
+      error() << FormEncodingString(Form) << " uses index " 
+              << format("%" PRIu64, Index) << ", which is too large:\n"; 
+      dump(Die) << '\n'; 
+      break; 
+    } 
+    // Check that the string offset is valid. 
+    uint64_t StringOffset = *DieCU->getStringOffsetSectionItem(Index); 
+    if (StringOffset >= DObj.getStrSection().size()) { 
+      ++NumErrors; 
+      error() << FormEncodingString(Form) << " uses index " 
+              << format("%" PRIu64, Index) 
+              << ", but the referenced string" 
+                 " offset is beyond .debug_str bounds:\n"; 
+      dump(Die) << '\n'; 
+    } 
+    break; 
+  } 
+  default: 
+    break; 
+  } 
+  return NumErrors; 
+} 
+ 
+unsigned DWARFVerifier::verifyDebugInfoReferences() { 
+  // Take all references and make sure they point to an actual DIE by 
+  // getting the DIE by offset and emitting an error 
+  OS << "Verifying .debug_info references...\n"; 
+  unsigned NumErrors = 0; 
+  for (const std::pair<const uint64_t, std::set<uint64_t>> &Pair : 
+       ReferenceToDIEOffsets) { 
+    if (DCtx.getDIEForOffset(Pair.first)) 
+      continue; 
+    ++NumErrors; 
+    error() << "invalid DIE reference " << format("0x%08" PRIx64, Pair.first) 
+            << ". Offset is in between DIEs:\n"; 
+    for (auto Offset : Pair.second) 
+      dump(DCtx.getDIEForOffset(Offset)) << '\n'; 
+    OS << "\n"; 
+  } 
+  return NumErrors; 
+} 
+ 
+void DWARFVerifier::verifyDebugLineStmtOffsets() { 
+  std::map<uint64_t, DWARFDie> StmtListToDie; 
+  for (const auto &CU : DCtx.compile_units()) { 
+    auto Die = CU->getUnitDIE(); 
+    // Get the attribute value as a section offset. No need to produce an 
+    // error here if the encoding isn't correct because we validate this in 
+    // the .debug_info verifier. 
+    auto StmtSectionOffset = toSectionOffset(Die.find(DW_AT_stmt_list)); 
+    if (!StmtSectionOffset) 
+      continue; 
+    const uint64_t LineTableOffset = *StmtSectionOffset; 
+    auto LineTable = DCtx.getLineTableForUnit(CU.get()); 
+    if (LineTableOffset < DCtx.getDWARFObj().getLineSection().Data.size()) { 
+      if (!LineTable) { 
+        ++NumDebugLineErrors; 
+        error() << ".debug_line[" << format("0x%08" PRIx64, LineTableOffset) 
+                << "] was not able to be parsed for CU:\n"; 
+        dump(Die) << '\n'; 
+        continue; 
+      } 
+    } else { 
+      // Make sure we don't get a valid line table back if the offset is wrong. 
+      assert(LineTable == nullptr); 
+      // Skip this line table as it isn't valid. No need to create an error 
+      // here because we validate this in the .debug_info verifier. 
+      continue; 
+    } 
+    auto Iter = StmtListToDie.find(LineTableOffset); 
+    if (Iter != StmtListToDie.end()) { 
+      ++NumDebugLineErrors; 
+      error() << "two compile unit DIEs, " 
+              << format("0x%08" PRIx64, Iter->second.getOffset()) << " and " 
+              << format("0x%08" PRIx64, Die.getOffset()) 
+              << ", have the same DW_AT_stmt_list section offset:\n"; 
+      dump(Iter->second); 
+      dump(Die) << '\n'; 
+      // Already verified this line table before, no need to do it again. 
+      continue; 
+    } 
+    StmtListToDie[LineTableOffset] = Die; 
+  } 
+} 
+ 
+void DWARFVerifier::verifyDebugLineRows() { 
+  for (const auto &CU : DCtx.compile_units()) { 
+    auto Die = CU->getUnitDIE(); 
+    auto LineTable = DCtx.getLineTableForUnit(CU.get()); 
+    // If there is no line table we will have created an error in the 
+    // .debug_info verifier or in verifyDebugLineStmtOffsets(). 
+    if (!LineTable) 
+      continue; 
+ 
+    // Verify prologue. 
+    uint32_t MaxDirIndex = LineTable->Prologue.IncludeDirectories.size(); 
+    uint32_t FileIndex = 1; 
+    StringMap<uint16_t> FullPathMap; 
+    for (const auto &FileName : LineTable->Prologue.FileNames) { 
+      // Verify directory index. 
+      if (FileName.DirIdx > MaxDirIndex) { 
+        ++NumDebugLineErrors; 
+        error() << ".debug_line[" 
+                << format("0x%08" PRIx64, 
+                          *toSectionOffset(Die.find(DW_AT_stmt_list))) 
+                << "].prologue.file_names[" << FileIndex 
+                << "].dir_idx contains an invalid index: " << FileName.DirIdx 
+                << "\n"; 
+      } 
+ 
+      // Check file paths for duplicates. 
+      std::string FullPath; 
+      const bool HasFullPath = LineTable->getFileNameByIndex( 
+          FileIndex, CU->getCompilationDir(), 
+          DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, FullPath); 
+      assert(HasFullPath && "Invalid index?"); 
+      (void)HasFullPath; 
+      auto It = FullPathMap.find(FullPath); 
+      if (It == FullPathMap.end()) 
+        FullPathMap[FullPath] = FileIndex; 
+      else if (It->second != FileIndex) { 
+        warn() << ".debug_line[" 
+               << format("0x%08" PRIx64, 
+                         *toSectionOffset(Die.find(DW_AT_stmt_list))) 
+               << "].prologue.file_names[" << FileIndex 
+               << "] is a duplicate of file_names[" << It->second << "]\n"; 
+      } 
+ 
+      FileIndex++; 
+    } 
+ 
+    // Verify rows. 
+    uint64_t PrevAddress = 0; 
+    uint32_t RowIndex = 0; 
+    for (const auto &Row : LineTable->Rows) { 
+      // Verify row address. 
+      if (Row.Address.Address < PrevAddress) { 
+        ++NumDebugLineErrors; 
+        error() << ".debug_line[" 
+                << format("0x%08" PRIx64, 
+                          *toSectionOffset(Die.find(DW_AT_stmt_list))) 
+                << "] row[" << RowIndex 
+                << "] decreases in address from previous row:\n"; 
+ 
+        DWARFDebugLine::Row::dumpTableHeader(OS, 0); 
+        if (RowIndex > 0) 
+          LineTable->Rows[RowIndex - 1].dump(OS); 
+        Row.dump(OS); 
+        OS << '\n'; 
+      } 
+ 
+      // Verify file index. 
+      if (!LineTable->hasFileAtIndex(Row.File)) { 
+        ++NumDebugLineErrors; 
+        bool isDWARF5 = LineTable->Prologue.getVersion() >= 5; 
+        error() << ".debug_line[" 
+                << format("0x%08" PRIx64, 
+                          *toSectionOffset(Die.find(DW_AT_stmt_list))) 
+                << "][" << RowIndex << "] has invalid file index " << Row.File 
+                << " (valid values are [" << (isDWARF5 ? "0," : "1,") 
+                << LineTable->Prologue.FileNames.size() 
+                << (isDWARF5 ? ")" : "]") << "):\n"; 
+        DWARFDebugLine::Row::dumpTableHeader(OS, 0); 
+        Row.dump(OS); 
+        OS << '\n'; 
+      } 
+      if (Row.EndSequence) 
+        PrevAddress = 0; 
+      else 
+        PrevAddress = Row.Address.Address; 
+      ++RowIndex; 
+    } 
+  } 
+} 
+ 
+DWARFVerifier::DWARFVerifier(raw_ostream &S, DWARFContext &D, 
+                             DIDumpOptions DumpOpts) 
+    : OS(S), DCtx(D), DumpOpts(std::move(DumpOpts)), IsObjectFile(false), 
+      IsMachOObject(false) { 
+  if (const auto *F = DCtx.getDWARFObj().getFile()) { 
+    IsObjectFile = F->isRelocatableObject(); 
+    IsMachOObject = F->isMachO(); 
+  } 
+} 
+ 
+bool DWARFVerifier::handleDebugLine() { 
+  NumDebugLineErrors = 0; 
+  OS << "Verifying .debug_line...\n"; 
+  verifyDebugLineStmtOffsets(); 
+  verifyDebugLineRows(); 
+  return NumDebugLineErrors == 0; 
+} 
+ 
+unsigned DWARFVerifier::verifyAppleAccelTable(const DWARFSection *AccelSection, 
+                                              DataExtractor *StrData, 
+                                              const char *SectionName) { 
+  unsigned NumErrors = 0; 
+  DWARFDataExtractor AccelSectionData(DCtx.getDWARFObj(), *AccelSection, 
+                                      DCtx.isLittleEndian(), 0); 
+  AppleAcceleratorTable AccelTable(AccelSectionData, *StrData); 
+ 
+  OS << "Verifying " << SectionName << "...\n"; 
+ 
+  // Verify that the fixed part of the header is not too short. 
+  if (!AccelSectionData.isValidOffset(AccelTable.getSizeHdr())) { 
+    error() << "Section is too small to fit a section header.\n"; 
+    return 1; 
+  } 
+ 
+  // Verify that the section is not too short. 
+  if (Error E = AccelTable.extract()) { 
+    error() << toString(std::move(E)) << '\n'; 
+    return 1; 
+  } 
+ 
+  // Verify that all buckets have a valid hash index or are empty. 
+  uint32_t NumBuckets = AccelTable.getNumBuckets(); 
+  uint32_t NumHashes = AccelTable.getNumHashes(); 
+ 
+  uint64_t BucketsOffset = 
+      AccelTable.getSizeHdr() + AccelTable.getHeaderDataLength(); 
+  uint64_t HashesBase = BucketsOffset + NumBuckets * 4; 
+  uint64_t OffsetsBase = HashesBase + NumHashes * 4; 
+  for (uint32_t BucketIdx = 0; BucketIdx < NumBuckets; ++BucketIdx) { 
+    uint32_t HashIdx = AccelSectionData.getU32(&BucketsOffset); 
+    if (HashIdx >= NumHashes && HashIdx != UINT32_MAX) { 
+      error() << format("Bucket[%d] has invalid hash index: %u.\n", BucketIdx, 
+                        HashIdx); 
+      ++NumErrors; 
+    } 
+  } 
+  uint32_t NumAtoms = AccelTable.getAtomsDesc().size(); 
+  if (NumAtoms == 0) { 
+    error() << "No atoms: failed to read HashData.\n"; 
+    return 1; 
+  } 
+  if (!AccelTable.validateForms()) { 
+    error() << "Unsupported form: failed to read HashData.\n"; 
+    return 1; 
+  } 
+ 
+  for (uint32_t HashIdx = 0; HashIdx < NumHashes; ++HashIdx) { 
+    uint64_t HashOffset = HashesBase + 4 * HashIdx; 
+    uint64_t DataOffset = OffsetsBase + 4 * HashIdx; 
+    uint32_t Hash = AccelSectionData.getU32(&HashOffset); 
+    uint64_t HashDataOffset = AccelSectionData.getU32(&DataOffset); 
+    if (!AccelSectionData.isValidOffsetForDataOfSize(HashDataOffset, 
+                                                     sizeof(uint64_t))) { 
+      error() << format("Hash[%d] has invalid HashData offset: " 
+                        "0x%08" PRIx64 ".\n", 
+                        HashIdx, HashDataOffset); 
+      ++NumErrors; 
+    } 
+ 
+    uint64_t StrpOffset; 
+    uint64_t StringOffset; 
+    uint32_t StringCount = 0; 
+    uint64_t Offset; 
+    unsigned Tag; 
+    while ((StrpOffset = AccelSectionData.getU32(&HashDataOffset)) != 0) { 
+      const uint32_t NumHashDataObjects = 
+          AccelSectionData.getU32(&HashDataOffset); 
+      for (uint32_t HashDataIdx = 0; HashDataIdx < NumHashDataObjects; 
+           ++HashDataIdx) { 
+        std::tie(Offset, Tag) = AccelTable.readAtoms(&HashDataOffset); 
+        auto Die = DCtx.getDIEForOffset(Offset); 
+        if (!Die) { 
+          const uint32_t BucketIdx = 
+              NumBuckets ? (Hash % NumBuckets) : UINT32_MAX; 
+          StringOffset = StrpOffset; 
+          const char *Name = StrData->getCStr(&StringOffset); 
+          if (!Name) 
+            Name = "<NULL>"; 
+ 
+          error() << format( 
+              "%s Bucket[%d] Hash[%d] = 0x%08x " 
+              "Str[%u] = 0x%08" PRIx64 " DIE[%d] = 0x%08" PRIx64 " " 
+              "is not a valid DIE offset for \"%s\".\n", 
+              SectionName, BucketIdx, HashIdx, Hash, StringCount, StrpOffset, 
+              HashDataIdx, Offset, Name); 
+ 
+          ++NumErrors; 
+          continue; 
+        } 
+        if ((Tag != dwarf::DW_TAG_null) && (Die.getTag() != Tag)) { 
+          error() << "Tag " << dwarf::TagString(Tag) 
+                  << " in accelerator table does not match Tag " 
+                  << dwarf::TagString(Die.getTag()) << " of DIE[" << HashDataIdx 
+                  << "].\n"; 
+          ++NumErrors; 
+        } 
+      } 
+      ++StringCount; 
+    } 
+  } 
+  return NumErrors; 
+} 
+ 
+unsigned 
+DWARFVerifier::verifyDebugNamesCULists(const DWARFDebugNames &AccelTable) { 
+  // A map from CU offset to the (first) Name Index offset which claims to index 
+  // this CU. 
+  DenseMap<uint64_t, uint64_t> CUMap; 
+  const uint64_t NotIndexed = std::numeric_limits<uint64_t>::max(); 
+ 
+  CUMap.reserve(DCtx.getNumCompileUnits()); 
+  for (const auto &CU : DCtx.compile_units()) 
+    CUMap[CU->getOffset()] = NotIndexed; 
+ 
+  unsigned NumErrors = 0; 
+  for (const DWARFDebugNames::NameIndex &NI : AccelTable) { 
+    if (NI.getCUCount() == 0) { 
+      error() << formatv("Name Index @ {0:x} does not index any CU\n", 
+                         NI.getUnitOffset()); 
+      ++NumErrors; 
+      continue; 
+    } 
+    for (uint32_t CU = 0, End = NI.getCUCount(); CU < End; ++CU) { 
+      uint64_t Offset = NI.getCUOffset(CU); 
+      auto Iter = CUMap.find(Offset); 
+ 
+      if (Iter == CUMap.end()) { 
+        error() << formatv( 
+            "Name Index @ {0:x} references a non-existing CU @ {1:x}\n", 
+            NI.getUnitOffset(), Offset); 
+        ++NumErrors; 
+        continue; 
+      } 
+ 
+      if (Iter->second != NotIndexed) { 
+        error() << formatv("Name Index @ {0:x} references a CU @ {1:x}, but " 
+                           "this CU is already indexed by Name Index @ {2:x}\n", 
+                           NI.getUnitOffset(), Offset, Iter->second); 
+        continue; 
+      } 
+      Iter->second = NI.getUnitOffset(); 
+    } 
+  } 
+ 
+  for (const auto &KV : CUMap) { 
+    if (KV.second == NotIndexed) 
+      warn() << formatv("CU @ {0:x} not covered by any Name Index\n", KV.first); 
+  } 
+ 
+  return NumErrors; 
+} 
+ 
+unsigned 
+DWARFVerifier::verifyNameIndexBuckets(const DWARFDebugNames::NameIndex &NI, 
+                                      const DataExtractor &StrData) { 
+  struct BucketInfo { 
+    uint32_t Bucket; 
+    uint32_t Index; 
+ 
+    constexpr BucketInfo(uint32_t Bucket, uint32_t Index) 
+        : Bucket(Bucket), Index(Index) {} 
+    bool operator<(const BucketInfo &RHS) const { return Index < RHS.Index; } 
+  }; 
+ 
+  uint32_t NumErrors = 0; 
+  if (NI.getBucketCount() == 0) { 
+    warn() << formatv("Name Index @ {0:x} does not contain a hash table.\n", 
+                      NI.getUnitOffset()); 
+    return NumErrors; 
+  } 
+ 
+  // Build up a list of (Bucket, Index) pairs. We use this later to verify that 
+  // each Name is reachable from the appropriate bucket. 
+  std::vector<BucketInfo> BucketStarts; 
+  BucketStarts.reserve(NI.getBucketCount() + 1); 
+  for (uint32_t Bucket = 0, End = NI.getBucketCount(); Bucket < End; ++Bucket) { 
+    uint32_t Index = NI.getBucketArrayEntry(Bucket); 
+    if (Index > NI.getNameCount()) { 
+      error() << formatv("Bucket {0} of Name Index @ {1:x} contains invalid " 
+                         "value {2}. Valid range is [0, {3}].\n", 
+                         Bucket, NI.getUnitOffset(), Index, NI.getNameCount()); 
+      ++NumErrors; 
+      continue; 
+    } 
+    if (Index > 0) 
+      BucketStarts.emplace_back(Bucket, Index); 
+  } 
+ 
+  // If there were any buckets with invalid values, skip further checks as they 
+  // will likely produce many errors which will only confuse the actual root 
+  // problem. 
+  if (NumErrors > 0) 
+    return NumErrors; 
+ 
+  // Sort the list in the order of increasing "Index" entries. 
+  array_pod_sort(BucketStarts.begin(), BucketStarts.end()); 
+ 
+  // Insert a sentinel entry at the end, so we can check that the end of the 
+  // table is covered in the loop below. 
+  BucketStarts.emplace_back(NI.getBucketCount(), NI.getNameCount() + 1); 
+ 
+  // Loop invariant: NextUncovered is the (1-based) index of the first Name 
+  // which is not reachable by any of the buckets we processed so far (and 
+  // hasn't been reported as uncovered). 
+  uint32_t NextUncovered = 1; 
+  for (const BucketInfo &B : BucketStarts) { 
+    // Under normal circumstances B.Index be equal to NextUncovered, but it can 
+    // be less if a bucket points to names which are already known to be in some 
+    // bucket we processed earlier. In that case, we won't trigger this error, 
+    // but report the mismatched hash value error instead. (We know the hash 
+    // will not match because we have already verified that the name's hash 
+    // puts it into the previous bucket.) 
+    if (B.Index > NextUncovered) { 
+      error() << formatv("Name Index @ {0:x}: Name table entries [{1}, {2}] " 
+                         "are not covered by the hash table.\n", 
+                         NI.getUnitOffset(), NextUncovered, B.Index - 1); 
+      ++NumErrors; 
+    } 
+    uint32_t Idx = B.Index; 
+ 
+    // The rest of the checks apply only to non-sentinel entries. 
+    if (B.Bucket == NI.getBucketCount()) 
+      break; 
+ 
+    // This triggers if a non-empty bucket points to a name with a mismatched 
+    // hash. Clients are likely to interpret this as an empty bucket, because a 
+    // mismatched hash signals the end of a bucket, but if this is indeed an 
+    // empty bucket, the producer should have signalled this by marking the 
+    // bucket as empty. 
+    uint32_t FirstHash = NI.getHashArrayEntry(Idx); 
+    if (FirstHash % NI.getBucketCount() != B.Bucket) { 
+      error() << formatv( 
+          "Name Index @ {0:x}: Bucket {1} is not empty but points to a " 
+          "mismatched hash value {2:x} (belonging to bucket {3}).\n", 
+          NI.getUnitOffset(), B.Bucket, FirstHash, 
+          FirstHash % NI.getBucketCount()); 
+      ++NumErrors; 
+    } 
+ 
+    // This find the end of this bucket and also verifies that all the hashes in 
+    // this bucket are correct by comparing the stored hashes to the ones we 
+    // compute ourselves. 
+    while (Idx <= NI.getNameCount()) { 
+      uint32_t Hash = NI.getHashArrayEntry(Idx); 
+      if (Hash % NI.getBucketCount() != B.Bucket) 
+        break; 
+ 
+      const char *Str = NI.getNameTableEntry(Idx).getString(); 
+      if (caseFoldingDjbHash(Str) != Hash) { 
+        error() << formatv("Name Index @ {0:x}: String ({1}) at index {2} " 
+                           "hashes to {3:x}, but " 
+                           "the Name Index hash is {4:x}\n", 
+                           NI.getUnitOffset(), Str, Idx, 
+                           caseFoldingDjbHash(Str), Hash); 
+        ++NumErrors; 
+      } 
+ 
+      ++Idx; 
+    } 
+    NextUncovered = std::max(NextUncovered, Idx); 
+  } 
+  return NumErrors; 
+} 
+ 
+unsigned DWARFVerifier::verifyNameIndexAttribute( 
+    const DWARFDebugNames::NameIndex &NI, const DWARFDebugNames::Abbrev &Abbr, 
+    DWARFDebugNames::AttributeEncoding AttrEnc) { 
+  StringRef FormName = dwarf::FormEncodingString(AttrEnc.Form); 
+  if (FormName.empty()) { 
+    error() << formatv("NameIndex @ {0:x}: Abbreviation {1:x}: {2} uses an " 
+                       "unknown form: {3}.\n", 
+                       NI.getUnitOffset(), Abbr.Code, AttrEnc.Index, 
+                       AttrEnc.Form); 
+    return 1; 
+  } 
+ 
+  if (AttrEnc.Index == DW_IDX_type_hash) { 
+    if (AttrEnc.Form != dwarf::DW_FORM_data8) { 
+      error() << formatv( 
+          "NameIndex @ {0:x}: Abbreviation {1:x}: DW_IDX_type_hash " 
+          "uses an unexpected form {2} (should be {3}).\n", 
+          NI.getUnitOffset(), Abbr.Code, AttrEnc.Form, dwarf::DW_FORM_data8); 
+      return 1; 
+    } 
+  } 
+ 
+  // A list of known index attributes and their expected form classes. 
+  // DW_IDX_type_hash is handled specially in the check above, as it has a 
+  // specific form (not just a form class) we should expect. 
+  struct FormClassTable { 
+    dwarf::Index Index; 
+    DWARFFormValue::FormClass Class; 
+    StringLiteral ClassName; 
+  }; 
+  static constexpr FormClassTable Table[] = { 
+      {dwarf::DW_IDX_compile_unit, DWARFFormValue::FC_Constant, {"constant"}}, 
+      {dwarf::DW_IDX_type_unit, DWARFFormValue::FC_Constant, {"constant"}}, 
+      {dwarf::DW_IDX_die_offset, DWARFFormValue::FC_Reference, {"reference"}}, 
+      {dwarf::DW_IDX_parent, DWARFFormValue::FC_Constant, {"constant"}}, 
+  }; 
+ 
+  ArrayRef<FormClassTable> TableRef(Table); 
+  auto Iter = find_if(TableRef, [AttrEnc](const FormClassTable &T) { 
+    return T.Index == AttrEnc.Index; 
+  }); 
+  if (Iter == TableRef.end()) { 
+    warn() << formatv("NameIndex @ {0:x}: Abbreviation {1:x} contains an " 
+                      "unknown index attribute: {2}.\n", 
+                      NI.getUnitOffset(), Abbr.Code, AttrEnc.Index); 
+    return 0; 
+  } 
+ 
+  if (!DWARFFormValue(AttrEnc.Form).isFormClass(Iter->Class)) { 
+    error() << formatv("NameIndex @ {0:x}: Abbreviation {1:x}: {2} uses an " 
+                       "unexpected form {3} (expected form class {4}).\n", 
+                       NI.getUnitOffset(), Abbr.Code, AttrEnc.Index, 
+                       AttrEnc.Form, Iter->ClassName); 
+    return 1; 
+  } 
+  return 0; 
+} 
+ 
+unsigned 
+DWARFVerifier::verifyNameIndexAbbrevs(const DWARFDebugNames::NameIndex &NI) { 
+  if (NI.getLocalTUCount() + NI.getForeignTUCount() > 0) { 
+    warn() << formatv("Name Index @ {0:x}: Verifying indexes of type units is " 
+                      "not currently supported.\n", 
+                      NI.getUnitOffset()); 
+    return 0; 
+  } 
+ 
+  unsigned NumErrors = 0; 
+  for (const auto &Abbrev : NI.getAbbrevs()) { 
+    StringRef TagName = dwarf::TagString(Abbrev.Tag); 
+    if (TagName.empty()) { 
+      warn() << formatv("NameIndex @ {0:x}: Abbreviation {1:x} references an " 
+                        "unknown tag: {2}.\n", 
+                        NI.getUnitOffset(), Abbrev.Code, Abbrev.Tag); 
+    } 
+    SmallSet<unsigned, 5> Attributes; 
+    for (const auto &AttrEnc : Abbrev.Attributes) { 
+      if (!Attributes.insert(AttrEnc.Index).second) { 
+        error() << formatv("NameIndex @ {0:x}: Abbreviation {1:x} contains " 
+                           "multiple {2} attributes.\n", 
+                           NI.getUnitOffset(), Abbrev.Code, AttrEnc.Index); 
+        ++NumErrors; 
+        continue; 
+      } 
+      NumErrors += verifyNameIndexAttribute(NI, Abbrev, AttrEnc); 
+    } 
+ 
+    if (NI.getCUCount() > 1 && !Attributes.count(dwarf::DW_IDX_compile_unit)) { 
+      error() << formatv("NameIndex @ {0:x}: Indexing multiple compile units " 
+                         "and abbreviation {1:x} has no {2} attribute.\n", 
+                         NI.getUnitOffset(), Abbrev.Code, 
+                         dwarf::DW_IDX_compile_unit); 
+      ++NumErrors; 
+    } 
+    if (!Attributes.count(dwarf::DW_IDX_die_offset)) { 
+      error() << formatv( 
+          "NameIndex @ {0:x}: Abbreviation {1:x} has no {2} attribute.\n", 
+          NI.getUnitOffset(), Abbrev.Code, dwarf::DW_IDX_die_offset); 
+      ++NumErrors; 
+    } 
+  } 
+  return NumErrors; 
+} 
+ 
+static SmallVector<StringRef, 2> getNames(const DWARFDie &DIE, 
+                                          bool IncludeLinkageName = true) { 
+  SmallVector<StringRef, 2> Result; 
+  if (const char *Str = DIE.getName(DINameKind::ShortName)) 
+    Result.emplace_back(Str); 
+  else if (DIE.getTag() == dwarf::DW_TAG_namespace) 
+    Result.emplace_back("(anonymous namespace)"); 
+ 
+  if (IncludeLinkageName) { 
+    if (const char *Str = DIE.getName(DINameKind::LinkageName)) { 
+      if (Result.empty() || Result[0] != Str) 
+        Result.emplace_back(Str); 
+    } 
+  } 
+ 
+  return Result; 
+} 
+ 
+unsigned DWARFVerifier::verifyNameIndexEntries( 
+    const DWARFDebugNames::NameIndex &NI, 
+    const DWARFDebugNames::NameTableEntry &NTE) { 
+  // Verifying type unit indexes not supported. 
+  if (NI.getLocalTUCount() + NI.getForeignTUCount() > 0) 
+    return 0; 
+ 
+  const char *CStr = NTE.getString(); 
+  if (!CStr) { 
+    error() << formatv( 
+        "Name Index @ {0:x}: Unable to get string associated with name {1}.\n", 
+        NI.getUnitOffset(), NTE.getIndex()); 
+    return 1; 
+  } 
+  StringRef Str(CStr); 
+ 
+  unsigned NumErrors = 0; 
+  unsigned NumEntries = 0; 
+  uint64_t EntryID = NTE.getEntryOffset(); 
+  uint64_t NextEntryID = EntryID; 
+  Expected<DWARFDebugNames::Entry> EntryOr = NI.getEntry(&NextEntryID); 
+  for (; EntryOr; ++NumEntries, EntryID = NextEntryID, 
+                                EntryOr = NI.getEntry(&NextEntryID)) { 
+    uint32_t CUIndex = *EntryOr->getCUIndex(); 
+    if (CUIndex > NI.getCUCount()) { 
+      error() << formatv("Name Index @ {0:x}: Entry @ {1:x} contains an " 
+                         "invalid CU index ({2}).\n", 
+                         NI.getUnitOffset(), EntryID, CUIndex); 
+      ++NumErrors; 
+      continue; 
+    } 
+    uint64_t CUOffset = NI.getCUOffset(CUIndex); 
+    uint64_t DIEOffset = CUOffset + *EntryOr->getDIEUnitOffset(); 
+    DWARFDie DIE = DCtx.getDIEForOffset(DIEOffset); 
+    if (!DIE) { 
+      error() << formatv("Name Index @ {0:x}: Entry @ {1:x} references a " 
+                         "non-existing DIE @ {2:x}.\n", 
+                         NI.getUnitOffset(), EntryID, DIEOffset); 
+      ++NumErrors; 
+      continue; 
+    } 
+    if (DIE.getDwarfUnit()->getOffset() != CUOffset) { 
+      error() << formatv("Name Index @ {0:x}: Entry @ {1:x}: mismatched CU of " 
+                         "DIE @ {2:x}: index - {3:x}; debug_info - {4:x}.\n", 
+                         NI.getUnitOffset(), EntryID, DIEOffset, CUOffset, 
+                         DIE.getDwarfUnit()->getOffset()); 
+      ++NumErrors; 
+    } 
+    if (DIE.getTag() != EntryOr->tag()) { 
+      error() << formatv("Name Index @ {0:x}: Entry @ {1:x}: mismatched Tag of " 
+                         "DIE @ {2:x}: index - {3}; debug_info - {4}.\n", 
+                         NI.getUnitOffset(), EntryID, DIEOffset, EntryOr->tag(), 
+                         DIE.getTag()); 
+      ++NumErrors; 
+    } 
+ 
+    auto EntryNames = getNames(DIE); 
+    if (!is_contained(EntryNames, Str)) { 
+      error() << formatv("Name Index @ {0:x}: Entry @ {1:x}: mismatched Name " 
+                         "of DIE @ {2:x}: index - {3}; debug_info - {4}.\n", 
+                         NI.getUnitOffset(), EntryID, DIEOffset, Str, 
+                         make_range(EntryNames.begin(), EntryNames.end())); 
+      ++NumErrors; 
+    } 
+  } 
+  handleAllErrors(EntryOr.takeError(), 
+                  [&](const DWARFDebugNames::SentinelError &) { 
+                    if (NumEntries > 0) 
+                      return; 
+                    error() << formatv("Name Index @ {0:x}: Name {1} ({2}) is " 
+                                       "not associated with any entries.\n", 
+                                       NI.getUnitOffset(), NTE.getIndex(), Str); 
+                    ++NumErrors; 
+                  }, 
+                  [&](const ErrorInfoBase &Info) { 
+                    error() 
+                        << formatv("Name Index @ {0:x}: Name {1} ({2}): {3}\n", 
+                                   NI.getUnitOffset(), NTE.getIndex(), Str, 
+                                   Info.message()); 
+                    ++NumErrors; 
+                  }); 
+  return NumErrors; 
+} 
+ 
+static bool isVariableIndexable(const DWARFDie &Die, DWARFContext &DCtx) { 
+  Expected<std::vector<DWARFLocationExpression>> Loc = 
+      Die.getLocations(DW_AT_location); 
+  if (!Loc) { 
+    consumeError(Loc.takeError()); 
+    return false; 
+  } 
+  DWARFUnit *U = Die.getDwarfUnit(); 
+  for (const auto &Entry : *Loc) { 
+    DataExtractor Data(toStringRef(Entry.Expr), DCtx.isLittleEndian(), 
+                       U->getAddressByteSize()); 
+    DWARFExpression Expression(Data, U->getAddressByteSize(), 
+                               U->getFormParams().Format); 
+    bool IsInteresting = any_of(Expression, [](DWARFExpression::Operation &Op) { 
+      return !Op.isError() && (Op.getCode() == DW_OP_addr || 
+                               Op.getCode() == DW_OP_form_tls_address || 
+                               Op.getCode() == DW_OP_GNU_push_tls_address); 
+    }); 
+    if (IsInteresting) 
+      return true; 
+  } 
+  return false; 
+} 
+ 
+unsigned DWARFVerifier::verifyNameIndexCompleteness( 
+    const DWARFDie &Die, const DWARFDebugNames::NameIndex &NI) { 
+ 
+  // First check, if the Die should be indexed. The code follows the DWARF v5 
+  // wording as closely as possible. 
+ 
+  // "All non-defining declarations (that is, debugging information entries 
+  // with a DW_AT_declaration attribute) are excluded." 
+  if (Die.find(DW_AT_declaration)) 
+    return 0; 
+ 
+  // "DW_TAG_namespace debugging information entries without a DW_AT_name 
+  // attribute are included with the name “(anonymous namespace)”. 
+  // All other debugging information entries without a DW_AT_name attribute 
+  // are excluded." 
+  // "If a subprogram or inlined subroutine is included, and has a 
+  // DW_AT_linkage_name attribute, there will be an additional index entry for 
+  // the linkage name." 
+  auto IncludeLinkageName = Die.getTag() == DW_TAG_subprogram || 
+                            Die.getTag() == DW_TAG_inlined_subroutine; 
+  auto EntryNames = getNames(Die, IncludeLinkageName); 
+  if (EntryNames.empty()) 
+    return 0; 
+ 
+  // We deviate from the specification here, which says: 
+  // "The name index must contain an entry for each debugging information entry 
+  // that defines a named subprogram, label, variable, type, or namespace, 
+  // subject to ..." 
+  // Explicitly exclude all TAGs that we know shouldn't be indexed. 
+  switch (Die.getTag()) { 
+  // Compile units and modules have names but shouldn't be indexed. 
+  case DW_TAG_compile_unit: 
+  case DW_TAG_module: 
+    return 0; 
+ 
+  // Function and template parameters are not globally visible, so we shouldn't 
+  // index them. 
+  case DW_TAG_formal_parameter: 
+  case DW_TAG_template_value_parameter: 
+  case DW_TAG_template_type_parameter: 
+  case DW_TAG_GNU_template_parameter_pack: 
+  case DW_TAG_GNU_template_template_param: 
+    return 0; 
+ 
+  // Object members aren't globally visible. 
+  case DW_TAG_member: 
+    return 0; 
+ 
+  // According to a strict reading of the specification, enumerators should not 
+  // be indexed (and LLVM currently does not do that). However, this causes 
+  // problems for the debuggers, so we may need to reconsider this. 
+  case DW_TAG_enumerator: 
+    return 0; 
+ 
+  // Imported declarations should not be indexed according to the specification 
+  // and LLVM currently does not do that. 
+  case DW_TAG_imported_declaration: 
+    return 0; 
+ 
+  // "DW_TAG_subprogram, DW_TAG_inlined_subroutine, and DW_TAG_label debugging 
+  // information entries without an address attribute (DW_AT_low_pc, 
+  // DW_AT_high_pc, DW_AT_ranges, or DW_AT_entry_pc) are excluded." 
+  case DW_TAG_subprogram: 
+  case DW_TAG_inlined_subroutine: 
+  case DW_TAG_label: 
+    if (Die.findRecursively( 
+            {DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_entry_pc})) 
+      break; 
+    return 0; 
+ 
+  // "DW_TAG_variable debugging information entries with a DW_AT_location 
+  // attribute that includes a DW_OP_addr or DW_OP_form_tls_address operator are 
+  // included; otherwise, they are excluded." 
+  // 
+  // LLVM extension: We also add DW_OP_GNU_push_tls_address to this list. 
+  case DW_TAG_variable: 
+    if (isVariableIndexable(Die, DCtx)) 
+      break; 
+    return 0; 
+ 
+  default: 
+    break; 
+  } 
+ 
+  // Now we know that our Die should be present in the Index. Let's check if 
+  // that's the case. 
+  unsigned NumErrors = 0; 
+  uint64_t DieUnitOffset = Die.getOffset() - Die.getDwarfUnit()->getOffset(); 
+  for (StringRef Name : EntryNames) { 
+    if (none_of(NI.equal_range(Name), [&](const DWARFDebugNames::Entry &E) { 
+          return E.getDIEUnitOffset() == DieUnitOffset; 
+        })) { 
+      error() << formatv("Name Index @ {0:x}: Entry for DIE @ {1:x} ({2}) with " 
+                         "name {3} missing.\n", 
+                         NI.getUnitOffset(), Die.getOffset(), Die.getTag(), 
+                         Name); 
+      ++NumErrors; 
+    } 
+  } 
+  return NumErrors; 
+} 
+ 
+unsigned DWARFVerifier::verifyDebugNames(const DWARFSection &AccelSection, 
+                                         const DataExtractor &StrData) { 
+  unsigned NumErrors = 0; 
+  DWARFDataExtractor AccelSectionData(DCtx.getDWARFObj(), AccelSection, 
+                                      DCtx.isLittleEndian(), 0); 
+  DWARFDebugNames AccelTable(AccelSectionData, StrData); 
+ 
+  OS << "Verifying .debug_names...\n"; 
+ 
+  // This verifies that we can read individual name indices and their 
+  // abbreviation tables. 
+  if (Error E = AccelTable.extract()) { 
+    error() << toString(std::move(E)) << '\n'; 
+    return 1; 
+  } 
+ 
+  NumErrors += verifyDebugNamesCULists(AccelTable); 
+  for (const auto &NI : AccelTable) 
+    NumErrors += verifyNameIndexBuckets(NI, StrData); 
+  for (const auto &NI : AccelTable) 
+    NumErrors += verifyNameIndexAbbrevs(NI); 
+ 
+  // Don't attempt Entry validation if any of the previous checks found errors 
+  if (NumErrors > 0) 
+    return NumErrors; 
+  for (const auto &NI : AccelTable) 
+    for (DWARFDebugNames::NameTableEntry NTE : NI) 
+      NumErrors += verifyNameIndexEntries(NI, NTE); 
+ 
+  if (NumErrors > 0) 
+    return NumErrors; 
+ 
+  for (const std::unique_ptr<DWARFUnit> &U : DCtx.compile_units()) { 
+    if (const DWARFDebugNames::NameIndex *NI = 
+            AccelTable.getCUNameIndex(U->getOffset())) { 
+      auto *CU = cast<DWARFCompileUnit>(U.get()); 
+      for (const DWARFDebugInfoEntry &Die : CU->dies()) 
+        NumErrors += verifyNameIndexCompleteness(DWARFDie(CU, &Die), *NI); 
+    } 
+  } 
+  return NumErrors; 
+} 
+ 
+bool DWARFVerifier::handleAccelTables() { 
+  const DWARFObject &D = DCtx.getDWARFObj(); 
+  DataExtractor StrData(D.getStrSection(), DCtx.isLittleEndian(), 0); 
+  unsigned NumErrors = 0; 
+  if (!D.getAppleNamesSection().Data.empty()) 
+    NumErrors += verifyAppleAccelTable(&D.getAppleNamesSection(), &StrData, 
+                                       ".apple_names"); 
+  if (!D.getAppleTypesSection().Data.empty()) 
+    NumErrors += verifyAppleAccelTable(&D.getAppleTypesSection(), &StrData, 
+                                       ".apple_types"); 
+  if (!D.getAppleNamespacesSection().Data.empty()) 
+    NumErrors += verifyAppleAccelTable(&D.getAppleNamespacesSection(), &StrData, 
+                                       ".apple_namespaces"); 
+  if (!D.getAppleObjCSection().Data.empty()) 
+    NumErrors += verifyAppleAccelTable(&D.getAppleObjCSection(), &StrData, 
+                                       ".apple_objc"); 
+ 
+  if (!D.getNamesSection().Data.empty()) 
+    NumErrors += verifyDebugNames(D.getNamesSection(), StrData); 
+  return NumErrors == 0; 
+} 
+ 
+raw_ostream &DWARFVerifier::error() const { return WithColor::error(OS); } 
+ 
+raw_ostream &DWARFVerifier::warn() const { return WithColor::warning(OS); } 
+ 
+raw_ostream &DWARFVerifier::note() const { return WithColor::note(OS); } 
+ 
+raw_ostream &DWARFVerifier::dump(const DWARFDie &Die, unsigned indent) const { 
+  Die.dump(OS, indent, DumpOpts); 
+  return OS; 
+}