Fix the verification of DIEs with DW_AT_ranges.

[clayborg]

Summary

There was a bug when processing the DW_AT_ranges for a DIE where as soon as an overlapping address range was found, we would stop processing and further ranges in a DW_AT_ranges set of address ranges. This means the DIE, usually a DW_AT_compile_unit, would end up with a truncated list of address ranges. This would cause spurious errors to be emitted stating that a DIE was not contained in a parent's address ranges.

This has now been fixed and added a fix and a test.

[clayborg]

The verification for:

0x0000000b: DW_TAG_compile_unit
              DW_AT_name        ("/tmp/main.c")
              DW_AT_language    (DW_LANG_C_plus_plus)
              DW_AT_low_pc      (0x0000000000000000)
              DW_AT_ranges      (0x00000000
                 [0x0000000000000000, 0x0000000000000020)
                 [0x0000000000000000, 0x0000000000000030)
                 [0x0000000000001000, 0x0000000000002000))
              DW_AT_stmt_list   (0x00000000)

0x00000022:   DW_TAG_subprogram
                DW_AT_name      ("stripped1")
                DW_AT_low_pc    (0x0000000000000000)
                DW_AT_high_pc   (0x0000000000000020)

0x00000033:   DW_TAG_subprogram
                DW_AT_name      ("stripped2")
                DW_AT_low_pc    (0x0000000000000000)
                DW_AT_high_pc   (0x0000000000000030)

0x00000048:   DW_TAG_subprogram
                DW_AT_name      ("main")
                DW_AT_low_pc    (0x0000000000001000)
                DW_AT_high_pc   (0x0000000000002000)

0x00000059:   NULL

Now looks like:

$ ../debug/bin/llvm-dwarfdump --verify /tmp/a.out
Verifying /tmp/a.out:   file format Mach-O 64-bit x86-64
Verifying .debug_abbrev...
Verifying .debug_info Unit Header Chain...
error: DIE has overlapping ranges in DW_AT_ranges attribute: [0x0000000000000000, 0x0000000000000020) and [0x0000000000000000, 0x0000000000000030)
0x0000000b:   DW_TAG_compile_unit
                DW_AT_name      ("/tmp/main.c")
                DW_AT_language  (DW_LANG_C_plus_plus)
                DW_AT_low_pc    (0x0000000000000000)
                DW_AT_ranges    (0x00000000
                   [0x0000000000000000, 0x0000000000000020)
                   [0x0000000000000000, 0x0000000000000030)
                   [0x0000000000001000, 0x0000000000002000))
                DW_AT_stmt_list (0x00000000)

error: DIEs have overlapping address ranges:
0x00000033: DW_TAG_subprogram
              DW_AT_name        ("stripped2")
              DW_AT_low_pc      (0x0000000000000000)
              DW_AT_high_pc     (0x0000000000000030)

0x00000022: DW_TAG_subprogram
              DW_AT_name        ("stripped1")
              DW_AT_low_pc      (0x0000000000000000)
              DW_AT_high_pc     (0x0000000000000020)

Verifying .debug_info references...
Verifying .debug_types Unit Header Chain...
Errors detected.

[dblaikie]

I'm not able to understand the description of the original bug, perhaps you could show the original behavior for your test case for comparison?

llvm/include/llvm/DebugInfo/DWARF/DWARFAddressRange.h

58

Probably could use a more explicit name - "union_if_intersecting"?

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

48

No need to have the llvm:: qualification here.

416

Where have you seen -1? Both gold and lld use 0, binutils ld... is more complicated, but I don't think it uses -1? hmm, maybe it does... hmm, at least for ranges it uses 1: [0x0000000000000001, 0x0000000000000001) which is different from gold and lld but for the address it uses zero:

DW_AT_low_pc    (0x0000000000000000)
DW_AT_high_pc   (0x0000000000000006)

[clayborg]

In D79962#2037671, @dblaikie wrote:

I'm not able to understand the description of the original bug, perhaps you could show the original behavior for your test case for comparison?

I will improve the description and improve the test to include some checks to make sure something is not there.

Basically if the DW_TAG_compile_unit had a DW_AT_ranges that had overlapping ranges, there was a break statement that would stop it from gathering all of the valid ranges for the compile unit. Then and DIEs whose address ranges didn't get added to the CU's ranges would emit an error. Here is a real example with some names changed:

