[llvm-readobj][MachO] Support option --unwind for __eh_frame

[gkm]

Summary

LLD will soon prune redundant __eh_frame entries. In order to debug this in LLD, we need the capacity to dump and cross-check the __eh_frame section and __unwind_info sections.

This diff adds the __eh_frame dumper.

The dumper code is adapted from llvm/tools/llvm-readobj/DwarfCFIEHPrinter.h:PrinterContext<ELFT>::printEHFrame().

[jhenderson]

You should try and find some Mach-O developers to assist with this, as I'm afraid I've got no real experience with it (my herald rule is dumb and just matches any llvm-readobj change). I know @smeenai and @alexander-shaposhnikov have been involved with the Mach-O side of llvm-objcopy, so are probably in a good place to review this too.

llvm/test/tools/llvm-readobj/MachO/eh_frame.yaml

1

Nit: add trailing "."

[thakis]

That looks ok, but doesn't llvm-dwarfdump --eh-frame file do this already?

[gkm]

In D105258#2852740, @thakis wrote:

That looks ok, but doesn't llvm-dwarfdump --eh-frame file do this already?

Ah yes, though the function addresses printed as pc=... are wrong. I will file a bug.

The ultimate goal with llvm-readobj is to dump any & all of __eh_frame, __compact_unwind, and __unwind_info, whereas the latter two are beyond the scope of llvm-dwarfdump.

[thakis]

In D105258#2853837, @gkm wrote:

In D105258#2852740, @thakis wrote:

That looks ok, but doesn't llvm-dwarfdump --eh-frame file do this already?

Ah yes, though the function addresses printed as pc=... are wrong. I will file a bug.

I think they're correct (?) They used to be wrong, but they seem to be fine now, at least in the examples I looked at – see unwinfo.py output here https://bugs.llvm.org/show_bug.cgi?id=50956 and comments about llvm-dwarfdump here https://github.com/nico/hack/blob/master/unwinfo.py#L63

The ultimate goal with llvm-readobj is to dump any & all of __eh_frame, __compact_unwind, and __unwind_info, whereas the latter two are beyond the scope of llvm-dwarfdump.

Yes, I think that's a good goal. There isn't a great way to do get a combined view at the moment.

[clayborg]

If we need to cross check between the two outputs (eh_frame and unwind_info), do we want some sort of intermediate output so we can see the unwind info organized by address instead of random order?

llvm/tools/llvm-readobj/MachODumper.cpp

726–734

I am assuming we must print this all in this code so we can use the "W" dumper (as opposed to telling the CIE to dump itself to a raw_ostream)?

743–746

I really don't like how the FDE calls is start address "initial location" and the address range size "address range". Granted this is how it is documented in the DWARF spec, but I am not a huge fan of these names. If you need it the output to be true to the specficiation, then this is ok. But in general, I would much rather see a printed address range in the output something like:

range: [0x1000-0x2000)

instead of

initial_location: 0x1000
address_range: 0x1000 (end: 0x2000)

Also make sure that the start address range has been relocated. In the actual data it is PC relative, just make sure the address range makes sense and matches what llvm-dwarfdump outputs in its output:

00000018 0000001c 0000001c FDE cie=00000000 pc=00004d50...00004d6a

748

FYI: you can easily dump the unwind info for each FDE to show the unwind info in the row. The output looks like:

00000018 0000001c 0000001c FDE cie=00000000 pc=00004d50...00004d6a
  Format:       DWARF32
  DW_CFA_nop:
  DW_CFA_nop:
  DW_CFA_nop:
  DW_CFA_nop:
  DW_CFA_nop:
  DW_CFA_nop:
  DW_CFA_nop:

  0x4d50: CFA=RSP+8: RIP=[CFA-8]

The last line dumps all of the rows that the FDE defines. Might be handy to include this information.

[thakis]

llvm/tools/llvm-readobj/MachODumper.cpp

689

That's a good point, the current factoring here makes it hard to do interleaved output by address like the output on https://bugs.llvm.org/show_bug.cgi?id=50956 . I think that's a useful way to present this information.

llvm/test/tools/llvm-readobj/MachO/eh_frame.yaml

