[macho2yaml] Refactor the DWARF section dumpers.

[Higuoxing]

Summary

This patch refactors the DWARF section dumpers. When dumping a DWARF
section, if the DWARF parser fails to parse the section, we will dump it
as a raw content section. This patch also fixes a bug in
DWARFYAML::Data::isEmpty(). Finally, a test case that tests dumping the
__debug_aranges section is added.

[grimar]

llvm/tools/obj2yaml/macho2yaml.cpp

29

Probably, std::unique_ptr<MachOYAML::Object> &Y -> const MachOYAML::Object &Y
would express the intention better (doesn't seem you need the ability to really access/change the std::unique_ptr<...> holder of Y).

154

Why not just something like the following?

if (SecName == "__debug_abbrev")
  return dumpDebugAbbrev(DCtx, DWARF);
if (SecName == "__debug_aranges")
  return dumpDebugARanges(DCtx, DWARF);

[Higuoxing]

Address review comments.

Thanks for reviewing!

llvm/tools/obj2yaml/macho2yaml.cpp

29

Y.DWARF is modified in dumpDebugSection(), so I change it to MachOYAML::Object &Y.

[grimar]

llvm/tools/obj2yaml/macho2yaml.cpp

153

Perhaps we need a test for an unknown debug section to test this?
E.g. a test for an arbitrary "__debug_foo" that shows that we are able to and actually emit a raw content for it.

[Higuoxing]

Add two test cases.

debug-aranges.yaml (e)
unrecognized-debug-section.yaml

[Higuoxing]

llvm/tools/obj2yaml/macho2yaml.cpp

153

The implementation of yaml2macho is buggy, we cannot specify the content of a section whose segname is __DWARF.

if (Sec.segname == "__DWARF") {
  if (Sec.sectname == "__debug_str")
    Err = emitDebugStr();
  else if (Sec.sectname == "__debug_info")
    Err = emitDebugInfo();
  ...
  else if (Sec.sectname == "__debug_line")
    Err = emitDebugLine();

  if (Err)
    return Err;
  continue;              // Emitting the custom content is unreachable.
}

if (Sec.content)
  emitContent();

So I create a section whose segname is __FOO and sectname is __debug_foo to bypass the ec.segname == "__DWARF" checking.

I also add a test case e) to test dumping a __debug_aranges section whose segname is __FOO. This is to prove that when the segname isn't __DWARF but the sectname starts with __debug_, dumpDebugSection() is still called.

[grimar]

OK, thanks. This LGTM, but please hold on a bit to give other people a chance to comment too.

[Higuoxing]

In D85506#2202295, @grimar wrote:

OK, thanks. This LGTM, but please hold on a bit to give other people a chance to comment too.

Thanks for reviewing! I will wait until other people accept this.

[jhenderson]

llvm/test/tools/obj2yaml/MachO/debug-aranges.yaml

3

79

99

llvm/test/tools/obj2yaml/MachO/unrecognized-debug-section.yaml

47

You might want to explain with a comment the unusual segment name.

[Higuoxing]

Address review comments.

[jhenderson]

LGTM.

llvm/test/tools/obj2yaml/MachO/unrecognized-debug-section.yaml

4–7

[Higuoxing]

Address review comments.

[Higuoxing]

Rebase.

