[DWARF] Return Error from DWARFDebugArangeSet::extract().

[ikudrin]

Summary

This helps to detect and report parsing errors better. The patch follows the ideas of LLDB's patches D59370 and D59381.

It adds tests for valid and some invalid cases. More checks and tests to come. Note that the patch fixes validation of the Length field because the value does not include the field itself.

[dblaikie]

llvm/lib/DebugInfo/DWARF/DWARFDebugArangeSet.cpp

85

In a separate patch, might be good to add error handling to stop when the Header length is reached, rather than when the section end is reached.

91

I'd probably write these ays "x == 0" rather than "!x"

91–92

Potentially another error case could be added here (in another patch) in the case where the list is terminated earlier than the Length specified in the header.

96

Looks like the old code fails if the range list is empty - and maybe the new code deosn't fail in that case? Worth adding a test case? (it actually seems reasonable to me to support it - you could imagine a CU with only type information in it & so no covered addresses, and having an arange entry describing that so the consumer didn't have to go discover it through parsing the CU, etc)

[ikudrin]

• "!x" -> "x == 0";
• Improved error messages wordings;
• Added more tests;
• Fixed checking the value of the Length field.

[ikudrin]

Thanks for the suggestions, @dblaikie! I've added D71931 and D71932 with corresponding patches.

[dblaikie]

llvm/lib/DebugInfo/DWARF/DWARFDebugArangeSet.cpp

60–63

Could this be phrased more specifically - "length exceeds section size" or something like that?

64–68

Could this be more specific about what's invalid about the address size ("unsupported address size: 5 (4 and 8 supported)" or the like?)

[clayborg]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

463

does "toString()" consume the error?

llvm/lib/DebugInfo/DWARF/DWARFDebugArangeSet.cpp

34

return error instead of crashing the program

llvm/lib/DebugInfo/DWARF/DWARFDebugAranges.cpp

23

return llvm::Error here?

29–34

return an error if Set.extract fails? Seems weird to add error handling to only convert it to bool and ignore the error?

llvm/tools/obj2yaml/dwarf2yaml.cpp

65–68

Dump the error if Set.extract() fails?

[ikudrin]

• Update wordings.
• Replace most of the lit tests to check error cases with gtest-based ones.
• Do not silently absorb the error messages.
• Update existing tests and add new ones to reflect the changes.

[ikudrin]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

463

Yes. It uses handleAllErrors() internally.

llvm/lib/DebugInfo/DWARF/DWARFDebugArangeSet.cpp

34

This just checks for the precondition. Callers are responsible to call the method with valid arguments. Therefore, if this triggers, it should be considered as an internal error and fixed.

llvm/lib/DebugInfo/DWARF/DWARFDebugAranges.cpp

23

As this is just a private helper method for DWARFDebugAranges::generate(), I opted to print the errors here.

llvm/tools/obj2yaml/dwarf2yaml.cpp

65–68

Done, but it pulled a lot of changes. Maybe it worth to move all them into a separate patch.

[clayborg]

lgtm with Error being returned everywhere now.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

461–462

do we want {} on this while now?

[ikudrin]

• Used curly brackets for the while loop in dumping .debug_aranges in DWARFContext::dump().
• Removed else branch after break.

Thanks, @clayborg!

[dblaikie]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

457–460

Might this eventually want to go in the direction of having fallible errors and errors that can continue, like some of @jhenderson 's work? Should we come up with a consistent strategy for this sort of thing as it seems we've developed a few different error handling parsing schemes at this point.

[jhenderson]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

457–460