error: DIE has overlapping address ranges: [0x0000000000000000, 0x0000000000000008) and [0x0000000000000000, 0x000000000000001e)
error: DIE address ranges are not contained in its parent's ranges:
0x0002022e: DW_TAG_compile_unit
              DW_AT_producer	("...")
              DW_AT_language	(DW_LANG_C_plus_plus)
              DW_AT_name	("...")
              DW_AT_stmt_list	(0x00004f60)
              DW_AT_comp_dir	(".")
              DW_AT_GNU_pubnames	(true)
              DW_AT_low_pc	(0x0000000000000000)
              DW_AT_ranges	(0x000010b0
                 [0x000045c4, 0x000045e8)
                 [0x00000000, 0x0000001e)
                 [0x00000000, 0x00000008)
                 [0x000049bc, 0x000049c0)
                 [0x000049c0, 0x00004a08)
                 [0x00004a08, 0x00004a0e))

0x0002f1f1:   DW_TAG_subprogram
                DW_AT_low_pc	(0x00000000000049c0)
                DW_AT_high_pc	(0x0000000000004a08)
                DW_AT_frame_base	(DW_OP_reg13)
                DW_AT_object_pointer	(0x0002f214)
                DW_AT_linkage_name	("_ZNSt12__shared_ptr...")
                DW_AT_specification	(0x00022eef)

But note that this range [0x49c0-0x4a08) IS in the DW_AT_ranges of the CU. So even if there are overlapping address ranges, we need to report them all and then shoe the DIE. I also modified the warning message to let you know that there are ovarlapping DW_AT_ranges in a DIE to make this more clear what is overlapping. So this diff is fixing this incorrect error reporting for "DIE address ranges are not contained in its parent's ranges".

llvm/include/llvm/DebugInfo/DWARF/DWARFAddressRange.h

58

that works

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

416

I believe Paul Robinson stated that the Sony linker does this. Paul did I remember correctly?

[clayborg]

I updated the description to better explain the fix.

[clayborg]

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

413

This was the problem "break;" that would stop parsing each range in "Ranges" and cause the address ranges for a DIE with DW_AT_ranges to be truncated. We still want a complete address range list for verification purposes.

[dblaikie]

Makes rough sense, but I'll leave it to folks who've worked more closely on the validator to chime in/approve (already cc'd)

[clayborg]

Fixed test case to properly check that we do not see a "error: DIE address ranges are not contained in its parent's ranges:" string in the output. The old llvm-dwarfdump --verify would have this incorrect error.

[clayborg]

Rename union_range to union_if_intersecting and and remove llvm:: qualification on None.

[clayborg]

All issues should be resolved. Test case was improved to verify old behavior doesn't persist by adding a CHECK-NOT in the test case.

[jhenderson]

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

416

Not got time to do a full review myself today, but just chiming in to confirm that the Sony linker patches low_pc to -1 for stripped stuff in .debug_info and .debug_aranges. For .debug_ranges we actually use -2/-2 pairs because -1 is a special value in that section.

I vaguely recall that there was some discussion on the mailing list about this a couple of years ago, and that there may be some other users of this approach too.

[clayborg]

Ping in case anyone has time to help move this forward.

[jhenderson]

I don't know if you've noticed, but you might be interested in following @Higuoxing's GSOC project to implement DWARF support for ELF yaml2obj. That would allow you to write this test using ELF, and omit 99% of the noise (to be clear, I'm not suggesting waiting, but it should help you in the future). If you've got any specific comments on his proposal, there's an RFC that's just gone up on the mailing list. I'd hope that some of the principles in that project (auto-generating most of the debug data) might even be more generically useful for Mach-O in the future.

llvm/include/llvm/DebugInfo/DWARF/DWARFAddressRange.h

58

Shouldn't it be unionIfIntersecting?

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

35–44

I think this and the similar code below be simplified slightly:

DWARFAddressRange Range(*Pos);
if (Pos->union_if_intersecting(R))
  return Range;

Alternatively, get rid of the "if intersecting" part of the union function (perhaps make it an assertion instead, but I'm not sure).

416

Some more related thoughts:

A range of (0, 0) is the end marker, whilst (-1, ...) is a base address selection entry. I don't know how these are represented (if at all) in the table. Either way, as mentioned (-2, -2) is a range we use for deadstripped code, so if that can be handled, we'd be very grateful! Last time I checked (admittedly quite a long while ago) DWARF verification didn't work for us because of stripped stuff (and possibly other reasons, but we haven't bothered digging further yet).