llvm/lib/ObjectYAML/DWARFYAML.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/ObjectYAML/DWARFYAML.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 
 namespace llvm {
 
 bool DWARFYAML::Data::isEmpty() const {
-  return DebugStrings.empty() && AbbrevDecls.empty() && DebugAranges &&
+  return DebugStrings.empty() && AbbrevDecls.empty() && !DebugAranges &&
          DebugRanges.empty() && !PubNames && !PubTypes && !GNUPubNames &&
          !GNUPubTypes && CompileUnits.empty() && DebugLines.empty();
 }
 
 SetVector<StringRef> DWARFYAML::Data::getNonEmptySectionNames() const {
   SetVector<StringRef> SecNames;
   if (!DebugStrings.empty())
     SecNames.insert("debug_str");

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

 # EMPTY-NEXT:     offset:          0x00000000
 # EMPTY-NEXT:     align:           0
 # EMPTY-NEXT:     reloff:          0x00000000
 # EMPTY-NEXT:     nreloc:          0
 # EMPTY-NEXT:     flags:           0x00000000
 # EMPTY-NEXT:     reserved1:       0x00000000
 # EMPTY-NEXT:     reserved2:       0x00000000
 # EMPTY-NEXT:     reserved3:       0x00000000
-# EMPTY-NEXT:     content:         ''
 # EMPTY-NEXT:   - sectname:        __debug_pubtypes
 # EMPTY-NEXT:     segname:         __DWARF
 # EMPTY-NEXT:     addr:            0x0000000000000000
 # EMPTY-NEXT:     size:            0
 # EMPTY-NEXT:     offset:          0x00000720
 # EMPTY-NEXT:     align:           0
 # EMPTY-NEXT:     reloff:          0x00000000
 # EMPTY-NEXT:     nreloc:          0
 # EMPTY-NEXT:     flags:           0x00000000
 # EMPTY-NEXT:     reserved1:       0x00000000
 # EMPTY-NEXT:     reserved2:       0x00000000
 # EMPTY-NEXT:     reserved3:       0x00000000
-# EMPTY-NEXT:     content:         ''
 # EMPTY-NEXT: ...
 
 --- !mach-o
 FileHeader:
   magic:      0xFEEDFACF
   cputype:    0x01000007
   cpusubtype: 0x00000003
   filetype:   0x0000000A

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

-# RUN: yaml2obj %s | not obj2yaml 2>&1 | FileCheck %s
-
---- !mach-o
-FileHeader:      
-  magic:           0xFEEDFACF
-  cputype:         0x01000007
-  cpusubtype:      0x00000003
-  filetype:        0x0000000A
-  ncmds:           5
-  sizeofcmds:      1800
-  flags:           0x00000000
-  reserved:        0x00000000
-LoadCommands:    
-  - cmd:             LC_SEGMENT_64
-    cmdsize:         72
-    segname:         __PAGEZERO
-    vmaddr:          0
-    vmsize:          4294967296
-    fileoff:         0
-    filesize:        0
-    maxprot:         0
-    initprot:        0
-    nsects:          0
-    flags:           0
-  - cmd:             LC_SEGMENT_64
-    cmdsize:         472
-    segname:         __TEXT
-    vmaddr:          4294967296
-    vmsize:          4096
-    fileoff:         0
-    filesize:        0
-    maxprot:         7
-    initprot:        5
-    nsects:          5
-    flags:           0
-    Sections:        
-      - sectname:        __text
-        segname:         __TEXT
-        addr:            0x0000000100000F50
-        size:            52
-        offset:          0x00000000
-        align:           4
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x80000400
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-      - sectname:        __stubs
-        segname:         __TEXT
-        addr:            0x0000000100000F84
-        size:            6
-        offset:          0x00000000
-        align:           1
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x80000408
-        reserved1:       0x00000000
-        reserved2:       0x00000006
-        reserved3:       0x00000000
-      - sectname:        __stub_helper
-        segname:         __TEXT
-        addr:            0x0000000100000F8C
-        size:            26
-        offset:          0x00000000
-        align:           2
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x80000400
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-      - sectname:        __cstring
-        segname:         __TEXT
-        addr:            0x0000000100000FA6
-        size:            14
-        offset:          0x00000000
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x00000002
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-      - sectname:        __unwind_info
-        segname:         __TEXT
-        addr:            0x0000000100000FB4
-        size:            72
-        offset:          0x00000000
-        align:           2
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x00000000
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-  - cmd:             LC_SEGMENT_64
-    cmdsize:         232
-    segname:         __DATA
-    vmaddr:          4294971392
-    vmsize:          4096
-    fileoff:         0
-    filesize:        0
-    maxprot:         7
-    initprot:        3
-    nsects:          2
-    flags:           0
-    Sections:        
-      - sectname:        __nl_symbol_ptr
-        segname:         __DATA
-        addr:            0x0000000100001000
-        size:            16
-        offset:          0x00000000
-        align:           3
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x00000006
-        reserved1:       0x00000001
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-      - sectname:        __la_symbol_ptr
-        segname:         __DATA
-        addr:            0x0000000100001010
-        size:            8
-        offset:          0x00000000
-        align:           3
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x00000007
-        reserved1:       0x00000003
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-  - cmd:             LC_SEGMENT_64
-    cmdsize:         72
-    segname:         __LINKEDIT
-    vmaddr:          4294975488
-    vmsize:          4096
-    fileoff:         4096
-    filesize:        60
-    maxprot:         7
-    initprot:        1
-    nsects:          0
-    flags:           0
-  - cmd:             LC_SEGMENT_64
-    cmdsize:         952
-    segname:         __DWARF
-    vmaddr:          4294979584
-    vmsize:          4096
-    fileoff:         8192
-    filesize:        764
-    maxprot:         7
-    initprot:        3
-    nsects:          11
-    flags:           0
-    Sections:        
-      - sectname:        __debug_line
-        segname:         __DWARF
-        addr:            0x0000000100003000
-        size:            69
-        offset:          0x00002000
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x00000000
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-      - sectname:        __debug_pubnames
-        segname:         __DWARF
-        addr:            0x0000000100003045
-        size:            27
-        offset:          0x00002045
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x00000000
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-      - sectname:        __debug_pubtypes
-        segname:         __DWARF
-        addr:            0x0000000100003060
-        size:            35
-        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
-        flags:           0x00000000
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-      - sectname:        __debug_abbrev
-        segname:         __DWARF
-        addr:            0x000000010000312C
-        size:            76
-        offset:          0x0000212C
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x00000000
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-      - sectname:        __debug_str
-        segname:         __DWARF
-        addr:            0x0000000100003178
-        size:            142
-        offset:          0x00002178
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x00000000
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-      - sectname:        __apple_names
-        segname:         __DWARF
-        addr:            0x0000000100003206
-        size:            60
-        offset:          0x00002206
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x00000000
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-      - sectname:        __apple_namespac
-        segname:         __DWARF
-        addr:            0x0000000100003242
-        size:            36
-        offset:          0x00002242
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x00000000
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-      - sectname:        __apple_types
-        segname:         __DWARF
-        addr:            0x0000000100003266
-        size:            114
-        offset:          0x00002266
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x00000000
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-      - sectname:        __apple_objc
-        segname:         __DWARF
-        addr:            0x00000001000032D8
-        size:            36
-        offset:          0x000022D8
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x00000000
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-DWARF:
-  debug_aranges:
-    - Length:              45
-      Version:             2
-      CuOffset:            0
-      AddressSize:         8
-      SegmentSelectorSize: 0
-      Descriptors:
-        - Address:         0x0000000100000F50
-          Length:          52
-...
-
-#CHECK: the length of address range table at offset 0x0 exceeds section size

llvm/test/tools/obj2yaml/MachO/debug-aranges.yaml

+## a) Test that we are able to dump the __debug_aranges section.
+## The content of the __debug_aranges section should be written in
+## the "DWARF" entry and the "content" field should remain empty.
+
+# RUN: yaml2obj --docnum=1 %s | obj2yaml | FileCheck -DSEGNAME=DWARF %s --check-prefix=ARANGES
+
+#      ARANGES: Sections:
+# ARANGES-NEXT:   - sectname:        __debug_aranges
+# ARANGES-NEXT:     segname:         __[[SEGNAME]]
+# ARANGES-NEXT:     addr:            0x0000000000000000
+# ARANGES-NEXT:     size:            64
+# ARANGES-NEXT:     offset:          0x00000210
+# ARANGES-NEXT:     align:           0
+# ARANGES-NEXT:     reloff:          0x00000000
+# ARANGES-NEXT:     nreloc:          0
+# ARANGES-NEXT:     flags:           0x00000000
+# ARANGES-NEXT:     reserved1:       0x00000000
+# ARANGES-NEXT:     reserved2:       0x00000000
+# ARANGES-NEXT:     reserved3:       0x00000000
+# ARANGES-NEXT: DWARF:
+# ARANGES-NEXT:   debug_aranges:
+# ARANGES-NEXT:     - Length:          0x000000000000003C
+# ARANGES-NEXT:       Version:         2
+# ARANGES-NEXT:       CuOffset:        0x0000000000001234
+# ARANGES-NEXT:       AddressSize:     0x08
+# ARANGES-NEXT:       Descriptors:
+# ARANGES-NEXT:         - Address:         0x0000000000001234
+# ARANGES-NEXT:           Length:          0x0000000000005678
+# ARANGES-NEXT:         - Address:         0x0000000000001234
+# ARANGES-NEXT:           Length:          0x0000000000005678
+
+--- !mach-o
+FileHeader:
+  magic:      0xFEEDFACF
+  cputype:    0x01000007
+  cpusubtype: 0x00000003
+  filetype:   0x0000000A
+  ncmds:      1
+  sizeofcmds: 232
+  flags:      0x00000000
+  reserved:   0x00000000
+LoadCommands:
+  - cmd:      LC_SEGMENT_64
+    cmdsize:  152
+    segname:  __DWARF
+    vmaddr:   0x00
+    vmsize:   0x00
+    fileoff:  0x00
+    filesize: 0x00
+    maxprot:  0
+    initprot: 0
+    nsects:   1
+    flags:    0
+    Sections:
+      - sectname:  __debug_aranges
+        segname:   __DWARF
+        addr:      0x00
+        size:      64
+        offset:    528
+        align:     0
+        reloff:    0x00000000
+        nreloc:    0
+        flags:     0x00000000
+        reserved1: 0x00000000
+        reserved2: 0x00000000
+        reserved3: 0x00000000
+DWARF:
+  debug_aranges:
+    - Length:   [[LENGTH=<none>]]
+      Version:  2
+      CuOffset: 0x1234
+      Descriptors:
+        - Address: 0x1234
+          Length:  0x5678
+        - Address: 0x1234
+          Length:  0x5678
+
+## b) Test dumping a __debug_aranges section whose length field doesn't match the actual length.
+## This makes the DWARF parser fail to parse it and we will dump it as a raw content section.
+
+# RUN: yaml2obj --docnum=1 -DLENGTH=0x2 %s | obj2yaml | FileCheck %s --check-prefix=RAW-CONTENT
+
+#      RAW-CONTENT: - sectname:        __debug_aranges
+# RAW-CONTENT-NEXT:   segname:         __DWARF
+# RAW-CONTENT-NEXT:   addr:            0x0000000000000000
+# RAW-CONTENT-NEXT:   size:            64
+# RAW-CONTENT-NEXT:   offset:          0x00000210
+# RAW-CONTENT-NEXT:   align:           0
+# RAW-CONTENT-NEXT:   reloff:          0x00000000
+# RAW-CONTENT-NEXT:   nreloc:          0
+# RAW-CONTENT-NEXT:   flags:           0x00000000
+# RAW-CONTENT-NEXT:   reserved1:       0x00000000
+# RAW-CONTENT-NEXT:   reserved2:       0x00000000
+# RAW-CONTENT-NEXT:   reserved3:       0x00000000
+# RAW-CONTENT-NEXT:   content:         '02000000020034120000080000000000341200000000000078560000000000003412000000000000785600000000000000000000000000000000000000000000'
+# RAW-CONTENT-NEXT: ...
+
+## c) Test dumping a __debug_aranges section whose segname is __FOO.
+
+# RUN: yaml2obj --docnum=2 %s | obj2yaml | FileCheck %s -DSEGNAME=FOO --check-prefix=ARANGES
+
+--- !mach-o
+FileHeader:
+  magic:      0xFEEDFACF
+  cputype:    0x01000007
+  cpusubtype: 0x00000003
+  filetype:   0x0000000A
+  ncmds:      1
+  sizeofcmds: 232
+  flags:      0x00000000
+  reserved:   0x00000000
+LoadCommands:
+  - cmd:      LC_SEGMENT_64
+    cmdsize:  152
+    segname:  __DWARF
+    vmaddr:   0x00
+    vmsize:   0x00
+    fileoff:  0x00
+    filesize: 0x00
+    maxprot:  0
+    initprot: 0
+    nsects:   1
+    flags:    0
+    Sections:
+      - sectname:  __debug_aranges
+        segname:   __FOO
+        addr:      0x00
+        size:      64
+        offset:    528
+        align:     0
+        reloff:    0x00000000
+        nreloc:    0
+        flags:     0x00000000
+        reserved1: 0x00000000
+        reserved2: 0x00000000
+        reserved3: 0x00000000
+        content:   '3C000000020034120000080000000000341200000000000078560000000000003412000000000000785600000000000000000000000000000000000000000000'

llvm/test/tools/obj2yaml/MachO/unrecognized-debug-section.yaml

+## Test that macho2yaml dumps the __debug_foo section (unrecognized debug section)
+## as a raw content section.
+
+## Due to the current implementation of yaml2macho is buggy, we cannot generate a DWARF section
+## (the sectname starts with '__debug_' and the segname is '__DWARF') from a raw content section.
+## We've slightly modified the segname to be '__FOO'. macho2yaml will still treat it as a debug
+## section.
+
+# RUN: yaml2obj %s | obj2yaml | FileCheck %s --check-prefix=UNRECOGNIZED
+
+#      UNRECOGNIZED: Sections:
+# UNRECOGNIZED-NEXT:   - sectname:        __debug_foo
+# UNRECOGNIZED-NEXT:     segname:         __FOO
+# UNRECOGNIZED-NEXT:     addr:            0x0000000000000000
+# UNRECOGNIZED-NEXT:     size:            5
+# UNRECOGNIZED-NEXT:     offset:          0x00000210
+# UNRECOGNIZED-NEXT:     align:           0
+# UNRECOGNIZED-NEXT:     reloff:          0x00000000
+# UNRECOGNIZED-NEXT:     nreloc:          0
+# UNRECOGNIZED-NEXT:     flags:           0x00000000
+# UNRECOGNIZED-NEXT:     reserved1:       0x00000000
+# UNRECOGNIZED-NEXT:     reserved2:       0x00000000
+# UNRECOGNIZED-NEXT:     reserved3:       0x00000000
+# UNRECOGNIZED-NEXT:     content:         '0123456789'
+# UNRECOGNIZED-NEXT: ...
+
+--- !mach-o
+FileHeader:
+  magic:      0xFEEDFACF
+  cputype:    0x01000007
+  cpusubtype: 0x00000003
+  filetype:   0x0000000A
+  ncmds:      1
+  sizeofcmds: 232
+  flags:      0x00000000
+  reserved:   0x00000000
+LoadCommands:
+  - cmd:      LC_SEGMENT_64
+    cmdsize:  152
+    segname:  __DWARF
+    vmaddr:   0x00
+    vmsize:   0x00
+    fileoff:  0x00
+    filesize: 0x00
+    maxprot:  0
+    initprot: 0
+    nsects:   1
+    flags:    0
+    Sections:
+      - sectname:  __debug_foo
+        segname:   __FOO
+        addr:      0x00
+        size:      5
+        offset:    528
+        align:     0
+        reloff:    0x00000000
+        nreloc:    0
+        flags:     0x00000000
+        reserved1: 0x00000000
+        reserved2: 0x00000000
+        reserved3: 0x00000000
+        content:   '0123456789'

llvm/tools/obj2yaml/dwarf2yaml.cpp

if (auto StmtOffset =
         DebugLines.Opcodes.push_back(NewOp);
       }
       Y.DebugLines.push_back(DebugLines);
     }
   }
 
   return Error::success();
 }
