[DebugInfo] Don't error for zero-length arange entries

[jhenderson]

Summary

Although the DWARF specification states that .debug_aranges entries can't have length zero, these can occur in the wild. There's no particular reason to enforce this part of the spec, since functionally they have no impact. The patch removes the error and introduces a new warning for premature terminator entries, which does not stop parsing.

Fixes https://bugs.llvm.org/show_bug.cgi?id=46805. See also https://reviews.llvm.org/D71932 which originally introduced the error.

[dblaikie]

Any chance/worth a warning/non-fatal error?

[ikudrin]

llvm/lib/DebugInfo/DWARF/DWARFDebugArangeSet.cpp

139–149

• Thought 1: these two ifs can now be combined into one.
• Thought 2: should not we report the premature termination of the list?

[jhenderson]

In D85313#2196990, @dblaikie wrote:

Any chance/worth a warning/non-fatal error?

I'd prefer not to - as noted elsewhere, our downstream solution for gc'ed references from .debug_aranges was to patch (-1, 0) for the .debug_aranges, so we have plenty of older objects with length 0 entries. At some point in the future these will start disappearing, now that we've moved to the new LLD tombstoning behaviour, but it would be nice to have a grace period, if that's okay?

llvm/lib/DebugInfo/DWARF/DWARFDebugArangeSet.cpp

139–149

Yeah, I wasn't sure about premature list termination. I think I'll add a warning/non-fatal error of some kind, and keep dumping - the header's length field means we know that it should be possible to ignore the terminator and continue dumping.

[jhenderson]

I've changed the existing error to a "warning" in the event of premature terminators with this change. I could just do what was being done before and emit an error. Functionally, they end up the same, but emitting an error does not allow continued parsing of the section.

[ikudrin]

llvm/unittests/DebugInfo/DWARF/DWARFDebugArangeSetTest.cpp

245–247

I'd prefer this test to be divided into more basic ones. All other tests in the suite follow the idea that a unit test should check just one particular case. This helps to improve readability and maintainability. So, I'd suggest creating separate tests for cases "allow zero-length entries" and "report premature termination but continue parsing".

[jhenderson]

Split unit test in two.

[ikudrin]

LGTM, thanks!

llvm/unittests/DebugInfo/DWARF/DWARFDebugArangeSetTest.cpp

181

Did you mean Of?

[jhenderson]

@dblaikie - are you happy with this version?

llvm/unittests/DebugInfo/DWARF/DWARFDebugArangeSetTest.cpp

181

Nope - this test tests both length being zero and address being zero (but not both in a single entry).

[ikudrin]

llvm/unittests/DebugInfo/DWARF/DWARFDebugArangeSetTest.cpp

181

Ah! So it is still not that elementary as I hoped...

[jhenderson]

Split up unit test further.

[ikudrin]

Great! Thanks.

[dblaikie]

In D85313#2199447, @jhenderson wrote:

@dblaikie - are you happy with this version?

Sounds good to me!

I'd prefer not to - as noted elsewhere, our downstream solution for gc'ed references from .debug_aranges was to patch (-1, 0) for the .debug_aranges, so we have plenty of older objects with length 0 entries. At some point in the future these will start disappearing, now that we've moved to the new LLD tombstoning behaviour, but it would be nice to have a grace period, if that's okay?

Oh, interesting - didn't realize your linker specifically truncated the range to 0 length, that totally makes sense! But now you're adopting the "new tombstoning" Semantics of -1 for the address, but leaving the length value the same as came from the input object?

I personally have no particular use for the DWARF verifier - so I'm not in a position to make strong preferences for what should or shouldn't be verified. Hopefully as a warning it might be something relatively easy to patch out in your downstream builds (not ideal, I know :/), or filter out, etc.

[jhenderson]

In D85313#2201451, @dblaikie wrote:

In D85313#2199447, @jhenderson wrote:

@dblaikie - are you happy with this version?

Sounds good to me!

Thanks, I'll go ahead and push this then.

I'd prefer not to - as noted elsewhere, our downstream solution for gc'ed references from .debug_aranges was to patch (-1, 0) for the .debug_aranges, so we have plenty of older objects with length 0 entries. At some point in the future these will start disappearing, now that we've moved to the new LLD tombstoning behaviour, but it would be nice to have a grace period, if that's okay?

