Add .debug_ranges support to the DWARF YAML.

[clayborg]

Summary

This allows DIEs with DW_AT_ranges to be encoded and decoded _and_ actually have their address ranges be included instead of having DW_AT_ranges with a section offset value for a section that doesn't exist.

[labath]

I don't think I am a good person to review this, as so far, I haven't found the current dwarfyaml representation to be particularly useful. I've left some comments inline.

llvm/include/llvm/ObjectYAML/DWARFYAML.h

75–76

The comments aren't really correct, because the range lists can also contain base address selection entries (low = 0xffff, high = base), and subsequent entries are then relative to that.

llvm/lib/ObjectYAML/DWARFEmitter.cpp

121

What if Ranges.Offset is strictly less than CurrOffset? Should that assert or something?

llvm/lib/ObjectYAML/DWARFYAML.cpp

88

DWARF4 spec calls these "entries". You probably copied these from the "descriptors" for aranges, but it looks like there is already a precedent for the term "Entries" in the "Pubsection" code a couple of lines lower.

llvm/test/tools/obj2yaml/macho-DWARF-debug-ranges.yaml

7–32

As you have spelled this out anyway, maybe you could just make this into an actual check (by running llvm-dwarfdump on the intermediate object file).

255–295

It doesn't look like the line section is needed to test this functionality.

[jhenderson]

I've not taken a look at this yet, but it's worth noting that we've got a GSOC proposal this year by @Higuoxing, which, if it gets accepted will aim to write a lot more of this sort of thing.

[clayborg]

llvm/test/tools/obj2yaml/macho-DWARF-debug-ranges.yaml

32

You mean check in an object file instead of using yaml?

[clayborg]

Updated things labath commented on by renaming Descriptors to Entries.

[jhenderson]

Does this patch add support in yaml2obj for debug_ranges (I get a bit lost as to what point this happens)? If it is newly supported, it should be tested in a yaml2obj test too.

llvm/test/tools/obj2yaml/macho-DWARF-debug-ranges.yaml

2

Something I'm trying to encourage where possible is to use '##' for comments in lit tests, as it makes the comments stand out from the functional parts of the test (lit and FileCheck run lines). You'll see that practice in many newer tests for obj2yaml/yaml2obj etc.

14

It might be a good idea to add a test case for a base selection entry, with the first "address" being 0xffffffffffffffff, and then confirm that obj2yaml/yaml2obj can handle it and subsequent entries (or emit a sensible error if not).

54

Nit: unnecessary blank line.

llvm/tools/obj2yaml/dwarf2yaml.cpp

87

Nit: delete blank line.

88–89

Rather than this assumption, maybe it would be better to emit an error in this patch, if the sizes differ.

107

clang-format is complaining in a few places in this file. Please fix before committing.

[labath]

llvm/test/tools/obj2yaml/macho-DWARF-debug-ranges.yaml

32

What I meant was something like:

RUN: yaml2obj %s > %t
RUN: llvm-dwarfdump %t | FileCheck --check-prefix=DWARF
RUN: obj2yaml %t | FileCheck --check-prefix=YAML

DWARF: check dwarfdump output

YAML: check yaml output

[aprantl]

llvm/include/llvm/ObjectYAML/DWARFYAML.h

79

Doxygen comment that says which entries/section this corresponds?

[clayborg]

In D78782#2004682, @jhenderson wrote:

Does this patch add support in yaml2obj for debug_ranges (I get a bit lost as to what point this happens)? If it is newly supported, it should be tested in a yaml2obj test too.

Already take care of with the test I added:

# RUN: yaml2obj %s | obj2yaml | FileCheck %s

I was looking around to see how the existing DWARF yaml code was tested and didn't find any great examples that split things up this way.

llvm/test/tools/obj2yaml/macho-DWARF-debug-ranges.yaml

2

will do

14

good idea

33

Gotcha, I can do that

[jhenderson]