-
-llvm::Error dwarf2yaml(DWARFContext &DCtx, DWARFYAML::Data &Y) {
-  if (Error E = dumpDebugAbbrev(DCtx, Y))
-    return E;
-  if (Error E = dumpDebugStrings(DCtx, Y))
-    return E;
-  if (Error E = dumpDebugARanges(DCtx, Y))
-    return E;
-  if (Error E = dumpDebugRanges(DCtx, Y))
-    return E;
-  if (Error E = dumpDebugPubSections(DCtx, Y))
-    return E;
-  if (Error E = dumpDebugInfo(DCtx, Y))
-    return E;
-  if (Error E = dumpDebugLines(DCtx, Y))
-    return E;
-  return ErrorSuccess();
-}

llvm/tools/obj2yaml/macho2yaml.cpp

 //===------ macho2yaml.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 "obj2yaml.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/Object/MachOUniversal.h"
+#include "llvm/ObjectYAML/DWARFYAML.h"
 #include "llvm/ObjectYAML/ObjectYAML.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
 
 #include <string.h> // for memcpy
 
 using namespace llvm;
 
 class MachODumper {
 
   template <typename StructType>
   Expected<const char *> processLoadCommandData(
       MachOYAML::LoadCommand &LC,
-      const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd);
+      const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd,
+      MachOYAML::Object &Y);
 
   const object::MachOObjectFile &Obj;