Oh, interesting - didn't realize your linker specifically truncated the range to 0 length, that totally makes sense! But now you're adopting the "new tombstoning" Semantics of -1 for the address, but leaving the length value the same as came from the input object?

Yeah, we changed the length because not all our tools necessarily handled the tombstone value specifically, but a 0-length range would always be safe. We're transitioning to the new scheme however, to save us having to maintain things further.

I personally have no particular use for the DWARF verifier - so I'm not in a position to make strong preferences for what should or shouldn't be verified. Hopefully as a warning it might be something relatively easy to patch out in your downstream builds (not ideal, I know :/), or filter out, etc.

We don't officially support using the verifier either (currently). This error/warning however is emitted by llvm-dwarfdump when printing the section, which is more problematic. I don't think we'd have an issue with it being added as a verifier warning of some sort consequently, but I'm not likely to add it myself, since it is not something that is useful for us. If we ever did add support for the verification, we'd likely say it only works with objects from a certain release onwards, or something similar.

[thakis]

I reverted this since it broke building obj2yaml on all bots, and the fix wasn't immediately clear to me. (We need to pass some warning handler, but I don't know which one's appropriate in obj2yaml.)

[jhenderson]

In D85313#2206366, @thakis wrote:

I reverted this since it broke building obj2yaml on all bots, and the fix wasn't immediately clear to me. (We need to pass some warning handler, but I don't know which one's appropriate in obj2yaml.)

Thanks. You beat me to it. Working on a fix now.

[jhenderson]

Fix obj2yaml code path. Either it changed since I made my change, or I just failed to build the right bits of LLVM...

@grimar/@Higuoxing, could one of you take a look at the obj2yaml changes, please?

[Higuoxing]

LGTM. Thanks!

llvm/test/tools/obj2yaml/ELF/DWARF/debug-aranges.yaml

7–10

I think it might be good to put -D options together.

e.g.,

FileCheck -DLENGTH1=24 -DLENGTH2=24 -DADDRSIZE=0x04 -DVARADDR=0x1234 -DVARLEN=0x5678 %s --check-prefix=BASIC --implicit-check-not=Sections

[jhenderson]

Reorder FileCheck arguments as suggested.

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

private:
   uint64_t Offset;
   Header HeaderData;
   DescriptorColl ArangeDescriptors;
 
 public:
   DWARFDebugArangeSet() { clear(); }
 
   void clear();
-  Error extract(DWARFDataExtractor data, uint64_t *offset_ptr);
+  Error extract(DWARFDataExtractor data, uint64_t *offset_ptr,
+                function_ref<void(Error)> WarningHandler);
   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/lib/DebugInfo/DWARF/DWARFContext.cpp