+## Verify that llvm-readobj can dump the __eh_frame section
+# RUN: yaml2obj %s -o %t
+# RUN: llvm-readobj --unwind %t | FileCheck %s --allow-empty
+
+# CHECK:       __eh_frame {
+# CHECK-NEXT:    Segment: __TEXT
+# CHECK-NEXT:    Name: __eh_frame
+# CHECK-NEXT:    Address: 0x100003FB8
+# CHECK-NEXT:    Size: 0x40
+# CHECK-NEXT:    Offset: 0x3FB8
+# CHECK-NEXT:    Type: Regular (0x0)
+# CHECK-NEXT:    Attributes [ (0x0)
+# CHECK-NEXT:    ]
+# CHECK-NEXT:      [0x100003fb8] CIE length=20
+# CHECK-NEXT:        version: 1
+# CHECK-NEXT:        augmentation: zR
+# CHECK-NEXT:        code_alignment_factor: 1
+# CHECK-NEXT:        data_alignment_factor: -8
+# CHECK-NEXT:        return_address_register: 16
+# CHECK-EMPTY:
+# CHECK-NEXT:        Program:
+# CHECK-NEXT:    DW_CFA_def_cfa: reg7 +8
+# CHECK-NEXT:    DW_CFA_offset: reg16 -8
+# CHECK-NEXT:    DW_CFA_nop:
+# CHECK-NEXT:    DW_CFA_nop:
+# CHECK-EMPTY:
+# CHECK-NEXT:      [0x100003fd0] FDE length=36 cie=[0x100003fb8]
+# CHECK-NEXT:        initial_location: 0x100003f60
+# CHECK-NEXT:        address_range: 0xf (end : 0x100003f6f)
+# CHECK-EMPTY:
+# CHECK-NEXT:        Program:
+# CHECK-NEXT:    DW_CFA_advance_loc: 1
+# CHECK-NEXT:    DW_CFA_def_cfa_offset: +16
+# CHECK-NEXT:    DW_CFA_offset: reg6 -16
+# CHECK-NEXT:    DW_CFA_advance_loc: 3
+# CHECK-NEXT:    DW_CFA_def_cfa_register: reg6
+# CHECK-NEXT:    DW_CFA_nop:
+# CHECK-NEXT:    DW_CFA_nop:
+# CHECK-NEXT:    DW_CFA_nop:
+# CHECK-NEXT:    DW_CFA_nop:
+# CHECK-NEXT:    DW_CFA_nop:
+# CHECK-NEXT:    DW_CFA_nop:
+# CHECK-NEXT:    DW_CFA_nop:
+# CHECK-EMPTY:
+# CHECK-NEXT:  }
+
+## Note that the following YAML comes from an executable
+## built from this test.c source:
+##   int main() { return 0; }
+## ... linked with:
+##   clang -Wl,-keep_dwarf_unwind -o test{,.c}
+## ... and all load commands after the __TEXT segment manually stripped
+
+--- !mach-o
+FileHeader:
+  magic:           0xFEEDFACF
+  cputype:         0x01000007
+  cpusubtype:      0x00000003
+  filetype:        0x00000002
+  ncmds:           2
+  sizeofcmds:      384
+  flags:           0x00200085
+  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:         312
+    segname:         __TEXT
+    vmaddr:          4294967296
+    vmsize:          16384
+    fileoff:         0
+    filesize:        16384
+    maxprot:         5
+    initprot:        5
+    nsects:          3
+    flags:           0
+    Sections:
+      - sectname:        __text
+        segname:         __TEXT
+        addr:            0x0000000100003F60
+        size:            15
+        offset:          0x00003F60
+        align:           4
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x80000400
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+        content:         554889E531C0C745FC000000005DC3
+      - sectname:        __unwind_info
+        segname:         __TEXT
+        addr:            0x0000000100003F70
+        size:            72
+        offset:          0x00003F70
+        align:           2
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x00000000
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+        content:         010000001C000000000000001C000000000000001C00000002000000603F00003400000034000000703F00000000000034000000030000000C000100100001000000000000000001
+      - sectname:        __eh_frame
+        segname:         __TEXT
+        addr:            0x0000000100003FB8
+        size:            64
+        offset:          0x00003FB8
+        align:           3
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x00000000
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+        content:         1400000000000000017A520001781001100C070890010000240000001C00000088FFFFFFFFFFFFFF0F0000000000000000410E108602430D0600000000000000
+...

llvm/tools/llvm-readobj/MachODumper.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "ObjDumper.h"
 #include "StackMapPrinter.h"
 #include "llvm-readobj.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 using namespace llvm;
 using namespace object;
 
 namespace {
private:
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printSymbol(const SymbolRef &Symbol);
 
   void printRelocation(const RelocationRef &Reloc);
 
   void printRelocation(const MachOObjectFile *Obj, const RelocationRef &Reloc);
 
+  void printCompactUnwind(const SectionRef &Section) const;
+  void printUnwindInfo(const SectionRef &Section) const;
+  void printEHFrame(const SectionRef &Section) const;
+
   void printSectionHeaders(const MachOObjectFile *Obj);
 
   const MachOObjectFile *Obj;
 };
 
 } // namespace
 
 
