Use DWARFDataExtractor::getInitialLength in debug_aranges

[labath]

Summary

getInitialLength is a *DWARF*DataExtractor method so I had to "upgrade"
some DataExtractors to be able to make use of it.

[probinson]

Yeah, previously the only extra feature in DWARFDataExtractor was handling relocations, IIRC. DebugInfo/DWARF generally used the base DataExtractor for cases where that wasn't needed, rather than consistently using the DWARF version.

Nice tidy-up, though, LGTM.

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h

 //===- DWARFDebugArangeSet.h ------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_DWARFDEBUGARANGESET_H
 #define LLVM_DEBUGINFO_DWARFDEBUGARANGESET_H
 
 #include "llvm/ADT/iterator_range.h"
-#include "llvm/Support/DataExtractor.h"
+#include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 #include "llvm/Support/Error.h"
 #include <cstdint>
 #include <vector>
 
 namespace llvm {
 
 class raw_ostream;
 
private:
   uint64_t Offset;
   Header HeaderData;
   DescriptorColl ArangeDescriptors;
 
 public:
   DWARFDebugArangeSet() { clear(); }
 
   void clear();
-  Error extract(DataExtractor data, uint64_t *offset_ptr);
+  Error extract(DWARFDataExtractor data, uint64_t *offset_ptr);
   void dump(raw_ostream &OS) const;
 
   uint64_t getCompileUnitDIEOffset() const { return HeaderData.CuOffset; }
 
   const Header &getHeader() const { return HeaderData; }
 
   desc_iterator_range descriptors() const {
     return desc_iterator_range(ArangeDescriptors.begin(),
                                ArangeDescriptors.end());
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARFDEBUGARANGESET_H

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugAranges.h

 //===- DWARFDebugAranges.h --------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_DWARFDEBUGARANGES_H
 #define LLVM_DEBUGINFO_DWARFDEBUGARANGES_H
 
 #include "llvm/ADT/DenseSet.h"
-#include "llvm/Support/DataExtractor.h"
+#include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 #include <cstdint>
 #include <vector>
 
 namespace llvm {
 
 class DWARFContext;
 
 class DWARFDebugAranges {
 public:
   void generate(DWARFContext *CTX);
   uint64_t findAddress(uint64_t Address) const;
 
 private:
   void clear();
-  void extract(DataExtractor DebugArangesData,
+  void extract(DWARFDataExtractor DebugArangesData,
                function_ref<void(Error)> RecoverableErrorHandler);
 
   /// Call appendRange multiple times and then call construct.
   void appendRange(uint64_t CUOffset, uint64_t LowPC, uint64_t HighPC);
   void construct();
 
   struct Range {
     explicit Range(uint64_t LowPC, uint64_t HighPC, uint64_t CUOffset)

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

void DWARFContext::dump(
   if (shouldDump(Explicit, ".debug_macinfo.dwo", DIDT_ID_DebugMacro,
                  DObj->getMacinfoDWOSection())) {
     getDebugMacinfoDWO()->dump(OS);
   }
 
   if (shouldDump(Explicit, ".debug_aranges", DIDT_ID_DebugAranges,
                  DObj->getArangesSection())) {
     uint64_t offset = 0;
-    DataExtractor arangesData(DObj->getArangesSection(), isLittleEndian(), 0);
+    DWARFDataExtractor arangesData(DObj->getArangesSection(), isLittleEndian(),
+                                   0);
     DWARFDebugArangeSet set;
     while (arangesData.isValidOffset(offset)) {
       if (Error E = set.extract(arangesData, &offset)) {
         RecoverableErrorHandler(std::move(E));
         break;
       }
       set.dump(OS);
     }

llvm/lib/DebugInfo/DWARF/DWARFDebugArangeSet.cpp

 }
 
 void DWARFDebugArangeSet::clear() {
   Offset = -1ULL;
   std::memset(&HeaderData, 0, sizeof(Header));
   ArangeDescriptors.clear();
 }
 
-Error DWARFDebugArangeSet::extract(DataExtractor data, uint64_t *offset_ptr) {
+Error DWARFDebugArangeSet::extract(DWARFDataExtractor data,
+                                   uint64_t *offset_ptr) {
   assert(data.isValidOffset(*offset_ptr));
   ArangeDescriptors.clear();
   Offset = *offset_ptr;
 
   // 7.21 Address Range Table (extract)
   // Each set of entries in the table of address ranges contained in
   // the .debug_aranges section begins with a header containing:
   // 1. unit_length (initial length)
Error DWARFDebugArangeSet::extract(DWARFDataExtractor data,
   // a segment, an address and a length. The segment selector size is given by
   // the segment_selector_size field of the header; the address and length
   // size are each given by the address_size field of the header. Each set of
   // tuples is terminated by a 0 for the segment, a 0 for the address and 0
   // for the length. If the segment_selector_size field in the header is zero,
   // the segment selectors are omitted from all tuples, including
   // the terminating tuple.
 
-  constexpr unsigned CommonFieldsLength = 2 + // Version
-                                          1 + // Address Size
-                                          1;  // Segment Selector Size
-  static const unsigned DWARF32HeaderLength =
-      dwarf::getUnitLengthFieldByteSize(dwarf::DWARF32) + CommonFieldsLength +
-      dwarf::getDwarfOffsetByteSize(dwarf::DWARF32); // Debug Info Offset
-  static const unsigned DWARF64HeaderLength =
-      dwarf::getUnitLengthFieldByteSize(dwarf::DWARF64) + CommonFieldsLength +
-      dwarf::getDwarfOffsetByteSize(dwarf::DWARF64); // Debug Info Offset
-
-  if (!data.isValidOffsetForDataOfSize(Offset, DWARF32HeaderLength))
+  dwarf::DwarfFormat format;
+  Error Err = Error::success();
+  std::tie(HeaderData.Length, format) = data.getInitialLength(offset_ptr, &Err);
+  HeaderData.Version = data.getU16(offset_ptr, &Err);
+  HeaderData.CuOffset =
+      data.getUnsigned(offset_ptr, dwarf::getDwarfOffsetByteSize(format), &Err);
+  HeaderData.AddrSize = data.getU8(offset_ptr, &Err);
+  HeaderData.SegSize = data.getU8(offset_ptr, &Err);
+  if (Err) {
     return createStringError(errc::invalid_argument,
-                             "section is not large enough to contain "
-                             "an address range table at offset 0x%" PRIx64,
-                             Offset);
-
-  dwarf::DwarfFormat format = dwarf::DWARF32;
-  HeaderData.Length = data.getU32(offset_ptr);
-  if (HeaderData.Length == dwarf::DW_LENGTH_DWARF64) {
-    if (!data.isValidOffsetForDataOfSize(Offset, DWARF64HeaderLength))
-      return createStringError(
-          errc::invalid_argument,
-          "section is not large enough to contain a DWARF64 "
-          "address range table at offset 0x%" PRIx64,
-          Offset);
-    HeaderData.Length = data.getU64(offset_ptr);
-    format = dwarf::DWARF64;
-  } else if (HeaderData.Length >= dwarf::DW_LENGTH_lo_reserved) {
-    return createStringError(
-        errc::invalid_argument,
-        "address range table at offset 0x%" PRIx64
-        " has unsupported reserved unit length of value 0x%8.8" PRIx64,
-        Offset, HeaderData.Length);
+                             "parsing address ranges table at offset 0x%" PRIx64
+                             ": %s",
+                             Offset, toString(std::move(Err)).c_str());
   }
-  HeaderData.Version = data.getU16(offset_ptr);
-  HeaderData.CuOffset =
-      data.getUnsigned(offset_ptr, dwarf::getDwarfOffsetByteSize(format));
-  HeaderData.AddrSize = data.getU8(offset_ptr);
-  HeaderData.SegSize = data.getU8(offset_ptr);
 
   // Perform basic validation of the header fields.
   uint64_t full_length =
       dwarf::getUnitLengthFieldByteSize(format) + HeaderData.Length;
   if (!data.isValidOffsetForDataOfSize(Offset, full_length))
     return createStringError(errc::invalid_argument,
                              "the length of address range table at offset "
                              "0x%" PRIx64 " exceeds section size",

llvm/lib/DebugInfo/DWARF/DWARFDebugAranges.cpp

 #include <cassert>
 #include <cstdint>
 #include <set>
 #include <vector>
 
 using namespace llvm;
 
 void DWARFDebugAranges::extract(
-    DataExtractor DebugArangesData,
+    DWARFDataExtractor DebugArangesData,
     function_ref<void(Error)> RecoverableErrorHandler) {
   if (!DebugArangesData.isValidOffset(0))
     return;
   uint64_t Offset = 0;
   DWARFDebugArangeSet Set;
 
   while (DebugArangesData.isValidOffset(Offset)) {
     if (Error E = Set.extract(DebugArangesData, &Offset)) {

 }
 
 void DWARFDebugAranges::generate(DWARFContext *CTX) {
   clear();
   if (!CTX)
     return;
 
   // Extract aranges from .debug_aranges section.
-  DataExtractor ArangesData(CTX->getDWARFObj().getArangesSection(),
+  DWARFDataExtractor ArangesData(CTX->getDWARFObj().getArangesSection(),
                                  CTX->isLittleEndian(), 0);
   extract(ArangesData, CTX->getRecoverableErrorHandler());
 
   // Generate aranges from DIEs: even if .debug_aranges section is present,
   // it may describe only a small subset of compilation units, so we need to
   // manually build aranges for the rest of them.
   for (const auto &CU : CTX->compile_units()) {
     uint64_t CUOffset = CU->getOffset();
     if (ParsedCUOffsets.insert(CUOffset).second) {

llvm/tools/obj2yaml/dwarf2yaml.cpp

void dumpDebugStrings(DWARFContext &DCtx, DWARFYAML::Data &Y) {
   while (RemainingTable.size() > 0) {
     auto SymbolPair = RemainingTable.split('\0');
     RemainingTable = SymbolPair.second;
     Y.DebugStrings.push_back(SymbolPair.first);
   }
 }
 
 Error dumpDebugARanges(DWARFContext &DCtx, DWARFYAML::Data &Y) {
-  DataExtractor ArangesData(DCtx.getDWARFObj().getArangesSection(),
+  DWARFDataExtractor ArangesData(DCtx.getDWARFObj().getArangesSection(),
                                  DCtx.isLittleEndian(), 0);
   uint64_t Offset = 0;
   DWARFDebugArangeSet Set;
 
   while (ArangesData.isValidOffset(Offset)) {
     if (Error E = Set.extract(ArangesData, &Offset))
       return E;
     DWARFYAML::ARange Range;
     Range.Length.setLength(Set.getHeader().Length);

llvm/unittests/DebugInfo/DWARF/DWARFDebugArangeSetTest.cpp

 
 using namespace llvm;
 
 namespace {
 
 template <size_t SecSize>
 void ExpectExtractError(const char (&SecDataRaw)[SecSize],
                         const char *ErrorMessage) {
-  DataExtractor Extractor(StringRef(SecDataRaw, SecSize - 1),
+  DWARFDataExtractor Extractor(StringRef(SecDataRaw, SecSize - 1),
                                /* IsLittleEndian = */ true,
                                /* AddressSize = */ 4);
   DWARFDebugArangeSet Set;
   uint64_t Offset = 0;
   Error E = Set.extract(Extractor, &Offset);
   ASSERT_TRUE(E.operator bool());
   EXPECT_STREQ(ErrorMessage, toString(std::move(E)).c_str());
 }
 
 TEST(DWARFDebugArangeSet, LengthExceedsSectionSize) {
ExpectExtractError(
       "address range table at offset 0x0 is not terminated by null entry");
 }
 
 TEST(DWARFDebugArangeSet, ReservedUnitLength) {
   // Note: 12 is the minimum length to pass the basic check for the size of
   // the section. 1 will be automatically subtracted in ExpectExtractError().
   static const char DebugArangesSecRaw[12 + 1] =
       "\xf0\xff\xff\xff"; // Reserved unit length value
-  ExpectExtractError(
-      DebugArangesSecRaw,
-      "address range table at offset 0x0 has unsupported reserved unit length "
-      "of value 0xfffffff0");
+  ExpectExtractError(DebugArangesSecRaw,
+                     "parsing address ranges table at offset 0x0: unsupported "
+                     "reserved unit length of value 0xfffffff0");
 }
 
 TEST(DWARFDebugArangeSet, SectionTooShort) {
   // Note: 1 will be automatically subtracted in ExpectExtractError().
   static const char DebugArangesSecRaw[11 + 1] = {0};
-  ExpectExtractError(
-      DebugArangesSecRaw,
-      "section is not large enough to contain an address range table "
-      "at offset 0x0");
+  ExpectExtractError(DebugArangesSecRaw,
+                     "parsing address ranges table at offset 0x0: unexpected "
+                     "end of data at offset 0xb");
 }
 
 TEST(DWARFDebugArangeSet, SectionTooShortDWARF64) {
   // Note: 1 will be automatically subtracted in ExpectExtractError().
   static const char DebugArangesSecRaw[23 + 1] =
       "\xff\xff\xff\xff"; // DWARF64 mark
-  ExpectExtractError(
-      DebugArangesSecRaw,
-      "section is not large enough to contain a DWARF64 address range table "
-      "at offset 0x0");
+  ExpectExtractError(DebugArangesSecRaw,
+                     "parsing address ranges table at offset 0x0: unexpected "
+                     "end of data at offset 0x17");
 }
 
 TEST(DWARFDebugArangeSet, NoSpaceForEntries) {
   static const char DebugArangesSecRaw[] =
       "\x0c\x00\x00\x00" // Length
       "\x02\x00"         // Version
       "\x00\x00\x00\x00" // Debug Info Offset
       "\x04"             // Address Size