Yeah, we should a) be consistent (though I don't mind specifically what we standardise on) and b) avoid printing such low-level errors in a library, as it makes things hard for clients. See my lightning talk on the subject that was inspired by my debug line error handling work some time ago: https://www.youtube.com/watch?v=YSEY4pg1YB0

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/Support/Error.h"
 #include <cstdint>
 #include <vector>
 
 namespace llvm {
 
 class raw_ostream;
 
 class DWARFDebugArangeSet {
private:
   uint64_t Offset;
   Header HeaderData;
   DescriptorColl ArangeDescriptors;
 
 public:
   DWARFDebugArangeSet() { clear(); }
 
   void clear();
-  bool extract(DataExtractor data, uint64_t *offset_ptr);
+  Error extract(DataExtractor data, uint64_t *offset_ptr);
   void dump(raw_ostream &OS) const;
 
   uint32_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

if (DumpType & DIDT_DebugMacro) {
     }
   }
 
   if (shouldDump(Explicit, ".debug_aranges", DIDT_ID_DebugAranges,
                  DObj->getArangesSection())) {
     uint64_t offset = 0;
     DataExtractor arangesData(DObj->getArangesSection(), isLittleEndian(), 0);
     DWARFDebugArangeSet set;
-    while (set.extract(arangesData, &offset))
+    while (arangesData.isValidOffset(offset)) {
+      if (Error E = set.extract(arangesData, &offset)) {
+        WithColor::error() << toString(std::move(E)) << '\n';
+        break;
+      }
       set.dump(OS);
     }
+  }
 
   auto DumpLineSection = [&](DWARFDebugLine::SectionParser Parser,
                              DIDumpOptions DumpOpts,
                              Optional<uint64_t> DumpOffset) {
     while (!Parser.done()) {
       if (DumpOffset && Parser.getOffset() != *DumpOffset) {
         Parser.skip(dumpWarning);
         continue;

llvm/lib/DebugInfo/DWARF/DWARFDebugArangeSet.cpp

 //===- DWARFDebugArangeSet.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/Support/Errc.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cinttypes>
 #include <cstdint>
 #include <cstring>
 
 using namespace llvm;
 
 void DWARFDebugArangeSet::Descriptor::dump(raw_ostream &OS,
                                            uint32_t AddressSize) const {
   OS << format("[0x%*.*" PRIx64 ", ", AddressSize * 2, AddressSize * 2, Address)
      << format(" 0x%*.*" PRIx64 ")", AddressSize * 2, AddressSize * 2,
                getEndAddress());
 }
 
 void DWARFDebugArangeSet::clear() {
   Offset = -1ULL;
   std::memset(&HeaderData, 0, sizeof(Header));
   ArangeDescriptors.clear();
 }
 
-bool
-DWARFDebugArangeSet::extract(DataExtractor data, uint64_t *offset_ptr) {
-  if (data.isValidOffset(*offset_ptr)) {
-    ArangeDescriptors.clear();
-    Offset = *offset_ptr;
+Error DWARFDebugArangeSet::extract(DataExtractor data, uint64_t *offset_ptr) {
+  assert(data.isValidOffset(*offset_ptr));
 
-    // 7.20 Address Range Table
-    //
-    // Each set of entries in the table of address ranges contained in
-    // the .debug_aranges section begins with a header consisting of: a
-    // 4-byte length containing the length of the set of entries for this
-    // compilation unit, not including the length field itself; a 2-byte
-    // version identifier containing the value 2 for DWARF Version 2; a
-    // 4-byte offset into the.debug_infosection; a 1-byte unsigned integer
-    // containing the size in bytes of an address (or the offset portion of
-    // an address for segmented addressing) on the target system; and a
-    // 1-byte unsigned integer containing the size in bytes of a segment
-    // descriptor on the target system. This header is followed by a series
-    // of tuples. Each tuple consists of an address and a length, each in
-    // the size appropriate for an address on the target architecture.
-    HeaderData.Length = data.getU32(offset_ptr);
-    HeaderData.Version = data.getU16(offset_ptr);
-    HeaderData.CuOffset = data.getU32(offset_ptr);
-    HeaderData.AddrSize = data.getU8(offset_ptr);
-    HeaderData.SegSize = data.getU8(offset_ptr);
 
-    // Perform basic validation of the header fields.
-    if (!data.isValidOffsetForDataOfSize(Offset, HeaderData.Length) ||
-        (HeaderData.AddrSize != 4 && HeaderData.AddrSize != 8)) {
-      clear();
-      return false;
-    }
+  if (!data.isValidOffsetForDataOfSize(Offset, HeaderData.Length + 4))
+    return createStringError(errc::invalid_argument,
+                             "the length of address range table at offset "
+                             "0x%" PRIx64 " exceeds section size",
+                             Offset);
+  if (HeaderData.AddrSize != 4 && HeaderData.AddrSize != 8)
+    return createStringError(errc::invalid_argument,
+                             "address range table at offset 0x%" PRIx64
+                             " has unsupported address size: %d "
+                             "(4 and 8 supported)",
+                             Offset, HeaderData.AddrSize);
 
-    // The first tuple following the header in each set begins at an offset
-    // that is a multiple of the size of a single tuple (that is, twice the
-    // size of an address). The header is padded, if necessary, to the
-    // appropriate boundary.
-    const uint32_t header_size = *offset_ptr - Offset;
-    const uint32_t tuple_size = HeaderData.AddrSize * 2;
-    uint32_t first_tuple_offset = 0;
-    while (first_tuple_offset < header_size)
-      first_tuple_offset += tuple_size;
 
-    *offset_ptr = Offset + first_tuple_offset;
 
-    Descriptor arangeDescriptor;
 
-    static_assert(sizeof(arangeDescriptor.Address) ==
-                      sizeof(arangeDescriptor.Length),
-                  "Different datatypes for addresses and sizes!");
-    assert(sizeof(arangeDescriptor.Address) >= HeaderData.AddrSize);
 
-    while (data.isValidOffset(*offset_ptr)) {
-      arangeDescriptor.Address = data.getUnsigned(offset_ptr, HeaderData.AddrSize);
-      arangeDescriptor.Length = data.getUnsigned(offset_ptr, HeaderData.AddrSize);
 
-      // Each set of tuples is terminated by a 0 for the address and 0
-      // for the length.
-      if (arangeDescriptor.Address || arangeDescriptor.Length)
-        ArangeDescriptors.push_back(arangeDescriptor);
-      else
-        return true; // We are done if we get a zero address and length
-    }
+    if (arangeDescriptor.Address == 0 && arangeDescriptor.Length == 0)
+      return ErrorSuccess();
 
-    return false; // No termination tuple is found.
-  }
-  return false;
+  return createStringError(errc::invalid_argument,
+                           "address range table at offset 0x%" PRIx64
+                           " is not terminated by null entry",
+                           Offset);
 }
 
 void DWARFDebugArangeSet::dump(raw_ostream &OS) const {
   OS << format("Address Range Header: length = 0x%8.8x, version = 0x%4.4x, ",
                HeaderData.Length, HeaderData.Version)
      << format("cu_offset = 0x%8.8x, addr_size = 0x%2.2x, seg_size = 0x%2.2x\n",
                HeaderData.CuOffset, HeaderData.AddrSize, HeaderData.SegSize);
 
   for (const auto &Desc : ArangeDescriptors) {
     Desc.dump(OS, HeaderData.AddrSize);
     OS << '\n';
   }
 }

llvm/lib/DebugInfo/DWARF/DWARFDebugAranges.cpp

 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <set>
 #include <vector>
 
 using namespace llvm;
 
 void DWARFDebugAranges::extract(DataExtractor DebugArangesData) {
   if (!DebugArangesData.isValidOffset(0))
     return;
   uint64_t Offset = 0;
   DWARFDebugArangeSet Set;
 
-  while (Set.extract(DebugArangesData, &Offset)) {
+  while (DebugArangesData.isValidOffset(Offset)) {
+    if (Error E = Set.extract(DebugArangesData, &Offset)) {
+      WithColor::error() << toString(std::move(E)) << '\n';
+      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);
     }
     ParsedCUOffsets.insert(CUOffset);
   }
 }

llvm/test/DebugInfo/X86/dwarfdump-debug-aranges.s

 # RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o - | \
 # RUN:  llvm-dwarfdump -debug-aranges - 2>&1 | \
 # RUN:  FileCheck %s
 
     .section .debug_aranges,"",@progbits
 # CHECK: .debug_aranges contents:
 
-## Check that an empty set of ranges is supported.
+## Case 1: Check that an empty set of ranges is supported.
     .long   .L1end - .L1version     # Length
 # CHECK: Address Range Header: length = 0x00000014,
 .L1version:
     .short  2                       # Version
     .long   0x3456789a              # Debug Info Offset
     .byte   4                       # Address Size
     .byte   0                       # Segment Selector Size
 # CHECK-SAME: version = 0x0002,
 # CHECK-SAME: cu_offset = 0x3456789a,
 # CHECK-SAME: addr_size = 0x04,
 # CHECK-SAME: seg_size = 0x00
     .space 4                        # Padding
 .L1tuples:
     .long   0, 0                    # Termination tuple
 # CHECK-NOT: [0x
 .L1end:
+
+## Case 2: Check that the address size of 4 is supported.
+    .long   .L2end - .L2version     # Length
+# CHECK: Address Range Header: length = 0x0000001c,
+.L2version:
+    .short  2                       # Version
+    .long   0x11223344              # Debug Info Offset
+    .byte   4                       # Address Size
+    .byte   0                       # Segment Selector Size
+# CHECK-SAME: version = 0x0002,
+# CHECK-SAME: cu_offset = 0x11223344,
+# CHECK-SAME: addr_size = 0x04,
+# CHECK-SAME: seg_size = 0x00
+    .space  4                       # Padding
+.L2tuples:
+    .long   0x11223344, 0x01020304  # Address and length
+# CHECK-NEXT: [0x11223344,  0x12243648)
+    .long   0, 0                    # Termination tuple
+# CHECK-NOT: [0x
+.L2end:
+
+## Case 3: Check that the address size of 8 is also supported.
+    .long   .L3end - .L3version     # Length
+# CHECK: Address Range Header: length = 0x0000002c,
+.L3version:
+    .short  2                       # Version
+    .long   0x22334455              # Debug Info Offset
+    .byte   8                       # Address Size
+    .byte   0                       # Segment Selector Size
+# CHECK-SAME: version = 0x0002,
+# CHECK-SAME: cu_offset = 0x22334455,
+# CHECK-SAME: addr_size = 0x08,
+# CHECK-SAME: seg_size = 0x00
+    .space  4                       # Padding
+.L3tuples:
+    .quad   0x1122334455667788      # Address
+    .quad   0x0102030405060708      # Length
+# CHECK-NEXT: [0x1122334455667788,  0x122436485a6c7e90)
+    .quad   0, 0                    # Termination tuple
+# CHECK-NOT: [0x
+.L3end:

llvm/test/ObjectYAML/MachO/DWARF-debug_abbrev.yaml

Sections:
         offset:          0x00002060
         align:           0
         reloff:          0x00000000
         nreloc:          0
         flags:           0x00000000
         reserved1:       0x00000000
         reserved2:       0x00000000
         reserved3:       0x00000000
-      - sectname:        __debug_aranges
-        segname:         __DWARF
-        addr:            0x0000000100003083
-        size:            48
-        offset:          0x00002083
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x00000000
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
       - sectname:        __debug_info
         segname:         __DWARF
         addr:            0x00000001000030B3
         size:            121
         offset:          0x000020B3
         align:           0
         reloff:          0x00000000
         nreloc:          0

llvm/test/ObjectYAML/MachO/DWARF-debug_str.yaml

Sections:
         offset:          0x00002061
         align:           0
         reloff:          0x00000000
         nreloc:          0
         flags:           0x00000000
         reserved1:       0x00000000
         reserved2:       0x00000000
         reserved3:       0x00000000
-      - sectname:        __debug_aranges
-        segname:         __DWARF
-        addr:            0x0000000100002084
-        size:            48
-        offset:          0x00002084
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x00000000
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
       - sectname:        __debug_info
         segname:         __DWARF
         addr:            0x00000001000020B4
         size:            121
         offset:          0x000020B4
         align:           0
         reloff:          0x00000000
         nreloc:          0

llvm/test/ObjectYAML/MachO/DWARF-pubsections.yaml

Sections:
         offset:          0x00002060
         align:           0
         reloff:          0x00000000
         nreloc:          0
         flags:           0x00000000
         reserved1:       0x00000000
         reserved2:       0x00000000
         reserved3:       0x00000000
-      - sectname:        __debug_aranges
-        segname:         __DWARF
-        addr:            0x0000000100003083
-        size:            48
-        offset:          0x00002083
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x00000000
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
       - sectname:        __debug_info
         segname:         __DWARF
         addr:            0x00000001000030B3
         size:            121
         offset:          0x000020B3
         align:           0
         reloff:          0x00000000
         nreloc:          0

llvm/test/ObjectYAML/MachO/DWARF2-AddrSize8-FormValues.yaml

Sections:
         offset:          0x00002060
         align:           0
         reloff:          0x00000000
         nreloc:          0
         flags:           0x00000000
         reserved1:       0x00000000
         reserved2:       0x00000000
         reserved3:       0x00000000
-      - sectname:        __debug_aranges
-        segname:         __DWARF
-        addr:            0x0000000100003083
-        size:            48
-        offset:          0x00002083
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x00000000
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
       - sectname:        __debug_info
         segname:         __DWARF
         addr:            0x00000001000030B3
         size:            180
         offset:          0x000020B3
         align:           0
         reloff:          0x00000000
         nreloc:          0

llvm/test/ObjectYAML/MachO/DWARF5-abbrevValues.yaml

Sections:
         offset:          0x00002060
         align:           0
         reloff:          0x00000000
         nreloc:          0
         flags:           0x00000000
         reserved1:       0x00000000
         reserved2:       0x00000000
         reserved3:       0x00000000
-      - sectname:        __debug_aranges
-        segname:         __DWARF
-        addr:            0x0000000100003083
-        size:            48
-        offset:          0x00002083
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x00000000
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
       - sectname:        __debug_info
         segname:         __DWARF
         addr:            0x00000001000030B3
         size:            121
         offset:          0x000020B3
         align:           0
         reloff:          0x00000000
         nreloc:          0

llvm/test/tools/llvm-dwarfdump/X86/debug_aranges-error.s

+# RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o %t.o
+# RUN: llvm-dwarfdump -debug-aranges %t.o 2>&1 | FileCheck %s
+# RUN: llvm-dwarfdump -lookup 10 %t.o 2>&1 | FileCheck %s
+
+## This checks that llvm-dwarfdump shows parsing errors in .debug_aranges.
+## For more error cases see unittests/DebugInfo/DWARF/DWARFDebugArangeSetTest.cpp.
+
+# CHECK: the length of address range table at offset 0x0 exceeds section size
+
+    .section .debug_aranges,"",@progbits
+    .long   .Lend - .Lversion + 1   # The length exceeds the section boundaries
+.Lversion:
+    .short  2                       # Version
+    .long   0                       # Debug Info Offset
+    .byte   4                       # Address Size
+    .byte   0                       # Segment Selector Size
+    .space  4                       # Padding
+.Ltuples:
+    .long   0, 1                    # Address and length
+    .long   0, 0                    # Termination tuple
+.Lend:

llvm/test/tools/obj2yaml/macho-DWARF-debug_aranges-error.yaml

-# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+# RUN: yaml2obj %s | not obj2yaml 2>&1 | FileCheck %s
 
 --- !mach-o
 FileHeader:      
   magic:           0xFEEDFACF
   cputype:         0x01000007
   cpusubtype:      0x00000003
   filetype:        0x0000000A
   ncmds:           5
Sections:
         offset:          0x000022D8
         align:           0
         reloff:          0x00000000
         nreloc:          0
         flags:           0x00000000
         reserved1:       0x00000000
         reserved2:       0x00000000
         reserved3:       0x00000000
-DWARF:           
-  debug_abbrev:     
-    - Code:            0x00000001
-      Tag:             DW_TAG_compile_unit
-      Children:        DW_CHILDREN_yes
-      Attributes:      
-        - Attribute:       0x2001
-          Form:            DW_FORM_implicit_const
-          Value:           0x12345678
+DWARF:
+  debug_aranges:
+    - Length:
+        TotalLength:     45
+      Version:         2
+      CuOffset:        0
+      AddrSize:        8
+      SegSize:         0
+      Descriptors:
+        - Address:         0x0000000100000F50
+          Length:          52
 ...
 
-#CHECK: DWARF:           
-#CHECK:   debug_abbrev:
-#CHECK:     - Code:            0x00000001
-#CHECK:       Tag:             DW_TAG_compile_unit
-#CHECK:       Children:        DW_CHILDREN_yes
-#CHECK:       Attributes:
-#CHECK:         - Attribute:       0x2001
-#CHECK:           Form:            DW_FORM_implicit_const
-#CHECK:           Value:           0x0000000012345678
+#CHECK: the length of address range table at offset 0x0 exceeds section size

llvm/tools/obj2yaml/dwarf2yaml.cpp

void dumpDebugStrings(DWARFContext &DCtx, DWARFYAML::Data &Y) {
   StringRef RemainingTable = DCtx.getDWARFObj().getStrSection();
   while (RemainingTable.size() > 0) {
     auto SymbolPair = RemainingTable.split('\0');
     RemainingTable = SymbolPair.second;
     Y.DebugStrings.push_back(SymbolPair.first);
   }
 }
 
-void dumpDebugARanges(DWARFContext &DCtx, DWARFYAML::Data &Y) {
+Error dumpDebugARanges(DWARFContext &DCtx, DWARFYAML::Data &Y) {
   DataExtractor ArangesData(DCtx.getDWARFObj().getArangesSection(),
                             DCtx.isLittleEndian(), 0);
   uint64_t Offset = 0;
   DWARFDebugArangeSet Set;
 
-  while (Set.extract(ArangesData, &Offset)) {
+  while (ArangesData.isValidOffset(Offset)) {
+    if (Error E = Set.extract(ArangesData, &Offset))
+      return E;
     DWARFYAML::ARange Range;
     Range.Length.setLength(Set.getHeader().Length);
     Range.Version = Set.getHeader().Version;
     Range.CuOffset = Set.getHeader().CuOffset;
     Range.AddrSize = Set.getHeader().AddrSize;
     Range.SegSize = Set.getHeader().SegSize;
     for (auto Descriptor : Set.descriptors()) {
       DWARFYAML::ARangeDescriptor Desc;
       Desc.Address = Descriptor.Address;
       Desc.Length = Descriptor.Length;
       Range.Descriptors.push_back(Desc);
     }
     Y.ARanges.push_back(Range);
   }
+  return ErrorSuccess();
 }
 
 void dumpPubSection(DWARFContext &DCtx, DWARFYAML::PubSection &Y,
                     DWARFSection Section) {
   DWARFDataExtractor PubSectionData(DCtx.getDWARFObj(), Section,
                                     DCtx.isLittleEndian(), 0);
   uint64_t Offset = 0;
   dumpInitialLength(PubSectionData, Offset, Y.Length);
if (auto StmtOffset =
         }
         DebugLines.Opcodes.push_back(NewOp);
       }
       Y.DebugLines.push_back(DebugLines);
     }
   }
 }
 
-std::error_code dwarf2yaml(DWARFContext &DCtx, DWARFYAML::Data &Y) {
+llvm::Error dwarf2yaml(DWARFContext &DCtx, DWARFYAML::Data &Y) {
   dumpDebugAbbrev(DCtx, Y);
   dumpDebugStrings(DCtx, Y);
-  dumpDebugARanges(DCtx, Y);
+  if (Error E = dumpDebugARanges(DCtx, Y))
+    return E;
   dumpDebugPubSections(DCtx, Y);
   dumpDebugInfo(DCtx, Y);
   dumpDebugLines(DCtx, Y);
-  return obj2yaml_error::success;
+  return ErrorSuccess();
 }

llvm/tools/obj2yaml/macho2yaml.cpp

Expected<std::unique_ptr<MachOYAML::Object>> MachODumper::dump() {
   auto Y = std::make_unique<MachOYAML::Object>();
   Y->IsLittleEndian = Obj.isLittleEndian();
   dumpHeader(Y);
   dumpLoadCommands(Y);
   dumpLinkEdit(Y);
 
   std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(Obj);
   if (auto Err = dwarf2yaml(*DICtx, Y->DWARF))
-    return errorCodeToError(Err);
+    return std::move(Err);
   return std::move(Y);
 }
 
 void MachODumper::dumpHeader(std::unique_ptr<MachOYAML::Object> &Y) {
   Y->Header.magic = Obj.getHeader().magic;
   Y->Header.cputype = Obj.getHeader().cputype;
   Y->Header.cpusubtype = Obj.getHeader().cpusubtype;
   Y->Header.filetype = Obj.getHeader().filetype;
for (auto Slice : Obj.objects()) {
     YAML.Slices.push_back(*YAMLObj.get());
   }
 
   yaml::Output Yout(Out);
   Yout << YAML;
   return Error::success();
 }
 
-std::error_code macho2yaml(raw_ostream &Out, const object::Binary &Binary) {
+Error macho2yaml(raw_ostream &Out, const object::Binary &Binary) {
   if (const auto *MachOObj = dyn_cast<object::MachOUniversalBinary>(&Binary)) {
     if (auto Err = macho2yaml(Out, *MachOObj)) {
-      return errorToErrorCode(std::move(Err));
+      return Err;
     }
-    return obj2yaml_error::success;
+    return Error::success();
   }
 
   if (const auto *MachOObj = dyn_cast<object::MachOObjectFile>(&Binary)) {
     if (auto Err = macho2yaml(Out, *MachOObj)) {
-      return errorToErrorCode(std::move(Err));
+      return Err;
     }
-    return obj2yaml_error::success;
+    return Error::success();
   }
 
-  return obj2yaml_error::unsupported_obj_file_format;
+  return errorCodeToError(obj2yaml_error::unsupported_obj_file_format);
 }

llvm/tools/obj2yaml/obj2yaml.h

 #include "llvm/Object/XCOFFObjectFile.h"
 #include "llvm/Support/raw_ostream.h"
 #include <system_error>
 
 std::error_code coff2yaml(llvm::raw_ostream &Out,
                           const llvm::object::COFFObjectFile &Obj);
 llvm::Error elf2yaml(llvm::raw_ostream &Out,
                          const llvm::object::ObjectFile &Obj);
-std::error_code macho2yaml(llvm::raw_ostream &Out,
+llvm::Error macho2yaml(llvm::raw_ostream &Out,
                            const llvm::object::Binary &Obj);
 llvm::Error minidump2yaml(llvm::raw_ostream &Out,
                           const llvm::object::MinidumpFile &Obj);
 std::error_code xcoff2yaml(llvm::raw_ostream &Out,
                            const llvm::object::XCOFFObjectFile &Obj);
 std::error_code wasm2yaml(llvm::raw_ostream &Out,
                           const llvm::object::WasmObjectFile &Obj);
 
 // Forward decls for dwarf2yaml
 namespace llvm {
 class DWARFContext;
 namespace DWARFYAML {
 struct Data;
 }
 }
 
-std::error_code dwarf2yaml(llvm::DWARFContext &DCtx, llvm::DWARFYAML::Data &Y);
+llvm::Error dwarf2yaml(llvm::DWARFContext &DCtx, llvm::DWARFYAML::Data &Y);
 
 #endif

llvm/tools/obj2yaml/obj2yaml.cpp

static Error dumpInput(StringRef File) {
   Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(File);
   if (!BinaryOrErr)
     return BinaryOrErr.takeError();
 
   Binary &Binary = *BinaryOrErr.get().getBinary();
   // Universal MachO is not a subclass of ObjectFile, so it needs to be handled
   // here with the other binary types.
   if (Binary.isMachO() || Binary.isMachOUniversalBinary())
-    return errorCodeToError(macho2yaml(outs(), Binary));
+    return macho2yaml(outs(), Binary);
   // TODO: If this is an archive, then burst it and dump each entry
   if (ObjectFile *Obj = dyn_cast<ObjectFile>(&Binary))
     return dumpObject(*Obj);
   if (MinidumpFile *Minidump = dyn_cast<MinidumpFile>(&Binary))
     return minidump2yaml(outs(), *Minidump);
 
   return Error::success();
 }

llvm/unittests/DebugInfo/DWARF/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   AsmPrinter
   DebugInfoDWARF
   MC
   Object
   ObjectYAML
   Support
   )
 
 add_llvm_unittest(DebugInfoDWARFTests
   DwarfGenerator.cpp
   DwarfUtils.cpp
+  DWARFDebugArangeSetTest.cpp
   DWARFDebugInfoTest.cpp
   DWARFDebugLineTest.cpp
   DWARFDieTest.cpp
   DWARFFormValueTest.cpp
   DWARFLocationExpressionTest.cpp
   )
 
 target_link_libraries(DebugInfoDWARFTests PRIVATE LLVMTestingSupport)

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 "gtest/gtest.h"
+
+using namespace llvm;
+
+namespace {
+
+template <size_t SecSize>
+void ExpectExtractError(const char (&SecDataRaw)[SecSize],
+                        const char *ErrorMessage) {
+  DataExtractor 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) {
+  static const char DebugArangesSecRaw[] =
+      "\x15\x00\x00\x00" // The length exceeds the section boundaries
+      "\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" // Termination tuple
+      "\x00\x00\x00\x00";
+  ExpectExtractError(
+      DebugArangesSecRaw,
+      "the length of address range table at offset 0x0 exceeds section size");
+}
+
+TEST(DWARFDebugArangeSet, UnsupportedAddressSize) {
+  static const char DebugArangesSecRaw[] =
+      "\x0c\x00\x00\x00"  // Length
+      "\x02\x00"          // Version
+      "\x00\x00\x00\x00"  // Debug Info Offset
+      "\x02"              // Address Size (not supported)
+      "\x00"              // Segment Selector Size
+                          // No padding
+      "\x00\x00\x00\x00"; // Termination tuple
+  ExpectExtractError(
+      DebugArangesSecRaw,
+      "address range table at offset 0x0 has unsupported address size: 2 "
+      "(4 and 8 supported)");
+}
+
+TEST(DWARFDebugArangeSet, NoTerminationEntry) {
+  static const char DebugArangesSecRaw[] =
+      "\x14\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" // Entry: Address
+      "\x01\x00\x00\x00" //        Length
+      ;                  // No termination tuple
+  ExpectExtractError(
+      DebugArangesSecRaw,
+      "address range table at offset 0x0 is not terminated by null entry");
+}
+
+} // end anonymous namespace