+  std::unique_ptr<DWARFContext> DWARFCtx;
   void dumpHeader(std::unique_ptr<MachOYAML::Object> &Y);
   Error dumpLoadCommands(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpLinkEdit(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpRebaseOpcodes(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpBindOpcodes(std::vector<MachOYAML::BindOpcode> &BindOpcodes,
                        ArrayRef<uint8_t> OpcodeBuffer, bool Lazy = false);
   void dumpExportTrie(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpSymbols(std::unique_ptr<MachOYAML::Object> &Y);
 
   template <typename SectionType>
   Expected<MachOYAML::Section> constructSectionCommon(SectionType Sec,
                                                       size_t SecIndex);
   template <typename SectionType>
   Expected<MachOYAML::Section> constructSection(SectionType Sec,
                                                 size_t SecIndex);
   template <typename SectionType, typename SegmentType>
   Expected<const char *>
   extractSections(const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd,
-                  std::vector<MachOYAML::Section> &Sections);
+                  std::vector<MachOYAML::Section> &Sections,
+                  MachOYAML::Object &Y);
 
 public:
-  MachODumper(const object::MachOObjectFile &O) : Obj(O) {}
+  MachODumper(const object::MachOObjectFile &O,
+              std::unique_ptr<DWARFContext> DCtx)
+      : Obj(O), DWARFCtx(std::move(DCtx)) {}
   Expected<std::unique_ptr<MachOYAML::Object>> dump();
 };
 
 #define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct)                         \
   case MachO::LCName:                                                          \
     memcpy((void *)&(LC.Data.LCStruct##_data), LoadCmd.Ptr,                    \
            sizeof(MachO::LCStruct));                                           \
     if (Obj.isLittleEndian() != sys::IsLittleEndianHost)                       \
       MachO::swapStruct(LC.Data.LCStruct##_data);                              \
     if (Expected<const char *> ExpectedEndPtr =                                \
-            processLoadCommandData<MachO::LCStruct>(LC, LoadCmd))              \
+            processLoadCommandData<MachO::LCStruct>(LC, LoadCmd, *Y.get()))    \
       EndPtr = *ExpectedEndPtr;                                                \
     else                                                                       \
       return ExpectedEndPtr.takeError();                                       \
     break;
 
 template <typename SectionType>
 Expected<MachOYAML::Section>
 MachODumper::constructSectionCommon(SectionType Sec, size_t SecIndex) {

 Expected<MachOYAML::Section>
 MachODumper::constructSection(MachO::section_64 Sec, size_t SecIndex) {
   Expected<MachOYAML::Section> TempSec = constructSectionCommon(Sec, SecIndex);
   if (TempSec)
     TempSec->reserved3 = Sec.reserved3;
   return TempSec;
 }
 
+static Error dumpDebugSection(StringRef SecName, DWARFContext &DCtx,
+                              DWARFYAML::Data &DWARF) {
+  if (SecName == "__debug_abbrev")
+    return dumpDebugAbbrev(DCtx, DWARF);
+  if (SecName == "__debug_aranges")
+    return dumpDebugARanges(DCtx, DWARF);
+  if (SecName == "__debug_info")
+    return dumpDebugInfo(DCtx, DWARF);
+  if (SecName == "__debug_line")
+    return dumpDebugLines(DCtx, DWARF);
+  if (SecName.startswith("__debug_pub"))
+    // FIXME: We should extract pub-section dumpers from this function.
+    return dumpDebugPubSections(DCtx, DWARF);
+  if (SecName == "__debug_ranges")
+    return dumpDebugRanges(DCtx, DWARF);
+  if (SecName == "__debug_str")
+    return dumpDebugStrings(DCtx, DWARF);
+  return createStringError(errc::not_supported,
+                           "dumping " + SecName + " section is not supported");
+}
+
 template <typename SectionType, typename SegmentType>
 Expected<const char *> MachODumper::extractSections(
     const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd,
-    std::vector<MachOYAML::Section> &Sections) {
+    std::vector<MachOYAML::Section> &Sections, MachOYAML::Object &Y) {
   auto End = LoadCmd.Ptr + LoadCmd.C.cmdsize;
   const SectionType *Curr =
       reinterpret_cast<const SectionType *>(LoadCmd.Ptr + sizeof(SegmentType));
   for (; reinterpret_cast<const void *>(Curr) < End; Curr++) {
     SectionType Sec;
     memcpy((void *)&Sec, Curr, sizeof(SectionType));
     if (Obj.isLittleEndian() != sys::IsLittleEndianHost)
       MachO::swapStruct(Sec);
     // For MachO section indices start from 1.
     if (Expected<MachOYAML::Section> S =
-            constructSection(Sec, Sections.size() + 1))
-      Sections.push_back(std::move(*S));
+            constructSection(Sec, Sections.size() + 1)) {
+      StringRef SecName(S->sectname);
+      DWARFYAML::Data DWARF;
+      if (SecName.startswith("__debug_")) {
+        // If the DWARF section cannot be successfully parsed, emit raw content
+        // instead of an entry in the DWARF section of the YAML.
+        if (Error Err = dumpDebugSection(SecName, *DWARFCtx.get(), Y.DWARF))
+          consumeError(std::move(Err));
         else
+          S->content.reset();
+      }
+      Sections.push_back(std::move(*S));
+    } else
       return S.takeError();
   }
   return reinterpret_cast<const char *>(Curr);
 }
 
 template <typename StructType>
 Expected<const char *> MachODumper::processLoadCommandData(
     MachOYAML::LoadCommand &LC,
-    const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
+    const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd,
+    MachOYAML::Object &Y) {
   return LoadCmd.Ptr + sizeof(StructType);
 }
 
 template <>
 Expected<const char *>
 MachODumper::processLoadCommandData<MachO::segment_command>(
     MachOYAML::LoadCommand &LC,
-    const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
-  return extractSections<MachO::section, MachO::segment_command>(LoadCmd,
-                                                                 LC.Sections);
+    const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd,
+    MachOYAML::Object &Y) {
+  return extractSections<MachO::section, MachO::segment_command>(
+      LoadCmd, LC.Sections, Y);
 }
 
 template <>
 Expected<const char *>
 MachODumper::processLoadCommandData<MachO::segment_command_64>(
     MachOYAML::LoadCommand &LC,
-    const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
+    const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd,
+    MachOYAML::Object &Y) {
   return extractSections<MachO::section_64, MachO::segment_command_64>(
-      LoadCmd, LC.Sections);
+      LoadCmd, LC.Sections, Y);
 }
 
 template <typename StructType>
 const char *
 readString(MachOYAML::LoadCommand &LC,
            const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
   auto Start = LoadCmd.Ptr + sizeof(StructType);
   auto MaxSize = LoadCmd.C.cmdsize - sizeof(StructType);
   auto Size = strnlen(Start, MaxSize);
   LC.PayloadString = StringRef(Start, Size).str();
   return Start + Size;
 }
 
 template <>
 Expected<const char *>
 MachODumper::processLoadCommandData<MachO::dylib_command>(
     MachOYAML::LoadCommand &LC,
-    const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
+    const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd,
+    MachOYAML::Object &Y) {
   return readString<MachO::dylib_command>(LC, LoadCmd);
 }
 
 template <>
 Expected<const char *>
 MachODumper::processLoadCommandData<MachO::dylinker_command>(
     MachOYAML::LoadCommand &LC,
-    const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
+    const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd,
+    MachOYAML::Object &Y) {
   return readString<MachO::dylinker_command>(LC, LoadCmd);
 }
 
 template <>
 Expected<const char *>
 MachODumper::processLoadCommandData<MachO::rpath_command>(
     MachOYAML::LoadCommand &LC,
-    const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
+    const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd,
+    MachOYAML::Object &Y) {
   return readString<MachO::rpath_command>(LC, LoadCmd);
 }
 
 template <>
 Expected<const char *>
 MachODumper::processLoadCommandData<MachO::build_version_command>(
     MachOYAML::LoadCommand &LC,
-    const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
+    const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd,
+    MachOYAML::Object &Y) {
   auto Start = LoadCmd.Ptr + sizeof(MachO::build_version_command);
   auto NTools = LC.Data.build_version_command_data.ntools;
   for (unsigned i = 0; i < NTools; ++i) {
     auto Curr = Start + i * sizeof(MachO::build_tool_version);
     MachO::build_tool_version BV;
     memcpy((void *)&BV, Curr, sizeof(MachO::build_tool_version));
     if (Obj.isLittleEndian() != sys::IsLittleEndianHost)
       MachO::swapStruct(BV);
     LC.Tools.push_back(BV);
   }
   return Start + NTools * sizeof(MachO::build_tool_version);
 }
 
 Expected<std::unique_ptr<MachOYAML::Object>> MachODumper::dump() {
   auto Y = std::make_unique<MachOYAML::Object>();
   Y->IsLittleEndian = Obj.isLittleEndian();
   dumpHeader(Y);
   if (Error Err = dumpLoadCommands(Y))
     return std::move(Err);
   dumpLinkEdit(Y);
 
-  std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(Obj);
-  if (auto Err = dwarf2yaml(*DICtx, Y->DWARF))
-    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 LoadCmd : Obj.load_commands()) {
     const char *EndPtr = LoadCmd.Ptr;
     switch (LoadCmd.C.cmd) {
     default:
       memcpy((void *)&(LC.Data.load_command_data), LoadCmd.Ptr,
              sizeof(MachO::load_command));
       if (Obj.isLittleEndian() != sys::IsLittleEndianHost)
         MachO::swapStruct(LC.Data.load_command_data);
       if (Expected<const char *> ExpectedEndPtr =
-              processLoadCommandData<MachO::load_command>(LC, LoadCmd))
+              processLoadCommandData<MachO::load_command>(LC, LoadCmd,
+                                                          *Y.get()))
         EndPtr = *ExpectedEndPtr;
       else
         return ExpectedEndPtr.takeError();
       break;
 #include "llvm/BinaryFormat/MachO.def"
     }
     auto RemainingBytes = LoadCmd.C.cmdsize - (EndPtr - LoadCmd.Ptr);
     if (!std::all_of(EndPtr, &EndPtr[RemainingBytes],
void MachODumper::dumpSymbols(std::unique_ptr<MachOYAML::Object> &Y) {
   while (RemainingTable.size() > 0) {
     auto SymbolPair = RemainingTable.split('\0');
     RemainingTable = SymbolPair.second;
     LEData.StringTable.push_back(SymbolPair.first);
   }
 }
 
 Error macho2yaml(raw_ostream &Out, const object::MachOObjectFile &Obj) {
-  MachODumper Dumper(Obj);
+  std::unique_ptr<DWARFContext> DCtx = DWARFContext::create(Obj);
+  MachODumper Dumper(Obj, std::move(DCtx));
   Expected<std::unique_ptr<MachOYAML::Object>> YAML = Dumper.dump();
   if (!YAML)
     return YAML.takeError();
 
   yaml::YamlObjectFile YAMLFile;
   YAMLFile.MachO = std::move(YAML.get());
 
   yaml::Output Yout(Out);
for (auto Slice : Obj.objects()) {
     arch.align = Slice.getAlign();
     arch.reserved = Slice.getReserved();
     YAML.FatArchs.push_back(arch);
 
     auto SliceObj = Slice.getAsObjectFile();
     if (!SliceObj)
       return SliceObj.takeError();
 
-    MachODumper Dumper(*SliceObj.get());
+    std::unique_ptr<DWARFContext> DCtx = DWARFContext::create(*SliceObj.get());
+    MachODumper Dumper(*SliceObj.get(), std::move(DCtx));
     Expected<std::unique_ptr<MachOYAML::Object>> YAMLObj = Dumper.dump();
     if (!YAMLObj)
       return YAMLObj.takeError();
     YAML.Slices.push_back(*YAMLObj.get());
   }
 
   yaml::Output Yout(Out);
   Yout << YAML;

llvm/tools/obj2yaml/obj2yaml.h

 // Forward decls for dwarf2yaml
 namespace llvm {
 class DWARFContext;
 namespace DWARFYAML {
 struct Data;
 }
 }
 
-llvm::Error dwarf2yaml(llvm::DWARFContext &DCtx, llvm::DWARFYAML::Data &Y);
+llvm::Error dumpDebugAbbrev(llvm::DWARFContext &DCtx, llvm::DWARFYAML::Data &Y);
 llvm::Error dumpDebugARanges(llvm::DWARFContext &DCtx,
                              llvm::DWARFYAML::Data &Y);
+llvm::Error dumpDebugPubSections(llvm::DWARFContext &DCtx,
+                                 llvm::DWARFYAML::Data &Y);
+llvm::Error dumpDebugInfo(llvm::DWARFContext &DCtx, llvm::DWARFYAML::Data &Y);
+llvm::Error dumpDebugLines(llvm::DWARFContext &DCtx, llvm::DWARFYAML::Data &Y);
+llvm::Error dumpDebugRanges(llvm::DWARFContext &DCtx, llvm::DWARFYAML::Data &Y);
+llvm::Error dumpDebugStrings(llvm::DWARFContext &DCtx,
+                             llvm::DWARFYAML::Data &Y);
+
 #endif