void DWARFContext::dump(
 
   if (shouldDump(Explicit, ".debug_aranges", DIDT_ID_DebugAranges,
                  DObj->getArangesSection())) {
     uint64_t offset = 0;
     DWARFDataExtractor arangesData(DObj->getArangesSection(), isLittleEndian(),
                                    0);
     DWARFDebugArangeSet set;
     while (arangesData.isValidOffset(offset)) {
-      if (Error E = set.extract(arangesData, &offset)) {
+      if (Error E =
+              set.extract(arangesData, &offset, DumpOpts.WarningHandler)) {
         RecoverableErrorHandler(std::move(E));
         break;
       }
       set.dump(OS);
     }
   }
 
   auto DumpLineSection = [&](DWARFDebugLine::SectionParser Parser,

llvm/lib/DebugInfo/DWARF/DWARFDebugArangeSet.cpp

 
 void DWARFDebugArangeSet::clear() {
   Offset = -1ULL;
   std::memset(&HeaderData, 0, sizeof(Header));
   ArangeDescriptors.clear();
 }
 
 Error DWARFDebugArangeSet::extract(DWARFDataExtractor data,
-                                   uint64_t *offset_ptr) {
+                                   uint64_t *offset_ptr,
+                                   function_ref<void(Error)> WarningHandler) {
   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,
 
   static_assert(sizeof(arangeDescriptor.Address) ==
                     sizeof(arangeDescriptor.Length),
                 "Different datatypes for addresses and sizes!");
   assert(sizeof(arangeDescriptor.Address) >= HeaderData.AddrSize);
 
   uint64_t end_offset = Offset + full_length;
   while (*offset_ptr < end_offset) {
+    uint64_t EntryOffset = *offset_ptr;
     arangeDescriptor.Address = data.getUnsigned(offset_ptr, HeaderData.AddrSize);
     arangeDescriptor.Length = data.getUnsigned(offset_ptr, HeaderData.AddrSize);
 
-    if (arangeDescriptor.Length == 0) {
-      // Each set of tuples is terminated by a 0 for the address and 0
-      // for the length.
-      if (arangeDescriptor.Address == 0 && *offset_ptr == end_offset)
+    if (arangeDescriptor.Length == 0 && arangeDescriptor.Address == 0) {
+      if (*offset_ptr == end_offset)
         return ErrorSuccess();
-      return createStringError(
+      WarningHandler(createStringError(
           errc::invalid_argument,
           "address range table at offset 0x%" PRIx64
-          " has an invalid tuple (length = 0) at offset 0x%" PRIx64,
-          Offset, *offset_ptr - tuple_size);
+          " has a premature terminator entry at offset 0x%" PRIx64,
+          Offset, EntryOffset));
     }
 
     ArangeDescriptors.push_back(arangeDescriptor);
   }
 
   return createStringError(errc::invalid_argument,
                            "address range table at offset 0x%" PRIx64
                            " is not terminated by null entry",

llvm/lib/DebugInfo/DWARF/DWARFDebugAranges.cpp

void DWARFDebugAranges::extract(
     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)) {
+    if (Error E =
+            Set.extract(DebugArangesData, &Offset, RecoverableErrorHandler)) {
       RecoverableErrorHandler(std::move(E));
       return;
     }
     uint64_t CUOffset = Set.getCompileUnitDIEOffset();
     for (const auto &Desc : Set.descriptors()) {
       uint64_t LowPC = Desc.Address;
       uint64_t HighPC = Desc.getEndAddress();
       appendRange(CUOffset, LowPC, HighPC);

llvm/test/tools/obj2yaml/ELF/DWARF/debug-aranges.yaml

 ## Test how we dump the .debug_aranges section.
 
 ## a) Test dumping the DWARF32/64 address range table from 32/64-bit, little/big endian object files.
 ## The .debug_aranges should be written to the 'DWARF' entry and the 'Sections' entry should remain empty.
 
 # RUN: yaml2obj --docnum=1 -DBITS=32 -DENDIAN=LSB %s | obj2yaml | \
-# RUN:   FileCheck -DLENGTH1=24 -DLENGTH2=24 -DADDRSIZE=0x04 %s --check-prefix=BASIC --implicit-check-not=Sections
+# RUN:   FileCheck %s --check-prefix=BASIC --implicit-check-not=Sections \
+# RUN:     -DLENGTH1=24 -DLENGTH2=24 -DADDRSIZE=0x04 \
+# RUN:     -DVARADDR=0x0000000000001234 -DVARLEN=0x0000000000005678
 
 # RUN: yaml2obj --docnum=1 -DBITS=32 -DENDIAN=MSB %s | obj2yaml | \
-# RUN:   FileCheck -DLENGTH1=24 -DLENGTH2=24 -DADDRSIZE=0x04 %s --check-prefix=BASIC --implicit-check-not=Sections
+# RUN:   FileCheck %s --check-prefix=BASIC --implicit-check-not=Sections \
+# RUN:     -DLENGTH1=24 -DLENGTH2=24 -DADDRSIZE=0x04 \
+# RUN:     -DVARADDR=0x0000000000001234 -DVARLEN=0x0000000000005678
 
 # RUN: yaml2obj --docnum=1 -DBITS=64 -DENDIAN=LSB %s | obj2yaml | \
-# RUN:   FileCheck -DLENGTH1=3C -DLENGTH2=44 -DADDRSIZE=0x08 %s --check-prefix=BASIC --implicit-check-not=Sections
+# RUN:   FileCheck %s --check-prefix=BASIC --implicit-check-not=Sections \
+# RUN:     -DLENGTH1=3C -DLENGTH2=44 -DADDRSIZE=0x08 \
+# RUN:     -DVARADDR=0x0000000000001234 -DVARLEN=0x0000000000005678
 
 # RUN: yaml2obj --docnum=1 -DBITS=64 -DENDIAN=MSB %s | obj2yaml | \
-# RUN:   FileCheck -DLENGTH1=3C -DLENGTH2=44 -DADDRSIZE=0x08 %s --check-prefix=BASIC --implicit-check-not=Sections
+# RUN:   FileCheck  %s --check-prefix=BASIC --implicit-check-not=Sections \
+# RUN:     -DLENGTH1=3C -DLENGTH2=44 -DADDRSIZE=0x08 \
+# RUN:     -DVARADDR=0x0000000000001234 -DVARLEN=0x0000000000005678
 
 #      BASIC: DWARF:
 # BASIC-NEXT:   debug_aranges:
 # BASIC-NEXT:     - Length:      0x00000000000000[[LENGTH1]]
 # BASIC-NEXT:       Version:     2
 # BASIC-NEXT:       CuOffset:    0x0000000000001234
 # BASIC-NEXT:       AddressSize: [[ADDRSIZE]]
 # BASIC-NEXT:       Descriptors:
 # BASIC-NEXT:         - Address: 0x0000000000001234
 # BASIC-NEXT:           Length:  0x0000000000005678
 # BASIC-NEXT:         - Address: 0x0000000000001234
 # BASIC-NEXT:           Length:  0x0000000000005678
 # BASIC-NEXT:     - Format:      DWARF64
 # BASIC-NEXT:       Length:      0x00000000000000[[LENGTH2]]
 # BASIC-NEXT:       Version:     2
 # BASIC-NEXT:       CuOffset:    0x1234567890ABCDEF
 # BASIC-NEXT:       AddressSize: [[ADDRSIZE]]
 # BASIC-NEXT:       Descriptors:
-# BASIC-NEXT:         - Address: 0x0000000000001234
-# BASIC-NEXT:           Length:  0x0000000000005678
+# BASIC-NEXT:         - Address: [[VARADDR]]
+# BASIC-NEXT:           Length:  [[VARLEN]]
 # BASIC-NEXT:         - Address: 0x0000000000001234
 # BASIC-NEXT:           Length:  0x0000000000005678
 # BASIC-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS[[BITS]]
   Data:    ELFDATA2[[ENDIAN]]
   Type:    ET_EXEC
   Machine: EM_X86_64
 DWARF:
   debug_aranges:
     - Version:  2
       CuOffset: 0x1234
       Descriptors:
         - Address: 0x1234
           Length:  0x5678
         - Address: 0x1234
           Length:  0x5678
     - Format:   DWARF64
       Version:  2
       CuOffset: 0x1234567890abcdef
       Descriptors:
-        - Address: 0x1234
-          Length:  0x5678
+        - Address: [[ADDR=0x1234]]
+          Length:  [[LENGTH=0x5678]]
         - Address: 0x1234
           Length:  0x5678
 
 ## b) Test dumping an .debug_aranges section whose section header properties are overridden.
 
 # RUN: yaml2obj --docnum=2 -DTYPE=SHT_STRTAB %s | obj2yaml | FileCheck %s -DTYPE=STRTAB --check-prefixes=ARANGE,SHDR
 # RUN: yaml2obj --docnum=2 -DFLAGS=[SHF_ALLOC] %s | obj2yaml | FileCheck %s -DTYPE=PROGBITS --check-prefixes=ARANGE,SHDR,FLAGS
 # RUN: yaml2obj --docnum=2 -DLINK='.sec' %s | obj2yaml | FileCheck %s -DTYPE=PROGBITS --check-prefixes=ARANGE,SHDR,LINK

 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 DWARF:
   debug_aranges: []
+
+## f) Show that dumping a table with a premature terminator entry still uses the
+## DWARF tag.
+
+# RUN: yaml2obj --docnum=1 %s -DADDR=0 -DLENGTH=0 -DBITS=64 -DENDIAN=LSB | obj2yaml | \
+# RUN:   FileCheck %s --check-prefix=BASIC --implicit-check-not=Sections \
+# RUN:     -DLENGTH1=3C -DLENGTH2=44 -DADDRSIZE=0x08  \
+# RUN:     -DVARADDR=0x0000000000000000 -DVARLEN=0x0000000000000000

llvm/tools/obj2yaml/dwarf2yaml.cpp

 }
 
 Error dumpDebugARanges(DWARFContext &DCtx, DWARFYAML::Data &Y) {
   DWARFDataExtractor ArangesData(DCtx.getDWARFObj().getArangesSection(),
                                  DCtx.isLittleEndian(), 0);
   uint64_t Offset = 0;
   DWARFDebugArangeSet Set;
   std::vector<DWARFYAML::ARange> DebugAranges;
+
+  // We ignore any errors that don't prevent parsing the section, since we can
+  // still represent such sections. These errors are recorded via the
+  // WarningHandler parameter of Set.extract().
+  auto DiscardError = [](Error Err) { consumeError(std::move(Err)); };
+
   while (ArangesData.isValidOffset(Offset)) {
-    if (Error E = Set.extract(ArangesData, &Offset))
+    if (Error E = Set.extract(ArangesData, &Offset, DiscardError))
       return E;
     DWARFYAML::ARange Range;
     Range.Format = Set.getHeader().Format;
     Range.Length = Set.getHeader().Length;
     Range.Version = Set.getHeader().Version;
     Range.CuOffset = Set.getHeader().CuOffset;
     Range.AddrSize = Set.getHeader().AddrSize;
     Range.SegSize = Set.getHeader().SegSize;

llvm/unittests/DebugInfo/DWARF/DWARFDebugArangeSetTest.cpp

 //===- llvm/unittest/DebugInfo/DWARFDebugArangeSetTest.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/DWARFDebugArangeSet.h"
+#include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
+struct WarningHandler {
+  ~WarningHandler() { EXPECT_THAT_ERROR(std::move(Err), Succeeded()); }
+
+  void operator()(Error E) { Err = joinErrors(std::move(Err), std::move(E)); }
+
+  Error getWarning() { return std::move(Err); }
+
+  Error Err = Error::success();
+};
+
 template <size_t SecSize>
 void ExpectExtractError(const char (&SecDataRaw)[SecSize],
                         const char *ErrorMessage) {
   DWARFDataExtractor Extractor(StringRef(SecDataRaw, SecSize - 1),
                                /* IsLittleEndian = */ true,
                                /* AddressSize = */ 4);
   DWARFDebugArangeSet Set;
   uint64_t Offset = 0;
-  Error E = Set.extract(Extractor, &Offset);
+  WarningHandler Warnings;
+  Error E = Set.extract(Extractor, &Offset, Warnings);
   ASSERT_TRUE(E.operator bool());
   EXPECT_STREQ(ErrorMessage, toString(std::move(E)).c_str());
 }
 
 TEST(DWARFDebugArangeSet, LengthExceedsSectionSize) {
   static const char DebugArangesSecRaw[] =
       "\x15\x00\x00\x00" // The length exceeds the section boundaries
       "\x02\x00"         // Version
static const char DebugArangesSecRaw[] =
       "\x00\x00\x00\x00" // Termination tuple
       "\x00\x00\x00\x00";
   ExpectExtractError(
       DebugArangesSecRaw,
       "address range table at offset 0x0 has length that is not a multiple "
       "of the tuple size");
 }
 
-TEST(DWARFDebugArangeSet, ZeroLengthEntry) {
+TEST(DWARFDebugArangeSet, ZeroAddressEntry) {
   static const char DebugArangesSecRaw[] =
-      "\x24\x00\x00\x00" // Length
+      "\x1c\x00\x00\x00" // Length
       "\x02\x00"         // Version
       "\x00\x00\x00\x00" // Debug Info Offset
       "\x04"             // Address Size
       "\x00"             // Segment Selector Size
       "\x00\x00\x00\x00" // Padding
       "\x00\x00\x00\x00" // Entry1: Address
       "\x01\x00\x00\x00" //         Length
+      "\x00\x00\x00\x00" // Termination tuple
+      "\x00\x00\x00\x00";
+  DWARFDataExtractor Extractor(
+      StringRef(DebugArangesSecRaw, sizeof(DebugArangesSecRaw) - 1),
+      /*IsLittleEndian=*/true,
+      /*AddressSize=*/4);
+  DWARFDebugArangeSet Set;
+  uint64_t Offset = 0;
+  ASSERT_THAT_ERROR(Set.extract(Extractor, &Offset, WarningHandler()),
+                    Succeeded());
+  auto Range = Set.descriptors();
+  auto Iter = Range.begin();
+  ASSERT_EQ(std::distance(Iter, Range.end()), 1u);
+  EXPECT_EQ(Iter->Address, 0u);
+  EXPECT_EQ(Iter->Length, 1u);
+}
+
+TEST(DWARFDebugArangeSet, ZeroLengthEntry) {
+  static const char DebugArangesSecRaw[] =
+      "\x1c\x00\x00\x00" // Length
+      "\x02\x00"         // Version
+      "\x00\x00\x00\x00" // Debug Info Offset
+      "\x04"             // Address Size
+      "\x00"             // Segment Selector Size
+      "\x00\x00\x00\x00" // Padding
+      "\x01\x00\x00\x00" // Entry1: Address
+      "\x00\x00\x00\x00" //         Length
+      "\x00\x00\x00\x00" // Termination tuple
+      "\x00\x00\x00\x00";
+  DWARFDataExtractor Extractor(
+      StringRef(DebugArangesSecRaw, sizeof(DebugArangesSecRaw) - 1),
+      /*IsLittleEndian=*/true,
+      /*AddressSize=*/4);
+  DWARFDebugArangeSet Set;
+  uint64_t Offset = 0;
+  ASSERT_THAT_ERROR(Set.extract(Extractor, &Offset, WarningHandler()),
+                    Succeeded());
+  auto Range = Set.descriptors();
+  auto Iter = Range.begin();
+  ASSERT_EQ(std::distance(Iter, Range.end()), 1u);
+  EXPECT_EQ(Iter->Address, 1u);
+  EXPECT_EQ(Iter->Length, 0u);
+}
+
+TEST(DWARFDebugArangesSet, PrematureTerminator) {
+  static const char DebugArangesSecRaw[] =
+      "\x24\x00\x00\x00" // Length
+      "\x02\x00"         // Version
+      "\x00\x00\x00\x00" // Debug Info Offset
+      "\x04"             // Address Size
+      "\x00"             // Segment Selector Size
+      "\x00\x00\x00\x00" // Padding
+      "\x00\x00\x00\x00" // Entry1: Premature
+      "\x00\x00\x00\x00" //         terminator
       "\x01\x00\x00\x00" // Entry2: Address
-      "\x00\x00\x00\x00" //         Length (invalid)
+      "\x01\x00\x00\x00" //         Length
       "\x00\x00\x00\x00" // Termination tuple
       "\x00\x00\x00\x00";
-  ExpectExtractError(
-      DebugArangesSecRaw,
-      "address range table at offset 0x0 has an invalid tuple (length = 0) "
-      "at offset 0x18");
+  DWARFDataExtractor Extractor(
+      StringRef(DebugArangesSecRaw, sizeof(DebugArangesSecRaw) - 1),
+      /*IsLittleEndian=*/true,
+      /*AddressSize=*/4);
+  DWARFDebugArangeSet Set;
+  uint64_t Offset = 0;
+  WarningHandler Warnings;
+  ASSERT_THAT_ERROR(Set.extract(Extractor, &Offset, Warnings), Succeeded());
+  auto Range = Set.descriptors();
+  auto Iter = Range.begin();
+  ASSERT_EQ(std::distance(Iter, Range.end()), 2u);
+  EXPECT_EQ(Iter->Address, 0u);
+  EXPECT_EQ(Iter->Length, 0u);
+  ++Iter;
+  EXPECT_EQ(Iter->Address, 1u);
+  EXPECT_EQ(Iter->Length, 1u);
+  EXPECT_THAT_ERROR(
+      Warnings.getWarning(),
+      FailedWithMessage("address range table at offset 0x0 has a premature "
+                        "terminator entry at offset 0x10"));
 }
 
 } // end anonymous namespace