llvm/test/tools/llvm-dwarfdump/X86/verify_overlapping_cu_ranges.yaml

68

Maybe it would be better to add --implicit-check-not=error: to FileCheck's invocation. That way, all errors will be detected, regardless of position, and will avoid this check passing spuriously in the future should the text of the message ever change.

[clayborg]

llvm/include/llvm/DebugInfo/DWARF/DWARFAddressRange.h

58

yep, I will change it

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

39

True. I will do rename to "union" since we already know it intersects.

416

My next patch will be to calculate all of the read + execute section ranges and verify all addresses against this. If the address ranges aren't in the read+execute ranges, then ignore the address (on fully linked input files only, not .o files). This will help clear out incorrect errors that find overlapping address ranges. That should be enough.

llvm/test/tools/llvm-dwarfdump/X86/verify_overlapping_cu_ranges.yaml

68

that is a good idea. I haven't used that flag before.

[jhenderson]

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

39

Hehe, just realised that union might not be an option for keyword reasons... Maybe something like merge would be okay.

[clayborg]

Simplified logic in DieRangeInfo::insert() and switch DWARFAddressRange::union_if_intersecting() to DWARFAddressRange::merge().

[Higuoxing]

llvm/include/llvm/DebugInfo/DWARF/DWARFVerifier.h

64

"if a DIE" -> "of a DIE" ?

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

402

I think the variable name GotError is a little bit ambiguous here. What about renaming it to InvalidOrOverlapped or something else?

[clayborg]

Fixed "if a DIE" to be "of a DIE" and renamed GotError to DumpDieAfterError.

[clayborg]

llvm/test/tools/llvm-dwarfdump/X86/verify_overlapping_cu_ranges.yaml

68

Actually can't include this because there is an error before this on line 44

[clayborg]

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

402

Yeah, I need something to dump the DIE once if we find any issues with its attributes and have already emitted an error message.

[jhenderson]

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

416

By the way, LLD is about to start patching -1/-2 for .debug data addresses to indicate "ignore me". See D81784.

llvm/test/tools/llvm-dwarfdump/X86/verify_overlapping_cu_ranges.yaml

68

--implicit-check-not only fails if the string is found and it wasn't matched by an explicit check somewhere else. Consequently, the line 44 check will mean --implicit-check-not should still work. It will only not work if there are other errors for this test case which aren't being checked for.

[clayborg]

Use "--implicit-check-not=error:" in test to ensure no other errors are found.

[clayborg]

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

416

That is great. The next patch that excludes all ranges that are not in sections with read + execute will easily weed those out and also not report errors when we find those ranges.

[jhenderson]

LGTM, with one small comment.

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

416

-1 probably should be -2 in this context, since -1 is for base address selection entries. In the Sony linker and the LLD patch, we use -2 for .debug_ranges and dead values (-1 is used elsewhere where it can be).

[MaskRay]

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

416

For .debug_ranges

• GNU ld: [1,1)
• gold and LLD before D81988: [addend0, addend1) ( addend0 is very likely 0 )
• LLD since D81988: [-2,-2)

llvm/include/llvm/DebugInfo/DWARF/DWARFAddressRange.h

struct DWARFAddressRange {
   bool intersects(const DWARFAddressRange &RHS) const {
     assert(valid() && RHS.valid());
     // Empty ranges can't intersect.
     if (LowPC == HighPC || RHS.LowPC == RHS.HighPC)
       return false;
     return LowPC < RHS.HighPC && RHS.LowPC < HighPC;
   }
 
+  /// Union two address ranges if they intersect.
+  ///
+  /// This function will union two address ranges if they intersect by
+  /// modifying this range to be the union of both ranges. If the two ranges
+  /// don't intersect this range will be left alone.
+  ///
+  /// \param RHS Another address range to combine with.
+  ///
+  /// \returns false if the ranges don't intersect, true if they do and the
+  /// ranges were combined.
+  bool merge(const DWARFAddressRange &RHS) {
+    if (!intersects(RHS))
+      return false;
+    LowPC = std::min<uint64_t>(LowPC, RHS.LowPC);
+    HighPC = std::max<uint64_t>(HighPC, RHS.HighPC);
+    return true;
+  }
+
   void dump(raw_ostream &OS, uint32_t AddressSize, DIDumpOptions DumpOpts = {},
             const DWARFObject *Obj = nullptr) const;
 };
 
 inline bool operator<(const DWARFAddressRange &LHS,
                       const DWARFAddressRange &RHS) {
   return std::tie(LHS.LowPC, LHS.HighPC) < std::tie(RHS.LowPC, RHS.HighPC);
 }