In D78782#2006883, @clayborg wrote:

In D78782#2004682, @jhenderson wrote:

Does this patch add support in yaml2obj for debug_ranges (I get a bit lost as to what point this happens)? If it is newly supported, it should be tested in a yaml2obj test too.

Already take care of with the test I added:

# RUN: yaml2obj %s | obj2yaml | FileCheck %s

I was looking around to see how the existing DWARF yaml code was tested and didn't find any great examples that split things up this way.

That's not exactly testing what I'd expect. The obj2yaml output emits an Entries tag with a series of Offsets, but the input to yaml2obj in the test just uses raw content. I'd expect to see a yaml2obj input that consumes an Entries array, effectively showing that what obj2yaml emits can be consumed by yaml2obj.

[clayborg]

• Updated yaml test case to encoded DW_AT_ranges with a base address entry to verify this works
• Change test case to save yaml to a tmp object file and then run llvm-dwarfdump and obj2yaml on it
• fixed all other issues mentioned in comments

[clayborg]

Everything should be updated as requested. Let me know if there is anything else needed

[clayborg]

Removed whitespace that caused clang format violation.

[clayborg]

Remove whitespace.

[Higuoxing]

Hi, I am not qualified to review, I leave some comments below :)

llvm/test/tools/obj2yaml/macho-DWARF-debug-ranges.yaml

97

Since the content of __debug_abbrev is provided by debug_abbrev in DWARF entry below. I think the content field can be removed?

110

Ditto.

123

Ditto.

159–164

Are these empty strings used as placeholders? If not, I think they can be removed?

[Higuoxing]

llvm/test/tools/obj2yaml/macho-DWARF-debug-ranges.yaml

136

__debug_str's content can also be placed in DWARF entry below, which is easier to read and write.

DWARF:
  debug_str:
    - ''
    - /tmp/main.c
    - stripped
    - stripped2
    - main

[clayborg]

llvm/test/tools/obj2yaml/macho-DWARF-debug-ranges.yaml

97

This is how obj2yaml converted my original mach-o file so I can't remove it.

110

This is how obj2yaml converted my original mach-o file so I can't remove it.

123

This is how obj2yaml converted my original mach-o file so I can't remove it.

136

This is how obj2yaml converted my original mach-o file so I can't remove it.

[jhenderson]

llvm/include/llvm/ObjectYAML/DWARFYAML.h

75

Nit: missing full stop.

llvm/test/tools/obj2yaml/macho-DWARF-debug-ranges.yaml

136

It sounds like obj2yaml for Mach-O (and COFF for that matter) is in dire need of cleaning up, so that it is more useful for minimal inputs.

For example, as @Higuoxing's and my own confusion have pointed out, it doesn't seem right that there is both section content and DWARF data describing the same thing. Which is the source of truth after all?

Not an issue for this patch of course.

llvm/tools/obj2yaml/dwarf2yaml.cpp

95–96

Test case?

110

The linter is still complaining about clang-format on this line.

[Higuoxing]

llvm/test/tools/obj2yaml/macho-DWARF-debug-ranges.yaml

97

Oh, got it, thank you.
I don't know if it's applied here, some MachO-DWARF related tests are placed in llvm/test/ObjectYAML/MachO

[clayborg]

Fixed inline comments and a clang format issue.

llvm/test/tools/obj2yaml/macho-DWARF-debug-ranges.yaml

164

Seems like another bug in the existing mach-o YAML stuff out of the scope of this patch. Don't want to remove in case it causes problems with the current existing code as this was created by the current obj2yaml.

llvm/tools/obj2yaml/dwarf2yaml.cpp

95–96

I tried to make a test case and ran into multiple issues:

• I modified my DWARF generator to emit two different compile units with different address sizes but obj2yaml won't load the DWARF as the DWARF parser asserts when it tries to make the YAML by loading the DWARF
• if I hand edit the YAML, section sizes change and all of the data is off since and there are the existing yaml2obj ignores a different AddrSize