void MachODumper::printSymbol(const SymbolRef &Symbol) {
   W.printEnum("RefType", static_cast<uint16_t>(MOSymbol.Flags & 0x7),
               makeArrayRef(MachOSymbolRefTypes));
   W.printFlags("Flags", static_cast<uint16_t>(MOSymbol.Flags & ~0x7),
                makeArrayRef(MachOSymbolFlags));
   W.printHex("Value", MOSymbol.Value);
 }
 
 void MachODumper::printUnwindInfo() {
-  W.startLine() << "UnwindInfo not implemented.\n";
+  for (const SectionRef &Section : Obj->sections()) {
+    StringRef Name = unwrapOrError(Obj->getFileName(), Section.getName());
+    if (Name.equals("__compact_unwind")) {
+      DictScope H(W, "__compact_unwind");
+      printCompactUnwind(Section);
+    } else if (Name.equals("__unwind_info")) {
+      DictScope H(W, "__unwind_info");
+      printUnwindInfo(Section);
+    } else if (Name.equals("__eh_frame")) {
+      DictScope H(W, "__eh_frame");
+      printEHFrame(Section);
+    }
+  }
+}
+
+void MachODumper::printCompactUnwind(const SectionRef &Section) const {
+  W.startLine() << "printCompactUnwind not yet implemented.\n";
+}
+
+void MachODumper::printUnwindInfo(const SectionRef &Section) const {
+  W.startLine() << "printUnwindInfo not yet implemented.\n";
+}
+
+void MachODumper::printEHFrame(const SectionRef &Section) const {
+  MachOSection MOSection;
+  getSection(Obj, Section.getRawDataRefImpl(), MOSection);
+  uint64_t Address = MOSection.Address;
+  DataRefImpl DR = Section.getRawDataRefImpl();
+  StringRef Name = unwrapOrError(Obj->getFileName(), Section.getName());
+  StringRef SegmentName = Obj->getSectionFinalSegmentName(DR);
+  StringRef Data = unwrapOrError(Obj->getFileName(), Section.getContents());
+
+  W.printString("Segment", SegmentName);
+  W.printString("Name", Name);
+  W.printHex("Address", Address);
+  W.printHex("Size", MOSection.Size);
+  W.printHex("Offset", MOSection.Offset);
+  W.printEnum("Type", MOSection.Flags & 0xFF, makeArrayRef(MachOSectionTypes));
+  W.printFlags("Attributes", MOSection.Flags >> 8,
+               makeArrayRef(MachOSectionAttributes));
+  W.indent();
+
+  // Construct DWARFDataExtractor to handle relocations ("PC Begin" fields).
+  std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(*Obj, nullptr);
+  // FIXME: IsLittleEndian & AddressSize
+  DWARFDataExtractor DE(Data, /*IsLittleEndian=*/true, /*AddressSize=*/8);
+  DWARFDebugFrame EHFrame(Triple::ArchType(Obj->getArch()), /*IsEH=*/true,
+                          /*EHFrameAddress=*/Address);
+  if (Error E = EHFrame.parse(DE))
+    reportError(std::move(E), Obj->getFileName());
+
+  for (const dwarf::FrameEntry &Entry : EHFrame) {
+    if (const dwarf::CIE *CIE = dyn_cast<dwarf::CIE>(&Entry)) {
+      W.startLine() << format("[0x%" PRIx64 "] CIE length=%" PRIu64 "\n",
+                              Address + CIE->getOffset(), CIE->getLength());
+      W.indent();
+
+      W.printNumber("version", CIE->getVersion());
+      W.printString("augmentation", CIE->getAugmentationString());
+      W.printNumber("code_alignment_factor", CIE->getCodeAlignmentFactor());
+      W.printNumber("data_alignment_factor", CIE->getDataAlignmentFactor());
+      W.printNumber("return_address_register", CIE->getReturnAddressRegister());
+    } else {
+      const dwarf::FDE *FDE = cast<dwarf::FDE>(&Entry);
+      W.startLine() << format("[0x%" PRIx64 "] FDE length=%" PRIu64
+                              " cie=[0x%" PRIx64 "]\n",
+                              Address + FDE->getOffset(), FDE->getLength(),
+                              Address + FDE->getLinkedCIE()->getOffset());
+      W.indent();
+
+      W.startLine() << format("initial_location: 0x%" PRIx64 "\n",
+                              FDE->getInitialLocation());
+      W.startLine() << format(
+          "address_range: 0x%" PRIx64 " (end : 0x%" PRIx64 ")\n",
+          FDE->getAddressRange(),
+          FDE->getInitialLocation() + FDE->getAddressRange());
+    }
+
+    W.getOStream() << "\n";
+    W.startLine() << "Program:\n";
+    W.indent();
+    Entry.cfis().dump(W.getOStream(), DIDumpOptions(), nullptr,
+                      W.getIndentLevel());
+    W.unindent();
+    W.unindent();
+    W.getOStream() << "\n";
+  }
+
+  W.unindent();
 }
 
 void MachODumper::printStackMap() const {
   object::SectionRef StackMapSection;
   for (auto Sec : Obj->sections()) {
     StringRef Name;
     if (Expected<StringRef> NameOrErr = Sec.getName())
       Name = *NameOrErr;