llvm/include/llvm/DebugInfo/DWARF/DWARFVerifier.h

 //===- DWARFVerifier.h ----------------------------------------------------===//
 //
 // 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_DWARF_DWARFVERIFIER_H
 #define LLVM_DEBUGINFO_DWARF_DWARFVERIFIER_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
 #include "llvm/DebugInfo/DWARF/DWARFAddressRange.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
 
 #include <cstdint>
 #include <map>
struct DieRangeInfo {
     DieRangeInfo(std::vector<DWARFAddressRange> Ranges)
         : Ranges(std::move(Ranges)) {}
 
     typedef std::vector<DWARFAddressRange>::const_iterator
         address_range_iterator;
     typedef std::set<DieRangeInfo>::const_iterator die_range_info_iterator;
 
     /// Inserts the address range. If the range overlaps with an existing
-    /// range, the range is *not* added and an iterator to the overlapping
-    /// range is returned.
+    /// range, the range that it overlaps with will be returned and the two
+    /// address ranges will be unioned together in "Ranges".
     ///
-    /// This is used for finding overlapping ranges within the same DIE.
-    address_range_iterator insert(const DWARFAddressRange &R);
+    /// This is used for finding overlapping ranges in the DW_AT_ranges
+    /// attribute of a DIE. It is also used as a set of address ranges that
+    /// children address ranges must all be contained in.
+    Optional<DWARFAddressRange> insert(const DWARFAddressRange &R);
 
     /// Finds an address range in the sorted vector of ranges.
     address_range_iterator findRange(const DWARFAddressRange &R) const {
       auto Begin = Ranges.begin();
       auto End = Ranges.end();
       auto Iter = std::upper_bound(Begin, End, R);
       if (Iter != Begin)
         --Iter;

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

 #include <map>
 #include <set>
 #include <vector>
 
 using namespace llvm;
 using namespace dwarf;
 using namespace object;
 
-DWARFVerifier::DieRangeInfo::address_range_iterator
+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) {
-    if (Pos->intersects(R))
-      return std::move(Pos);
-    if (Pos != Begin) {
-      auto Iter = Pos - 1;
-      if (Iter->intersects(R))
-        return std::move(Iter);
-    }
+    DWARFAddressRange Range(*Pos);
+    if (Pos->merge(R))
+      return Range;
+  }
+    DWARFAddressRange Range(*Iter);
+    if (Iter->merge(R))
+      return Range;
   }
 
   Ranges.insert(Pos, R);