This really never happens in reality. I had this as an assert before, but you requested the error. Since the DWARF parsing code already asserts on this issue, I would be fine if we did too here?

110

I kept seeing this in reverse thinking it didn't want the space... After looking around it seems that a space _is_ supposed to be added.

[jhenderson]

LGTM, with one small request.

llvm/tools/obj2yaml/dwarf2yaml.cpp

95–96

Sounds to me like the DWARF parser asserting is a bug in the code, but that's outside the scope of this patch. We shouldn't ever be able to hit asserts, however broken the input is. Could you add a TODO noting that this error is untested due to the parser asserting when it happens?

[dblaikie]

llvm/tools/obj2yaml/dwarf2yaml.cpp

95–96

if I hand edit the YAML, section sizes change and all of the data is off since and there are the existing yaml2obj ignores a different AddrSize

I didn't quite follow this - could you explain that in more detail/other words? Specifically, yes, it would be difficult/annoying to hand-craft such an input, but what were the particular problems you hit when attempting to do so?

[clayborg]

if I hand edit the YAML, section sizes change and all of the data is off since and there are the existing yaml2obj ignores a different AddrSize

I didn't quite follow this - could you explain that in more detail/other words? Specifically, yes, it would be difficult/annoying to hand-craft such an input, but what were the particular problems you hit when attempting to do so?

I meant if I take an example file with 2 DWARF compile units and then manually try to edit the YAML to set the compile unit addr size to 8 on one of them (where they were both 4 to begin with, then the section sizes end up being wrong and other errors can occur when trying to obj2yaml the modified YAML. Very common stuff where the YAML can't be heavily modified or changed without things failing.

[mtrofin]

llvm/include/llvm/ObjectYAML/DWARFYAML.h

162

This seems to cause bot failure:

http://lab.llvm.org:8011/builders/llvm-clang-x86_64-expensive-checks-ubuntu/builds/5553/steps/build-unified-tree/logs/stdio

FAILED: lib/ObjectYAML/CMakeFiles/LLVMObjectYAML.dir/DWARFEmitter.cpp.o 
/usr/bin/c++  -DEXPENSIVE_CHECKS -DGTEST_HAS_RTTI=0 -D_DEBUG -D_GLIBCXX_ASSERTIONS -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Ilib/ObjectYAML -I/home/buildbot/as-builder-4/llvm-clang-x86_64-expensive-checks-ubuntu/llvm-project/llvm/lib/ObjectYAML -Iinclude -I/home/buildbot/as-builder-4/llvm-clang-x86_64-expensive-checks-ubuntu/llvm-project/llvm/include -U_GLIBCXX_DEBUG -fPIC -fvisibility-inlines-hidden -Werror=date-time -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wno-maybe-uninitialized -Wno-noexcept-type -Wdelete-non-virtual-dtor -Wno-comment -fdiagnostics-color -g    -fno-exceptions -fno-rtti -std=c++14 -MD -MT lib/ObjectYAML/CMakeFiles/LLVMObjectYAML.dir/DWARFEmitter.cpp.o -MF lib/ObjectYAML/CMakeFiles/LLVMObjectYAML.dir/DWARFEmitter.cpp.o.d -o lib/ObjectYAML/CMakeFiles/LLVMObjectYAML.dir/DWARFEmitter.cpp.o -c /home/buildbot/as-builder-4/llvm-clang-x86_64-expensive-checks-ubuntu/llvm-project/llvm/lib/ObjectYAML/DWARFEmitter.cpp
In file included from /home/buildbot/as-builder-4/llvm-clang-x86_64-expensive-checks-ubuntu/llvm-project/llvm/lib/ObjectYAML/DWARFEmitter.cpp:18:0:
/home/buildbot/as-builder-4/llvm-clang-x86_64-expensive-checks-ubuntu/llvm-project/llvm/include/llvm/ObjectYAML/DWARFYAML.h:162:23: error: declaration of ‘std::vector<llvm::DWARFYAML::Ranges> llvm::DWARFYAML::Data::Ranges’ [-fpermissive]
   std::vector<Ranges> Ranges;
                       ^~~~~~
/home/buildbot/as-builder-4/llvm-clang-x86_64-expensive-checks-ubuntu/llvm-project/llvm/include/llvm/ObjectYAML/DWARFYAML.h:82:8: error: changes meaning of ‘Ranges’ from ‘struct llvm::DWARFYAML::Ranges’ [-fpermissive]
 struct Ranges {

[clayborg]

Fixed buildbots with:

commit 6e73f12a641bb8fd965d28937ea3a6d1dcecc8c0 (HEAD -> master, origin/master, origin/HEAD)
Author: Greg Clayton <[e-mail]>
Date: Wed May 13 22:01:57 2020 -0700

Fix buildbots errors after comitting D78782.

Rename "Ranges" variables to "DebugRanges" to avoid warnings/errors on machines that have extra settings enabled.

https://reviews.llvm.org/D78782

llvm/include/llvm/ObjectYAML/DWARFEmitter.h

 
 struct Data;
 struct PubSection;
 
 void EmitDebugAbbrev(raw_ostream &OS, const Data &DI);
 void EmitDebugStr(raw_ostream &OS, const Data &DI);
 
 void EmitDebugAranges(raw_ostream &OS, const Data &DI);
+void EmitDebugRanges(raw_ostream &OS, const Data &DI);
 void EmitPubSection(raw_ostream &OS, const PubSection &Sect,
                     bool IsLittleEndian);
 void EmitDebugInfo(raw_ostream &OS, const Data &DI);
 void EmitDebugLine(raw_ostream &OS, const Data &DI);
 
 Expected<StringMap<std::unique_ptr<MemoryBuffer>>>
 EmitDebugSections(StringRef YAMLString, bool ApplyFixups = false,
                   bool IsLittleEndian = sys::IsLittleEndianHost);
 StringMap<std::unique_ptr<MemoryBuffer>>
 EmitDebugSections(llvm::DWARFYAML::Data &DI, bool ApplyFixups);
 
 } // end namespace DWARFYAML
 } // end namespace llvm
 
 #endif // LLVM_OBJECTYAML_DWARFEMITTER_H