-  return Ranges.end();
+  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))
unsigned DWARFVerifier::verifyDieRanges(const DWARFDie &Die,
   // 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.
-      const auto IntersectingRange = RI.insert(Range);
-      if (IntersectingRange != RI.Ranges.end()) {
-        ++NumErrors;
-        error() << "DIE has overlapping address ranges: " << Range << " and "
-                << *IntersectingRange << "\n";
-        break;
+      // 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);

llvm/test/tools/llvm-dwarfdump/X86/verify_overlapping_cu_ranges.yaml

+# This test verifies that if a DW_TAG_compile_unit has DW_AT_ranges that
+# overlap, that it doesn't end up producing invalid errors claiming a child
+# DW_TAG_subprogram DIE is not in the parant (CU) ranges. Prior to the commit
+# that fixed this, a loop was iterating over all DW_AT_ranges for a DIE and
+# stopping the loop if any intersecting ranges were found. This would cause
+# the DW_TAG_subprogram DIEs, like "stripped2" and "main", to improperly report
+# that they were not contained in the parent's address ranges
+#
+# The DWARF looks like:
+# 0x0000000b: DW_TAG_compile_unit
+#               DW_AT_name  ("/tmp/main.c")
+#               DW_AT_language  (DW_LANG_C)
+#               DW_AT_low_pc  (0x0000000000000000)
+#               DW_AT_ranges  (0x00000000
+#                  [0x0000000000002000, 0x0000000000003000)
+#                  [0x0000000000000000, 0x0000000000000020)
+#                  [0x0000000000000000, 0x0000000000000030)
+#                  [0x0000000000001000, 0x0000000000002000))
+#
+# 0x0000001e:   DW_TAG_subprogram
+#                 DW_AT_name  ("stripped1")
+#                 DW_AT_low_pc  (0x0000000000000000)
+#                 DW_AT_high_pc (0x0000000000000020)
+#
+# 0x0000002f:   DW_TAG_subprogram
+#                 DW_AT_name  ("stripped2")
+#                 DW_AT_low_pc  (0x0000000000000000)
+#                 DW_AT_high_pc (0x0000000000000030)
+#
+# 0x00000044:   DW_TAG_subprogram
+#                 DW_AT_name  ("main")
+#                 DW_AT_low_pc  (0x0000000000001000)
+#                 DW_AT_high_pc (0x0000000000002000)
+#
+# 0x00000055:   DW_TAG_subprogram
+#                 DW_AT_name  ("foo")
+#                 DW_AT_low_pc  (0x0000000000002000)
+#                 DW_AT_high_pc (0x0000000000003000)
+#
+# 0x00000066:   NULL
+
+# RUN: yaml2obj %s | not llvm-dwarfdump --verify - | FileCheck %s --implicit-check-not=error:
+
+# CHECK: error: DIE has overlapping ranges in DW_AT_ranges attribute: [0x0000000000000000, 0x0000000000000020) and [0x0000000000000000, 0x0000000000000030)
+
+# CHECK: 0x0000000b:   DW_TAG_compile_unit
+# CHECK-NEXT:                DW_AT_name      ("/tmp/main.c")
+# CHECK-NEXT:                DW_AT_language  (DW_LANG_C)
+# CHECK-NEXT:                DW_AT_low_pc    (0x0000000000000000)
+# CHECK-NEXT:                DW_AT_ranges    (0x00000000
+# CHECK-NEXT:                   [0x0000000000002000, 0x0000000000003000)
+# CHECK-NEXT:                   [0x0000000000000000, 0x0000000000000020)
+# CHECK-NEXT:                   [0x0000000000000000, 0x0000000000000030)
+# CHECK-NEXT:                   [0x0000000000001000, 0x0000000000002000))
+
+# CHECK: error: DIEs have overlapping address ranges:
+# CHECK: 0x0000002f: DW_TAG_subprogram
+# CHECK-NEXT:              DW_AT_name        ("stripped2")
+# CHECK-NEXT:              DW_AT_low_pc      (0x0000000000000000)
+# CHECK-NEXT:              DW_AT_high_pc     (0x0000000000000030)
+
+# CHECK: 0x0000001e: DW_TAG_subprogram
+# CHECK-NEXT:              DW_AT_name        ("stripped1")
+# CHECK-NEXT:              DW_AT_low_pc      (0x0000000000000000)
+# CHECK-NEXT:              DW_AT_high_pc     (0x0000000000000020)
+
+# CHECK: Verifying .debug_info references...
+
+--- !mach-o
+FileHeader:
+  magic:           0xFEEDFACF
+  cputype:         0x01000007
+  cpusubtype:      0x00000003
+  filetype:        0x00000001
+  ncmds:           4
+  sizeofcmds:      464
+  flags:           0x00002000
+  reserved:        0x00000000
+LoadCommands:
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         392
+    segname:         ''
+    vmaddr:          0
+    vmsize:          261
+    fileoff:         528
+    filesize:        261
+    maxprot:         7
+    initprot:        7
+    nsects:          4
+    flags:           0
+    Sections:
+      - sectname:        __debug_abbrev
+        segname:         __DWARF
+        addr:            0x0000000000000000
+        size:            36
+        offset:          0x00000210
+        align:           0
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x00000000
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+        content:         011101030E1305110155170000022E00030E110112060000032E00030E11011201000000
+      - sectname:        __debug_info
+        segname:         __DWARF
+        addr:            0x0000000000000024
+        size:            103
+        offset:          0x00000234
+        align:           0
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x00000000
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+        content:         630000000400000000000801010000000200000000000000000000000000020D0000000000000000000000200000000317000000000000000000000030000000000000000221000000001000000000000000100000022600000000200000000000000010000000
+      - sectname:        __debug_ranges
+        segname:         __DWARF
+        addr:            0x000000000000008B
+        size:            80
+        offset:          0x0000029B
+        align:           0
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x00000000
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+        content:         '0020000000000000003000000000000000000000000000002000000000000000000000000000000030000000000000000010000000000000002000000000000000000000000000000000000000000000'
+      - sectname:        __debug_str
+        segname:         __DWARF
+        addr:            0x00000000000000DB
+        size:            42
+        offset:          0x000002EB
+        align:           0
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x00000000
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+        content:         002F746D702F6D61696E2E630073747269707065643100737472697070656432006D61696E00666F6F00
+  - cmd:             LC_SYMTAB
+    cmdsize:         24
+    symoff:          0
+    nsyms:           0
+    stroff:          792
+    strsize:         8
+  - cmd:             LC_BUILD_VERSION
+    cmdsize:         32
+    platform:        1
+    minos:           658944
+    sdk:             658944
+    ntools:          1
+    Tools:
+      - tool:            3
+        version:         34734080
+  - cmd:             LC_DATA_IN_CODE
+    cmdsize:         16
+    dataoff:         792
+    datasize:        0
+LinkEditData:
+  StringTable:
+    - ' '
+    - ''
+    - ''
+    - ''
+    - ''
+    - ''
+    - ''
+DWARF:
+  debug_str:
+    - ''
+    - '/tmp/main.c'
+    - stripped1
+    - stripped2
+    - main
+    - foo
+  debug_abbrev:
+    - Code:            0x00000001
+      Tag:             DW_TAG_compile_unit
+      Children:        DW_CHILDREN_yes
+      Attributes:
+        - Attribute:       DW_AT_name
+          Form:            DW_FORM_strp
+        - Attribute:       DW_AT_language
+          Form:            DW_FORM_data2
+        - Attribute:       DW_AT_low_pc
+          Form:            DW_FORM_addr
+        - Attribute:       DW_AT_ranges
+          Form:            DW_FORM_sec_offset
+    - Code:            0x00000002
+      Tag:             DW_TAG_subprogram
+      Children:        DW_CHILDREN_no
+      Attributes:
+        - Attribute:       DW_AT_name
+          Form:            DW_FORM_strp
+        - Attribute:       DW_AT_low_pc
+          Form:            DW_FORM_addr
+        - Attribute:       DW_AT_high_pc
+          Form:            DW_FORM_data4
+    - Code:            0x00000003
+      Tag:             DW_TAG_subprogram
+      Children:        DW_CHILDREN_no
+      Attributes:
+        - Attribute:       DW_AT_name
+          Form:            DW_FORM_strp
+        - Attribute:       DW_AT_low_pc
+          Form:            DW_FORM_addr
+        - Attribute:       DW_AT_high_pc
+          Form:            DW_FORM_addr
+  debug_ranges:
+    - Offset:          0x00000000
+      AddrSize:        0x08
+      Entries:
+        - LowOffset:       0x0000000000002000
+          HighOffset:      0x0000000000003000
+        - LowOffset:       0x0000000000000000
+          HighOffset:      0x0000000000000020
+        - LowOffset:       0x0000000000000000
+          HighOffset:      0x0000000000000030
+        - LowOffset:       0x0000000000001000
+          HighOffset:      0x0000000000002000
+  debug_info:
+    - Length:
+        TotalLength:     99
+      Version:         4
+      AbbrOffset:      0
+      AddrSize:        8
+      Entries:
+        - AbbrCode:        0x00000001
+          Values:
+            - Value:           0x0000000000000001
+            - Value:           0x0000000000000002
+            - Value:           0x0000000000000000
+            - Value:           0x0000000000000000
+        - AbbrCode:        0x00000002
+          Values:
+            - Value:           0x000000000000000D
+            - Value:           0x0000000000000000
+            - Value:           0x0000000000000020
+        - AbbrCode:        0x00000003
+          Values:
+            - Value:           0x0000000000000017
+            - Value:           0x0000000000000000
+            - Value:           0x0000000000000030
+        - AbbrCode:        0x00000002
+          Values:
+            - Value:           0x0000000000000021
+            - Value:           0x0000000000001000
+            - Value:           0x0000000000001000
+        - AbbrCode:        0x00000002
+          Values:
+            - Value:           0x0000000000000026
+            - Value:           0x0000000000002000
+            - Value:           0x0000000000001000
+        - AbbrCode:        0x00000000
+          Values:          []
+...