llvm/include/llvm/ObjectYAML/DWARFYAML.h

struct ARange {
   InitialLength Length;
   uint16_t Version;
   uint32_t CuOffset;
   uint8_t AddrSize;
   uint8_t SegSize;
   std::vector<ARangeDescriptor> Descriptors;
 };
 
+/// Class that describes a range list entry, or a base address selection entry
+/// within a range list in the .debug_ranges section.
+struct RangeEntry {
+  llvm::yaml::Hex64 LowOffset;
+  llvm::yaml::Hex64 HighOffset;
+};
+
+/// Class that describes a single range list inside the .debug_ranges section.
+struct Ranges {
+  llvm::yaml::Hex32 Offset;
+  llvm::yaml::Hex8 AddrSize;
+  std::vector<RangeEntry> Entries;
+};
+
 struct PubEntry {
   llvm::yaml::Hex32 DieOffset;
   llvm::yaml::Hex8 Descriptor;
   StringRef Name;
 };
 
 struct PubSection {
   InitialLength Length;
struct LineTable {
   std::vector<LineTableOpcode> Opcodes;
 };
 
 struct Data {
   bool IsLittleEndian;
   std::vector<Abbrev> AbbrevDecls;
   std::vector<StringRef> DebugStrings;
   std::vector<ARange> ARanges;
+  std::vector<Ranges> Ranges;
   PubSection PubNames;
   PubSection PubTypes;
 
   PubSection GNUPubNames;
   PubSection GNUPubTypes;
 
   std::vector<Unit> CompileUnits;
 
   std::vector<LineTable> DebugLines;
 
   bool isEmpty() const;
 };
 
 } // end namespace DWARFYAML
 } // end namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AttributeAbbrev)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Abbrev)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARangeDescriptor)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARange)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::RangeEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Ranges)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::PubEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Unit)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::FormValue)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Entry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::File)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTable)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTableOpcode)
 

 template <> struct MappingTraits<DWARFYAML::ARangeDescriptor> {
   static void mapping(IO &IO, DWARFYAML::ARangeDescriptor &Descriptor);
 };
 
 template <> struct MappingTraits<DWARFYAML::ARange> {
   static void mapping(IO &IO, DWARFYAML::ARange &Range);
 };
 
+template <> struct MappingTraits<DWARFYAML::RangeEntry> {
+  static void mapping(IO &IO, DWARFYAML::RangeEntry &Entry);
+};
+
+template <> struct MappingTraits<DWARFYAML::Ranges> {
+  static void mapping(IO &IO, DWARFYAML::Ranges &Ranges);
+};
+
 template <> struct MappingTraits<DWARFYAML::PubEntry> {
   static void mapping(IO &IO, DWARFYAML::PubEntry &Entry);
 };
 
 template <> struct MappingTraits<DWARFYAML::PubSection> {
   static void mapping(IO &IO, DWARFYAML::PubSection &Section);
 };
 

llvm/lib/ObjectYAML/DWARFEmitter.cpp

for (auto Descriptor : Range.Descriptors) {
                                 DI.IsLittleEndian);
       writeVariableSizedInteger(Descriptor.Length, Range.AddrSize, OS,
                                 DI.IsLittleEndian);
     }
     ZeroFillBytes(OS, Range.AddrSize * 2);
   }
 }
 
+void DWARFYAML::EmitDebugRanges(raw_ostream &OS, const DWARFYAML::Data &DI) {
+  const size_t RangesOffset = OS.tell();
+  for (auto Ranges : DI.Ranges) {
+    const size_t CurrOffset = OS.tell() - RangesOffset;
+    assert(Ranges.Offset <= CurrOffset);
+    if (Ranges.Offset > CurrOffset)
+      ZeroFillBytes(OS, Ranges.Offset - CurrOffset);
+    for (auto Entry : Ranges.Entries) {
+      writeVariableSizedInteger(Entry.LowOffset, Ranges.AddrSize, OS,
+                                DI.IsLittleEndian);
+      writeVariableSizedInteger(Entry.HighOffset, Ranges.AddrSize, OS,
+                                DI.IsLittleEndian);
+    }
+    ZeroFillBytes(OS, Ranges.AddrSize * 2);
+  }
+}
+
 void DWARFYAML::EmitPubSection(raw_ostream &OS,
                                const DWARFYAML::PubSection &Sect,
                                bool IsLittleEndian) {
   writeInitialLength(Sect.Length, OS, IsLittleEndian);
   writeInteger((uint16_t)Sect.Version, OS, IsLittleEndian);
   writeInteger((uint32_t)Sect.UnitOffset, OS, IsLittleEndian);
   writeInteger((uint32_t)Sect.UnitSize, OS, IsLittleEndian);
   for (auto Entry : Sect.Entries) {
DWARFYAML::EmitDebugSections(StringRef YAMLString, bool ApplyFixups,
   EmitDebugSectionImpl(DI, &DWARFYAML::EmitDebugLine, "debug_line",
                        DebugSections);
   EmitDebugSectionImpl(DI, &DWARFYAML::EmitDebugStr, "debug_str",
                        DebugSections);
   EmitDebugSectionImpl(DI, &DWARFYAML::EmitDebugAbbrev, "debug_abbrev",
                        DebugSections);
   EmitDebugSectionImpl(DI, &DWARFYAML::EmitDebugAranges, "debug_aranges",
                        DebugSections);
+  EmitDebugSectionImpl(DI, &DWARFYAML::EmitDebugRanges, "debug_ranges",
+                       DebugSections);
   return std::move(DebugSections);
 }

llvm/lib/ObjectYAML/DWARFYAML.cpp

 
 void MappingTraits<DWARFYAML::Data>::mapping(IO &IO, DWARFYAML::Data &DWARF) {
   auto oldContext = IO.getContext();
   IO.setContext(&DWARF);
   IO.mapOptional("debug_str", DWARF.DebugStrings);
   IO.mapOptional("debug_abbrev", DWARF.AbbrevDecls);
   if (!DWARF.ARanges.empty() || !IO.outputting())
     IO.mapOptional("debug_aranges", DWARF.ARanges);
+  if (!DWARF.Ranges.empty() || !IO.outputting())
+    IO.mapOptional("debug_ranges", DWARF.Ranges);
   if (!DWARF.PubNames.Entries.empty() || !IO.outputting())
     IO.mapOptional("debug_pubnames", DWARF.PubNames);
   if (!DWARF.PubTypes.Entries.empty() || !IO.outputting())
     IO.mapOptional("debug_pubtypes", DWARF.PubTypes);
   if (!DWARF.GNUPubNames.Entries.empty() || !IO.outputting())
     IO.mapOptional("debug_gnu_pubnames", DWARF.GNUPubNames);
   if (!DWARF.GNUPubTypes.Entries.empty() || !IO.outputting())
     IO.mapOptional("debug_gnu_pubtypes", DWARF.GNUPubTypes);
void MappingTraits<DWARFYAML::ARange>::mapping(IO &IO,
   IO.mapRequired("Length", Range.Length);
   IO.mapRequired("Version", Range.Version);
   IO.mapRequired("CuOffset", Range.CuOffset);
   IO.mapRequired("AddrSize", Range.AddrSize);
   IO.mapRequired("SegSize", Range.SegSize);
   IO.mapRequired("Descriptors", Range.Descriptors);
 }
 
+void MappingTraits<DWARFYAML::RangeEntry>::mapping(
+    IO &IO, DWARFYAML::RangeEntry &Descriptor) {
+  IO.mapRequired("LowOffset", Descriptor.LowOffset);
+  IO.mapRequired("HighOffset", Descriptor.HighOffset);
+}
+
+void MappingTraits<DWARFYAML::Ranges>::mapping(IO &IO,
+                                               DWARFYAML::Ranges &Ranges) {
+  IO.mapRequired("Offset", Ranges.Offset);
+  IO.mapRequired("AddrSize", Ranges.AddrSize);
+  IO.mapRequired("Entries", Ranges.Entries);
+}
+
 void MappingTraits<DWARFYAML::PubEntry>::mapping(IO &IO,
                                                  DWARFYAML::PubEntry &Entry) {
   IO.mapRequired("DieOffset", Entry.DieOffset);
   if (reinterpret_cast<DWARFYAML::PubSection *>(IO.getContext())->IsGNUStyle)
     IO.mapRequired("Descriptor", Entry.Descriptor);
   IO.mapRequired("Name", Entry.Name);
 }
 

llvm/lib/ObjectYAML/MachOEmitter.cpp

case MachO::LC_SEGMENT_64:
                "Wrote too much data somewhere, section offsets don't line up.");
         if (0 == strncmp(&Sec.segname[0], "__DWARF", 16)) {
           if (0 == strncmp(&Sec.sectname[0], "__debug_str", 16)) {
             DWARFYAML::EmitDebugStr(OS, Obj.DWARF);
           } else if (0 == strncmp(&Sec.sectname[0], "__debug_abbrev", 16)) {
             DWARFYAML::EmitDebugAbbrev(OS, Obj.DWARF);
           } else if (0 == strncmp(&Sec.sectname[0], "__debug_aranges", 16)) {
             DWARFYAML::EmitDebugAranges(OS, Obj.DWARF);
+          } else if (0 == strncmp(&Sec.sectname[0], "__debug_ranges", 16)) {
+            DWARFYAML::EmitDebugRanges(OS, Obj.DWARF);
           } else if (0 == strncmp(&Sec.sectname[0], "__debug_pubnames", 16)) {
             DWARFYAML::EmitPubSection(OS, Obj.DWARF.PubNames,
                                       Obj.IsLittleEndian);
           } else if (0 == strncmp(&Sec.sectname[0], "__debug_pubtypes", 16)) {
             DWARFYAML::EmitPubSection(OS, Obj.DWARF.PubTypes,
                                       Obj.IsLittleEndian);
           } else if (0 == strncmp(&Sec.sectname[0], "__debug_info", 16)) {
             DWARFYAML::EmitDebugInfo(OS, Obj.DWARF);

llvm/test/tools/obj2yaml/macho-DWARF-debug-ranges.yaml

+## Test that yaml2obj and obj2yaml can create mach-o files with valid
+## __debug_ranges section.
+##
+## The DWARF should end up looking like:
+##
+## 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
+
+# RUN: yaml2obj %s > %t
+# RUN: llvm-dwarfdump %t | FileCheck %s
+# RUN: obj2yaml %t | FileCheck --check-prefix=YAML %s
+
+# CHECK:      DW_AT_ranges  (0x00000000
+# CHECK-NEXT: [0x0000000000000000, 0x0000000000000020)
+# CHECK-NEXT: [0x0000000000000000, 0x0000000000000030)
+# CHECK-NEXT: [0x0000000000001000, 0x0000000000002000))
+
+# YAML:      - sectname:        __debug_ranges
+# YAML-NEXT:   segname:         __DWARF
+# YAML-NEXT:   addr:            0x000000000000007A
+# YAML-NEXT:   size:            80
+# YAML-NEXT:   offset:          0x0000028A
+
+# YAML:      debug_ranges:
+# YAML-NEXT:   - Offset:          0x00000000
+# YAML-NEXT:     AddrSize:        0x08
+# YAML-NEXT:     Entries:
+# YAML-NEXT:       - LowOffset:       0x0000000000000000
+# YAML-NEXT:         HighOffset:      0x0000000000000020
+# YAML-NEXT:       - LowOffset:       0x0000000000000000
+# YAML-NEXT:         HighOffset:      0x0000000000000030
+# YAML-NEXT:       - LowOffset:       0xFFFFFFFFFFFFFFFF
+# YAML-NEXT:         HighOffset:      0x0000000000001000
+# YAML-NEXT:       - LowOffset:       0x0000000000000000
+# YAML-NEXT:         HighOffset:      0x0000000000001000
+
+--- !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:          240
+    fileoff:         528
+    filesize:        240
+    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:            86
+        offset:          0x00000234
+        align:           0
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x00000000
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+        content:         520000000400000000000801010000000400000000000000000000000000020D000000000000000000000020000000031700000000000000000000003000000000000000022100000000100000000000000010000000
+      - sectname:        __debug_ranges
+        segname:         __DWARF
+        addr:            0x000000000000007A
+        size:            80
+        offset:          0x0000028A
+        align:           0
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x00000000
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+        content:         0000000000000000200000000000000000000000000000003000000000000000FFFFFFFFFFFFFFFF00100000000000000000000000000000001000000000000000000000000000000000000000000000
+      - sectname:        __debug_str
+        segname:         __DWARF
+        addr:            0x00000000000000CA
+        size:            38
+        offset:          0x000002DA
+        align:           0
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x00000000
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+        content:         002F746D702F6D61696E2E630073747269707065643100737472697070656432006D61696E00
+  - cmd:             LC_SYMTAB
+    cmdsize:         24
+    symoff:          0
+    nsyms:           0
+    stroff:          768
+    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:         768
+    datasize:        0
+LinkEditData:
+  StringTable:
+    - ' '
+    - ''
+    - ''
+    - ''
+    - ''
+    - ''
+    - ''
+DWARF:
+  debug_str:
+    - ''
+    - '/tmp/main.c'
+    - stripped1
+    - stripped2
+    - main
+  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:       0x0000000000000000
+          HighOffset:      0x0000000000000020
+        - LowOffset:       0x0000000000000000
+          HighOffset:      0x0000000000000030
+        - LowOffset:       0xFFFFFFFFFFFFFFFF
+          HighOffset:      0x0000000000001000
+        - LowOffset:       0x0000000000000000
+          HighOffset:      0x0000000000001000
+  debug_info:
+    - Length:
+        TotalLength:     82
+      Version:         4
+      AbbrOffset:      0
+      AddrSize:        8
+      Entries:
+        - AbbrCode:        0x00000001
+          Values:
+            - Value:           0x0000000000000001
+            - Value:           0x0000000000000004
+            - 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:        0x00000000
+          Values:          []
+...

llvm/tools/obj2yaml/dwarf2yaml.cpp

 //===------ dwarf2yaml.cpp - obj2yaml conversion tool -----------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "Error.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/ObjectYAML/DWARFYAML.h"
 
 #include <algorithm>
 
 using namespace llvm;
 
 void dumpInitialLength(DataExtractor &Data, uint64_t &Offset,
for (auto Descriptor : Set.descriptors()) {
       Desc.Length = Descriptor.Length;
       Range.Descriptors.push_back(Desc);
     }
     Y.ARanges.push_back(Range);
   }
   return ErrorSuccess();
 }
 
+Error dumpDebugRanges(DWARFContext &DCtx, DWARFYAML::Data &Y) {
+  // We are assuming all address byte sizes will be consistent across all
+  // compile units.
+  uint8_t AddrSize = 0;
+  for (const auto &CU : DCtx.compile_units()) {
+    const uint8_t CUAddrSize = CU->getAddressByteSize();
+    if (AddrSize == 0)
+      AddrSize = CUAddrSize;
+    else if (CUAddrSize != AddrSize)
+      return createStringError(std::errc::invalid_argument,
+                               "address sizes vary in different compile units");
+  }
+
+  DWARFDataExtractor Data(DCtx.getDWARFObj().getRangesSection().Data,
+                          DCtx.isLittleEndian(), AddrSize);
+  uint64_t Offset = 0;
+  DWARFDebugRangeList DwarfRanges;
+
+  while (Data.isValidOffset(Offset)) {
+    DWARFYAML::Ranges YamlRanges;
+    YamlRanges.Offset = Offset;
+    YamlRanges.AddrSize = AddrSize;
+    if (Error E = DwarfRanges.extract(Data, &Offset))
+      return E;
+    for (const auto &RLE : DwarfRanges.getEntries())
+      YamlRanges.Entries.push_back({RLE.StartAddress, RLE.EndAddress});
+    Y.Ranges.push_back(std::move(YamlRanges));
+  }
+  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);
   Y.Version = PubSectionData.getU16(&Offset);
   Y.UnitOffset = PubSectionData.getU32(&Offset);
void dumpDebugLines(DWARFContext &DCtx, DWARFYAML::Data &Y) {
   }
 }
 
 llvm::Error dwarf2yaml(DWARFContext &DCtx, DWARFYAML::Data &Y) {
   dumpDebugAbbrev(DCtx, Y);
   dumpDebugStrings(DCtx, Y);
   if (Error E = dumpDebugARanges(DCtx, Y))
     return E;
+  if (Error E = dumpDebugRanges(DCtx, Y))
+    return E;
   dumpDebugPubSections(DCtx, Y);
   dumpDebugInfo(DCtx, Y);
   dumpDebugLines(DCtx, Y);
   return ErrorSuccess();
 }