Use dwarfdump's frame parser instead of writing a new one in llvm-obdjump

[pete]

Summary

Hi Rafael

Turns out all the code I wrote in llvm-objdump to handle __eh_frame entries wasn't needed. As you pointed out, we should handle the --debug=frames option in llvm-objdump and that led me to the code which can already parse CIEs and FDEs.

This patch deletes printMachOEHFrameSection from MachODump.cpp and instead improves DWARFDebugFrame::parse to also handle __eh_frame. It also hooks up the command line options to llvm-objdump and teaches the dwarf dumping code that it may be dumping EH data so should look at the .eh_frame section.

I think improving DWARFDebugFrame::parse makes sense as we already have single MC methods to emit both EH and DWARF frames (FrameEmitterImpl::EmitCIE, FrameEmitterImpl::EmitFDE), so parsing both EH and DWARF frames is analogous to this.

[• rafael]

General direction looks good. Just have some comments.

include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

22

The whitespace change looks ood.

lib/DebugInfo/DWARF/DWARFContext.cpp

371

This comment is a copy and paste and is probably out of place for .eh_frame. It is based on debug_frame.

lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

542

Looks like EHData is never used.
Also, where is "eh" from? I don't see it in

https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html

test/tools/llvm-objdump/eh_frame-arm64.test

1

Can you update the test to use the new command line option and delete the old one?

[pete]

Thanks for the review. Will get you an updated version shortly.

include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

22

Good catch. It was automatically indented. Will fix.

lib/DebugInfo/DWARF/DWARFContext.cpp

371

Ah yeah, i'll remove the bad comment.

lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

542

I'd been using this site. But yeah, no idea where 'eh' comes from. We don't generate it in LLVM so i'll remove it from this code.

https://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-PDA/LSB-PDA/ehframechpt.html

test/tools/llvm-objdump/eh_frame-arm64.test

1

-unwind-info is still used for other stuff. But I will remove .eh_frame dumping from that method and make this test use -debug=frames.

If we want to remove -unwind-info completely then i'm happy to, but will do in a follow up patch.

[• rafael]

Can you update the test to use the new command line option and delete the old one?

-unwind-info is still used for other stuff. But I will remove .eh_frame dumping from that method and make this test use -debug=frames.

If we want to remove -unwind-info completely then i'm happy to, but will do in a follow up patch.

Agreed.

Thanks,
Rafael

[pete]

Updated to address Rafael's comment.

Thanks,
Pete

[• rafael]

include/llvm/DebugInfo/DWARF/DWARFContext.h

51

Just EHFrame maybe?

174

getEHFrame

199

getEHFrameSection

251

EHFrameSection

291

getEHFrameSection

lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

540–544

Will this ever return null? In the format it is always present. I can be empty.

567

You can use a range loop, no?

634

'z' has to be the first character.

643

Instead of checking the string again, can't you check the variables you set when parsing? If LSDAPointerEncoding has a value for this case for example.

[pete]

Thanks for the comments.

I've renamed everything to just EHFrame. Will work on restructuring the loop now.

lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

540–544

The link I gave before suggests its optional. LLVM itself will always generate at least "zR", but I have no idea about other tools.

The line in particular I think makes it optional is "A 'z' may be present as the first character of the string"

634

Good catch. I'll be changing the structure of the loop so that it starts at index 0 and makes sure that 'z' is only at index 0. That should fix this.

643

Will do.

[pete]

Updated naming, restructured loop, and fixed FDE parsing to not recheck the contents of the CIE augmentation string.

[• rafael]

LGTM with a nit.

tools/llvm-objdump/llvm-objdump.cpp

1629

Shouldn't this be checking DIDT_Frames?

[pete]

tools/llvm-objdump/llvm-objdump.cpp

1629

Good question. Wasn't sure exactly how we want to handle this.

The cl::opt I added was copied from llvm-dwarfdump so supports much more than just frames. If we only want llvm-objdump to support frames for now then I'll remove the other options from llvm-objdump until we want to add them later.

The objdump man page lists the following, which is why I thought we could just allow pretty much anything llvm-dwarfdump has in it, but i'm happy to restrict it to frames for now:

man page: "--dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=frames-interp,=str,=loc,=Ranges]"

[pete]

Committed in r256008.

I removed all the other dump dwarf dump options so we just have dwarf=frames. We can add them back in as needed.

I left the conditional checks against "!= DIDT_Null" as that way we don't have to change those lines in future when we add more options to become more like objdump.

If any of that isn't quite what you were thinking, let me know and i'll be happy to change it.

Thanks again for the review, Rafael,
Pete

include/llvm/DebugInfo/DIContext.h

   DIContext(DIContextKind K) : Kind(K) {}
   virtual ~DIContext() {}
 
-  virtual void dump(raw_ostream &OS, DIDumpType DumpType = DIDT_All) = 0;
+  virtual void dump(raw_ostream &OS, DIDumpType DumpType = DIDT_All,
+                    bool DumpEH = false) = 0;
 
   virtual DILineInfo getLineInfoForAddress(uint64_t Address,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) = 0;

include/llvm/DebugInfo/DWARF/DWARFContext.h

   std::unique_ptr<DWARFDebugAranges> Aranges;
   std::unique_ptr<DWARFDebugLine> Line;
   std::unique_ptr<DWARFDebugFrame> DebugFrame;
+  std::unique_ptr<DWARFDebugFrame> DebugEHFrame;
   std::unique_ptr<DWARFDebugMacro> Macro;
 
   DWARFUnitSection<DWARFCompileUnit> DWOCUs;

     return DICtx->getKind() == CK_DWARF;
   }
 
-  void dump(raw_ostream &OS, DIDumpType DumpType = DIDT_All) override;
+  void dump(raw_ostream &OS, DIDumpType DumpType = DIDT_All,
+            bool DumpEH = false) override;
 
   typedef DWARFUnitSection<DWARFCompileUnit>::iterator_range cu_iterator_range;
   typedef DWARFUnitSection<DWARFTypeUnit>::iterator_range tu_iterator_range;

   /// Get a pointer to the parsed frame information object.
   const DWARFDebugFrame *getDebugFrame();
 
+  /// Get a pointer to the parsed eh frame information object.
+  const DWARFDebugFrame *getDebugEHFrame();
+
   /// Get a pointer to the parsed DebugMacro object.
   const DWARFDebugMacro *getDebugMacro();
 

   virtual const DWARFSection &getLocSection() = 0;
   virtual StringRef getARangeSection() = 0;
   virtual StringRef getDebugFrameSection() = 0;
+  virtual StringRef getDebugEHFrameSection() = 0;
   virtual const DWARFSection &getLineSection() = 0;
   virtual StringRef getStringSection() = 0;
   virtual StringRef getRangeSection() = 0;

   DWARFSection LocSection;
   StringRef ARangeSection;
   StringRef DebugFrameSection;
+  StringRef DebugEHFrameSection;
   DWARFSection LineSection;
   StringRef StringSection;
   StringRef RangeSection;

   const DWARFSection &getLocSection() override { return LocSection; }
   StringRef getARangeSection() override { return ARangeSection; }
   StringRef getDebugFrameSection() override { return DebugFrameSection; }
+  StringRef getDebugEHFrameSection() override { return DebugEHFrameSection; }
   const DWARFSection &getLineSection() override { return LineSection; }
   StringRef getStringSection() override { return StringSection; }
   StringRef getRangeSection() override { return RangeSection; }

include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

 
 class FrameEntry;
 
-/// \brief A parsed .debug_frame section
+  /// \brief A parsed .debug_frame or .eh_frame section
 ///
 class DWARFDebugFrame {
+  // True if this is parsing an eh_frame section.
+  bool IsEH;
 public:
-  DWARFDebugFrame();
+  DWARFDebugFrame(bool IsEH);
   ~DWARFDebugFrame();
 
   /// \brief Dump the section data into the given stream.

include/llvm/DebugInfo/PDB/PDBContext.h

     return DICtx->getKind() == CK_PDB;
   }
 
-  void dump(raw_ostream &OS, DIDumpType DumpType = DIDT_All) override;
+  void dump(raw_ostream &OS, DIDumpType DumpType = DIDT_All,
+            bool DumpEH = false) override;
 
   DILineInfo getLineInfoForAddress(
       uint64_t Address,

lib/DebugInfo/DWARF/DWARFContext.cpp

   Accel.dump(OS);
 }
 
-void DWARFContext::dump(raw_ostream &OS, DIDumpType DumpType) {
+void DWARFContext::dump(raw_ostream &OS, DIDumpType DumpType, bool DumpEH) {
   if (DumpType == DIDT_All || DumpType == DIDT_Abbrev) {
     OS << ".debug_abbrev contents:\n";
     getDebugAbbrev()->dump(OS);

   if (DumpType == DIDT_All || DumpType == DIDT_Frames) {
     OS << "\n.debug_frame contents:\n";
     getDebugFrame()->dump(OS);
+    if (DumpEH) {
+      OS << "\n.eh_frame contents:\n";
+      getDebugEHFrame()->dump(OS);
+    }
   }
 
   if (DumpType == DIDT_All || DumpType == DIDT_Macro) {

   // http://lists.dwarfstd.org/htdig.cgi/dwarf-discuss-dwarfstd.org/2011-December/001173.html
   DataExtractor debugFrameData(getDebugFrameSection(), isLittleEndian(),
                                getAddressSize());
-  DebugFrame.reset(new DWARFDebugFrame());
+  DebugFrame.reset(new DWARFDebugFrame(false /* IsEH */));
+  DebugFrame->parse(debugFrameData);
+  return DebugFrame.get();
+}
+
+const DWARFDebugFrame *DWARFContext::getDebugEHFrame() {
+  if (DebugEHFrame)
+    return DebugEHFrame.get();
+
+  // There's a "bug" in the DWARFv3 standard with respect to the target address
+  // size within debug frame sections. While DWARF is supposed to be independent
+  // of its container, FDEs have fields with size being "target address size",
+  // which isn't specified in DWARF in general. It's only specified for CUs, but
+  // .eh_frame can appear without a .debug_info section. Follow the example of
+  // other tools (libdwarf) and extract this from the container (ObjectFile
+  // provides this information). This problem is fixed in DWARFv4
+  // See this dwarf-discuss discussion for more details:
+  // http://lists.dwarfstd.org/htdig.cgi/dwarf-discuss-dwarfstd.org/2011-December/001173.html
+  DataExtractor debugFrameData(getDebugEHFrameSection(), isLittleEndian(),
+                               getAddressSize());
+  DebugFrame.reset(new DWARFDebugFrame(true /* IsEH */));
   DebugFrame->parse(debugFrameData);
   return DebugFrame.get();
 }

             .Case("debug_line", &LineSection.Data)
             .Case("debug_aranges", &ARangeSection)
             .Case("debug_frame", &DebugFrameSection)
+            .Case("eh_frame", &DebugEHFrameSection)
             .Case("debug_str", &StringSection)
             .Case("debug_ranges", &RangeSection)
             .Case("debug_macinfo", &MacinfoSection)

lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

 #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/DataTypes.h"

   CIE(uint64_t Offset, uint64_t Length, uint8_t Version,
       SmallString<8> Augmentation, uint8_t AddressSize,
       uint8_t SegmentDescriptorSize, uint64_t CodeAlignmentFactor,
-      int64_t DataAlignmentFactor, uint64_t ReturnAddressRegister)
+      int64_t DataAlignmentFactor, uint64_t ReturnAddressRegister,
+      SmallString<8> AugmentationData, Optional<uint32_t> FDEPointerEncoding,
+      Optional<uint32_t> LSDAPointerEncoding)
       : FrameEntry(FK_CIE, Offset, Length), Version(Version),
         Augmentation(std::move(Augmentation)),
         AddressSize(AddressSize),
         SegmentDescriptorSize(SegmentDescriptorSize),
         CodeAlignmentFactor(CodeAlignmentFactor),
         DataAlignmentFactor(DataAlignmentFactor),
-        ReturnAddressRegister(ReturnAddressRegister) {}
+        ReturnAddressRegister(ReturnAddressRegister),
+        AugmentationData(AugmentationData),
+        FDEPointerEncoding(FDEPointerEncoding),
+        LSDAPointerEncoding(LSDAPointerEncoding) { }
 
   ~CIE() override {}
 
+  StringRef getAugmentationString() const { return Augmentation; }
   uint64_t getCodeAlignmentFactor() const { return CodeAlignmentFactor; }
   int64_t getDataAlignmentFactor() const { return DataAlignmentFactor; }
+  Optional<uint32_t> getFDEPointerEncoding() const {
+    return FDEPointerEncoding;
+  }
+  Optional<uint32_t> getLSDAPointerEncoding() const {
+    return LSDAPointerEncoding;
+  }
 
   void dumpHeader(raw_ostream &OS) const override {
     OS << format("%08x %08x %08x CIE",

                  (int32_t)DataAlignmentFactor);
     OS << format("  Return address column: %d\n",
                  (int32_t)ReturnAddressRegister);
+    if (!AugmentationData.empty())
+      OS << "  Augmentation data:     " << AugmentationData << "\n";
     OS << "\n";
   }
 

   uint64_t CodeAlignmentFactor;
   int64_t DataAlignmentFactor;
   uint64_t ReturnAddressRegister;
+
+  // The following are used when the CIE represents an EH frame entry.
+  SmallString<8> AugmentationData;
+  Optional<uint32_t> FDEPointerEncoding;
+  Optional<uint32_t> LSDAPointerEncoding;
 };
 
 

   }
 }
 
-DWARFDebugFrame::DWARFDebugFrame() {
+DWARFDebugFrame::DWARFDebugFrame(bool IsEH) : IsEH(IsEH) {
 }
 
 DWARFDebugFrame::~DWARFDebugFrame() {

   errs() << "\n";
 }
 
+static unsigned getSizeForEncoding(const DataExtractor &Data,
+                                   unsigned symbolEncoding) {
+  unsigned format = symbolEncoding & 0x0f;
+  switch (format) {
+    default: llvm_unreachable("Unknown Encoding");
+    case dwarf::DW_EH_PE_absptr:
+    case dwarf::DW_EH_PE_signed:
+      return Data.getAddressSize();
+    case dwarf::DW_EH_PE_udata2:
+    case dwarf::DW_EH_PE_sdata2:
+      return 2;
+    case dwarf::DW_EH_PE_udata4:
+    case dwarf::DW_EH_PE_sdata4:
+      return 4;
+    case dwarf::DW_EH_PE_udata8:
+    case dwarf::DW_EH_PE_sdata8:
+      return 8;
+  }
+}
+
+static uint64_t readPointer(const DataExtractor &Data, uint32_t &Offset,
+                            unsigned Encoding) {
+  switch (getSizeForEncoding(Data, Encoding)) {
+    case 2:
+      return Data.getU16(&Offset);
+    case 4:
+      return Data.getU32(&Offset);
+    case 8:
+      return Data.getU64(&Offset);
+    default:
+      llvm_unreachable("Illegal data size");
+  }
+}
 
 void DWARFDebugFrame::parse(DataExtractor Data) {
   uint32_t Offset = 0;

   while (Data.isValidOffset(Offset)) {
     uint32_t StartOffset = Offset;
 
+    auto ReportError = [StartOffset](const char *ErrorMsg) {
+      std::string Str;
+      raw_string_ostream OS(Str);
+      OS << format(ErrorMsg, StartOffset);
+      OS.flush();
+      report_fatal_error(Str);
+    };
+
     bool IsDWARF64 = false;
     uint64_t Length = Data.getU32(&Offset);
     uint64_t Id;

     // read).
     // TODO: For honest DWARF64 support, DataExtractor will have to treat
     //       offset_ptr as uint64_t*
+    uint32_t StartStructureOffset = Offset;
     uint32_t EndStructureOffset = Offset + static_cast<uint32_t>(Length);
 
     // The Id field's size depends on the DWARF format
-    Id = Data.getUnsigned(&Offset, IsDWARF64 ? 8 : 4);
-    bool IsCIE = ((IsDWARF64 && Id == DW64_CIE_ID) || Id == DW_CIE_ID);
+    Id = Data.getUnsigned(&Offset, (IsDWARF64 && !IsEH) ? 8 : 4);
+    bool IsCIE = ((IsDWARF64 && Id == DW64_CIE_ID) ||
+                  Id == DW_CIE_ID ||
+                  (IsEH && !Id));
 
     if (IsCIE) {
       uint8_t Version = Data.getU8(&Offset);
       const char *Augmentation = Data.getCStr(&Offset);
+      StringRef AugmentationString(Augmentation ? Augmentation : "");
+      uint64_t EHData = 0;
+      if (AugmentationString.count("eh"))
+        EHData = Data.getAddress(&Offset);
       uint8_t AddressSize = Version < 4 ? Data.getAddressSize() : Data.getU8(&Offset);
       Data.setAddressSize(AddressSize);
       uint8_t SegmentDescriptorSize = Version < 4 ? 0 : Data.getU8(&Offset);

       int64_t DataAlignmentFactor = Data.getSLEB128(&Offset);
       uint64_t ReturnAddressRegister = Data.getULEB128(&Offset);
 
+      // Parse the augmentation data for EH CIEs
+      StringRef AugmentationData;
+      Optional<uint32_t> FDEPointerEncoding;
+      Optional<uint32_t> LSDAPointerEncoding;
+      if (IsEH && StringRef(Augmentation).startswith("z")) {
+        Optional<uint32_t> PersonalityEncoding;
+        Optional<uint64_t> Personality;
+
+        uint64_t AugmentationLength = Data.getULEB128(&Offset);
+
+        uint32_t StartAugmentationOffset = Offset;
+        uint32_t EndAugmentationOffset =
+          Offset + static_cast<uint32_t>(AugmentationLength);
+
+        // Walk the augmentation string to get all the augmentation data.
+        for (unsigned i = 1, e = AugmentationString.size(); i != e; ++i) {
+          char Char = AugmentationString[i];
+          switch (Char) {
+            case 'e':
+              if ((i + 1) == e || AugmentationString[i + 1] != 'h')
+                ReportError(
+                        "Expected 'eh' in augmentation string in entry at %lx");
+              // Skip the 'h'.
+              ++i;
+              break;
+            case 'L':
+              if (LSDAPointerEncoding)
+                ReportError("Duplicate LSDA encoding in entry at %lx");
+              LSDAPointerEncoding = Data.getU8(&Offset);
+              break;
+            case 'P': {
+              if (Personality)
+                ReportError("Duplicate personality in entry at %lx");
+              PersonalityEncoding = Data.getU8(&Offset);
+              Personality = readPointer(Data, Offset, *PersonalityEncoding);
+              break;
+            }
+            case 'R':
+              if (FDEPointerEncoding)
+                ReportError("Duplicate FDE encoding in entry at %lx");
+              FDEPointerEncoding = Data.getU8(&Offset);
+              break;
+            case 'z':
+              ReportError(
+                "'z' must be first in the augmentation string in entry at %lx");
+          }
+        }
+
+        if (Offset != EndAugmentationOffset)
+          ReportError("Parsing augmentation data at %lx failed");
+
+        AugmentationData = Data.getData().slice(StartAugmentationOffset,
+                                                EndAugmentationOffset);
+      }
+
       auto Cie = make_unique<CIE>(StartOffset, Length, Version,
                                   StringRef(Augmentation), AddressSize,
                                   SegmentDescriptorSize, CodeAlignmentFactor,
-                                  DataAlignmentFactor, ReturnAddressRegister);
+                                  DataAlignmentFactor, ReturnAddressRegister,
+                                  AugmentationData, FDEPointerEncoding,
+                                  LSDAPointerEncoding);
       CIEs[StartOffset] = Cie.get();
       Entries.emplace_back(std::move(Cie));
     } else {
       // FDE
       uint64_t CIEPointer = Id;
-      uint64_t InitialLocation = Data.getAddress(&Offset);
-      uint64_t AddressRange = Data.getAddress(&Offset);
+      uint64_t InitialLocation = 0;
+      uint64_t AddressRange = 0;
+      CIE *Cie = CIEs[IsEH ? (StartStructureOffset - CIEPointer) : CIEPointer];
+
+      if (IsEH) {
+        // The address size is encoded in the CIE we reference.
+        if (!Cie)
+          ReportError("Parsing FDE data at %lx failed due to missing CIE");
+
+        Optional<uint32_t> FDEPointerEncoding = Cie->getFDEPointerEncoding();
+        if (!FDEPointerEncoding)
+          ReportError("Parsing at %lx failed due to missing pointer encoding");
+
+        InitialLocation = readPointer(Data, Offset, *FDEPointerEncoding);
+        AddressRange = readPointer(Data, Offset, *FDEPointerEncoding);
+        StringRef AugmentationString = Cie->getAugmentationString();
+        if (AugmentationString.count('z')) {
+          // Parse the augmentation length and data for this FDE.
+          uint64_t AugmentationLength = Data.getULEB128(&Offset);
+
+          uint32_t EndAugmentationOffset =
+            Offset + static_cast<uint32_t>(AugmentationLength);
+
+          // Decode the LSDA if the CIE augmentation string said we should.
+          uint64_t LSDA = 0;
+          if (AugmentationString.count('L')) {
+            Optional<uint32_t> Encoding = Cie->getLSDAPointerEncoding();
+            if (!Encoding)
+              ReportError("Parsing at %lx failed "
+                          "due to missing pointer encoding");
+            LSDA = readPointer(Data, Offset, *Encoding);
+          }
+
+          if (Offset != EndAugmentationOffset)
+            ReportError("Parsing augmentation data at %lx failed");
+        }
+      } else {
+        InitialLocation = Data.getAddress(&Offset);
+        AddressRange = Data.getAddress(&Offset);
+      }
 
       Entries.emplace_back(new FDE(StartOffset, Length, CIEPointer,
                                    InitialLocation, AddressRange,
-                                   CIEs[CIEPointer]));
+                                   Cie));
     }
 
     Entries.back()->parseInstructions(Data, &Offset, EndStructureOffset);
 
-    if (Offset != EndStructureOffset) {
-      std::string Str;
-      raw_string_ostream OS(Str);
-      OS << format("Parsing entry instructions at %lx failed", StartOffset);
-      report_fatal_error(Str);
-    }
+    if (Offset != EndStructureOffset)
+      ReportError("Parsing entry instructions at %lx failed");
   }
 }
 

lib/DebugInfo/PDB/PDBContext.cpp

     Session->setLoadAddress(ImageBase.get());
 }
 
-void PDBContext::dump(raw_ostream &OS, DIDumpType DumpType) {}
+void PDBContext::dump(raw_ostream &OS, DIDumpType DumpType,
+                      bool DumpEH) {}
 
 DILineInfo PDBContext::getLineInfoForAddress(uint64_t Address,
                                              DILineInfoSpecifier Specifier) {

test/tools/llvm-objdump/eh_frame-arm64.test

 # RUN: llvm-objdump -unwind-info %p/Inputs/eh_frame.macho-arm64 2>/dev/null | FileCheck %s
 
-# CHECK: Contents of __eh_frame section:
-# CHECK: CIE:
-# CHECK:   Length: 16
-# CHECK:   CIE ID: 0
-# CHECK:   Version: 1
-# CHECK:   Augmentation String: zR
-# CHECK:   Code Alignment Factor: 1
-# CHECK:   Data Alignment Factor: -8
-# CHECK:   Return Address Register: 30
-# CHECK:   Augmentation Data Length: 1
-# CHECK:   FDE Address Pointer Encoding: 16
-# CHECK:   Instructions:
-# CHECK:   0c 1f 00 
-# CHECK: FDE:
-# CHECK:   Length: 32
-# CHECK:   CIE Offset: 0
-# CHECK:   PC Begin: ffffffffffffffe4
-# CHECK:   PC Range: 0000000000000020
-# CHECK:   Augmentation Data Length: 0
-# CHECK:   Instructions:
-# CHECK:   48 0e 10 9e 01 9d 02 00 00 00 00
+# CHECK: .eh_frame contents:
+
+# CHECK: 00000000 00000010 ffffffff CIE
+# CHECK:   Version:               1
+# CHECK:   Augmentation:          "zR"
+# CHECK:   Code alignment factor: 1
+# CHECK:   Data alignment factor: -8
+# CHECK:   Return address column: 30
+# CHECK:   Augmentation data:
+
+# CHECK:   DW_CFA_def_cfa: reg31 +0
+
+# CHECK: 00000014 00000020 00000018 FDE cie=00000018 pc=ffffffe4...00000004
+# CHECK:   DW_CFA_advance_loc: 8
+# CHECK:   DW_CFA_def_cfa_offset: +16
+# CHECK:   DW_CFA_offset: reg30 -8
+# CHECK:   DW_CFA_offset: reg29 -16
+# CHECK:   DW_CFA_nop:
+# CHECK:   DW_CFA_nop:
+# CHECK:   DW_CFA_nop:
+# CHECK:   DW_CFA_nop:

tools/llvm-objdump/MachODump.cpp

     printLazyBindTable(MachOOF);
   if (WeakBind)
     printWeakBindTable(MachOOF);
+
+  if (DwarfDumpType != DIDT_Null) {
+    std::unique_ptr<DIContext> DICtx(new DWARFContextInMemory(*MachOOF));
+    // Dump the complete DWARF structure.
+    DICtx->dump(outs(), DwarfDumpType, true /* DumpEH */);
+  }
 }
 
 // printUnknownCPUType() helps print_fat_headers for unknown CPU's.

   }
 }
 
-static unsigned getSizeForEncoding(bool is64Bit,
-                                   unsigned symbolEncoding) {
-  unsigned format = symbolEncoding & 0x0f;
-  switch (format) {
-    default: llvm_unreachable("Unknown Encoding");
-    case dwarf::DW_EH_PE_absptr:
-    case dwarf::DW_EH_PE_signed:
-      return is64Bit ? 8 : 4;
-    case dwarf::DW_EH_PE_udata2:
-    case dwarf::DW_EH_PE_sdata2:
-      return 2;
-    case dwarf::DW_EH_PE_udata4:
-    case dwarf::DW_EH_PE_sdata4:
-      return 4;
-    case dwarf::DW_EH_PE_udata8:
-    case dwarf::DW_EH_PE_sdata8:
-      return 8;
-  }
-}
-
-static uint64_t readPointer(const char *&Pos, bool is64Bit, unsigned Encoding) {
-  switch (getSizeForEncoding(is64Bit, Encoding)) {
-    case 2:
-      return readNext<uint16_t>(Pos);
-      break;
-    case 4:
-      return readNext<uint32_t>(Pos);
-      break;
-    case 8:
-      return readNext<uint64_t>(Pos);
-      break;
-    default:
-      llvm_unreachable("Illegal data size");
-  }
-}
-
-static void printMachOEHFrameSection(const MachOObjectFile *Obj,
-                                     std::map<uint64_t, SymbolRef> &Symbols,
-                                     const SectionRef &EHFrame) {
-  if (!Obj->isLittleEndian()) {
-    outs() << "warning: cannot handle big endian __eh_frame section\n";
-    return;
-  }
-
-  bool is64Bit = Obj->is64Bit();
-
-  outs() << "Contents of __eh_frame section:\n";
-
-  StringRef Contents;
-  EHFrame.getContents(Contents);
-
-  /// A few fields of the CIE are used when decoding the FDE's.  This struct
-  /// will cache those fields we need so that we don't have to decode it
-  /// repeatedly for each FDE that references it.
-  struct DecodedCIE {
-    Optional<uint32_t> FDEPointerEncoding;
-    Optional<uint32_t> LSDAPointerEncoding;
-    bool hasAugmentationLength;
-  };
-
-  // Map from the start offset of the CIE to the cached data for that CIE.
-  DenseMap<uint64_t, DecodedCIE> CachedCIEs;
-
-  for (const char *Pos = Contents.data(), *End = Contents.end(); Pos != End; ) {
-
-    const char *EntryStartPos = Pos;
-
-    uint64_t Length = readNext<uint32_t>(Pos);
-    if (Length == 0xffffffff)
-      Length = readNext<uint64_t>(Pos);
-
-    // Save the Pos so that we can check the length we encoded against what we
-    // end up decoding.
-    const char *PosAfterLength = Pos;
-    const char *EntryEndPos = PosAfterLength + Length;
-
-    assert(EntryEndPos <= End &&
-           "__eh_frame entry length exceeds section size");
-
-    uint32_t ID = readNext<uint32_t>(Pos);
-    if (ID == 0) {
-      // This is a CIE.
-
-      uint32_t Version = readNext<uint8_t>(Pos);
-
-      // Parse a null terminated augmentation string
-      SmallString<8> AugmentationString;
-      for (uint8_t Char = readNext<uint8_t>(Pos); Char;
-           Char = readNext<uint8_t>(Pos))
-        AugmentationString.push_back(Char);
-
-      // Optionally parse the EH data if the augmentation string says it's there.
-      Optional<uint64_t> EHData;
-      if (StringRef(AugmentationString).count("eh"))
-        EHData = is64Bit ? readNext<uint64_t>(Pos) : readNext<uint32_t>(Pos);
-
-      unsigned ULEBByteCount;
-      uint64_t CodeAlignmentFactor = decodeULEB128((const uint8_t *)Pos,
-                                                   &ULEBByteCount);
-      Pos += ULEBByteCount;
-
-      int64_t DataAlignmentFactor = decodeSLEB128((const uint8_t *)Pos,
-                                                   &ULEBByteCount);
-      Pos += ULEBByteCount;
-
-      uint32_t ReturnAddressRegister = readNext<uint8_t>(Pos);
-
-      Optional<uint64_t> AugmentationLength;
-      Optional<uint32_t> LSDAPointerEncoding;
-      Optional<uint32_t> PersonalityEncoding;
-      Optional<uint64_t> Personality;
-      Optional<uint32_t> FDEPointerEncoding;
-      if (!AugmentationString.empty() && AugmentationString.front() == 'z') {
-        AugmentationLength = decodeULEB128((const uint8_t *)Pos,
-                                           &ULEBByteCount);
-        Pos += ULEBByteCount;
-
-        // Walk the augmentation string to get all the augmentation data.
-        for (unsigned i = 1, e = AugmentationString.size(); i != e; ++i) {
-          char Char = AugmentationString[i];
-          switch (Char) {
-            case 'e':
-              assert((i + 1) != e && AugmentationString[i + 1] == 'h' &&
-                     "Expected 'eh' in augmentation string");
-              break;
-            case 'L':
-              assert(!LSDAPointerEncoding && "Duplicate LSDA encoding");
-              LSDAPointerEncoding = readNext<uint8_t>(Pos);
-              break;
-            case 'P': {
-              assert(!Personality && "Duplicate personality");
-              PersonalityEncoding = readNext<uint8_t>(Pos);
-              Personality = readPointer(Pos, is64Bit, *PersonalityEncoding);
-              break;
-            }
-            case 'R':
-              assert(!FDEPointerEncoding && "Duplicate FDE encoding");
-              FDEPointerEncoding = readNext<uint8_t>(Pos);
-              break;
-            case 'z':
-              llvm_unreachable("'z' must be first in the augmentation string");
-          }
-        }
-      }
-
-      outs() << "CIE:\n";
-      outs() << "  Length: " << Length << "\n";
-      outs() << "  CIE ID: " << ID << "\n";
-      outs() << "  Version: " << Version << "\n";
-      outs() << "  Augmentation String: " << AugmentationString << "\n";
-      if (EHData)
-        outs() << "  EHData: " << *EHData << "\n";
-      outs() << "  Code Alignment Factor: " << CodeAlignmentFactor << "\n";
-      outs() << "  Data Alignment Factor: " << DataAlignmentFactor << "\n";
-      outs() << "  Return Address Register: " << ReturnAddressRegister << "\n";
-      if (AugmentationLength) {
-        outs() << "  Augmentation Data Length: " << *AugmentationLength << "\n";
-        if (LSDAPointerEncoding) {
-          outs() << "  FDE LSDA Pointer Encoding: "
-                 << *LSDAPointerEncoding << "\n";
-        }
-        if (Personality) {
-          outs() << "  Personality Encoding: " << *PersonalityEncoding << "\n";
-          outs() << "  Personality: " << *Personality << "\n";
-        }
-        if (FDEPointerEncoding) {
-          outs() << "  FDE Address Pointer Encoding: "
-                 << *FDEPointerEncoding << "\n";
-        }
-      }
-      // FIXME: Handle instructions.
-      // For now just emit some bytes
-      outs() << "  Instructions:\n  ";
-      dumpBytes(makeArrayRef((const uint8_t*)Pos, (const uint8_t*)EntryEndPos),
-                outs());
-      outs() << "\n";
-      Pos = EntryEndPos;
-
-      // Cache this entry.
-      uint64_t Offset = EntryStartPos - Contents.data();
-      CachedCIEs[Offset] = { FDEPointerEncoding, LSDAPointerEncoding,
-                             AugmentationLength.hasValue() };
-      continue;
-    }
-
-    // This is an FDE.
-    // The CIE pointer for an FDE is the same location as the ID which we
-    // already read.
-    uint32_t CIEPointer = ID;
-
-    const char *CIEStart = PosAfterLength - CIEPointer;
-    assert(CIEStart >= Contents.data() &&
-           "FDE points to CIE before the __eh_frame start");
-
-    uint64_t CIEOffset = CIEStart - Contents.data();
-    auto CIEIt = CachedCIEs.find(CIEOffset);
-    if (CIEIt == CachedCIEs.end())
-      llvm_unreachable("Couldn't find CIE at offset in to __eh_frame section");
-
-    const DecodedCIE &CIE = CIEIt->getSecond();
-    assert(CIE.FDEPointerEncoding &&
-           "FDE references CIE which did not set pointer encoding");
-
-    uint64_t PCPointerSize = getSizeForEncoding(is64Bit,
-                                                *CIE.FDEPointerEncoding);
-
-    uint64_t PCBegin = readPointer(Pos, is64Bit, *CIE.FDEPointerEncoding);
-    uint64_t PCRange = readPointer(Pos, is64Bit, *CIE.FDEPointerEncoding);
-
-    Optional<uint64_t> AugmentationLength;
-    uint32_t LSDAPointerSize;
-    Optional<uint64_t> LSDAPointer;
-    if (CIE.hasAugmentationLength) {
-      unsigned ULEBByteCount;
-      AugmentationLength = decodeULEB128((const uint8_t *)Pos,
-                                         &ULEBByteCount);
-      Pos += ULEBByteCount;
-
-      // Decode the LSDA if the CIE augmentation string said we should.
-      if (CIE.LSDAPointerEncoding) {
-        LSDAPointerSize = getSizeForEncoding(is64Bit, *CIE.LSDAPointerEncoding);
-        LSDAPointer = readPointer(Pos, is64Bit, *CIE.LSDAPointerEncoding);
-      }
-    }
-
-    outs() << "FDE:\n";
-    outs() << "  Length: " << Length << "\n";
-    outs() << "  CIE Offset: " << CIEOffset << "\n";
-
-    if (PCPointerSize == 8) {
-      outs() << format("  PC Begin: %016" PRIx64, PCBegin) << "\n";
-      outs() << format("  PC Range: %016" PRIx64, PCRange) << "\n";
-    } else {
-      outs() << format("  PC Begin: %08" PRIx64, PCBegin) << "\n";
-      outs() << format("  PC Range: %08" PRIx64, PCRange) << "\n";
-    }
-    if (AugmentationLength) {
-      outs() << "  Augmentation Data Length: " << *AugmentationLength << "\n";
-      if (LSDAPointer) {
-        if (LSDAPointerSize == 8)
-          outs() << format("  LSDA Pointer: %016\n" PRIx64, *LSDAPointer);
-        else
-          outs() << format("  LSDA Pointer: %08\n" PRIx64, *LSDAPointer);
-      }
-    }
-
-    // FIXME: Handle instructions.
-    // For now just emit some bytes
-    outs() << "  Instructions:\n  ";
-    dumpBytes(makeArrayRef((const uint8_t*)Pos, (const uint8_t*)EntryEndPos),
-              outs());
-    outs() << "\n";
-    Pos = EntryEndPos;
-  }
-}
-
 void llvm::printMachOUnwindInfo(const MachOObjectFile *Obj) {
   std::map<uint64_t, SymbolRef> Symbols;
   for (const SymbolRef &SymRef : Obj->symbols()) {

       printMachOCompactUnwindSection(Obj, Symbols, Section);
     else if (SectName == "__unwind_info")
       printMachOUnwindInfoSection(Obj, Symbols, Section);
-    else if (SectName == "__eh_frame")
-      printMachOEHFrameSection(Obj, Symbols, Section);
+    else if (SectName == "__eh_frame") {
+      // If the Dwarf dump type is not going to dump the debug info, then
+      // we'll just print it from here.
+      if (DwarfDumpType != DIDT_Frames) {
+        std::unique_ptr<DIContext> DICtx(new DWARFContextInMemory(*Obj));
+        // Dump the frames DWARF structure.
+        DICtx->dump(outs(), DIDT_Frames, true /* DumpEH */);
+      }
+    }
   }
 }
 

tools/llvm-objdump/llvm-objdump.h

 #define LLVM_TOOLS_LLVM_OBJDUMP_LLVM_OBJDUMP_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/DebugInfo/DIContext.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/DataTypes.h"
 

 extern cl::opt<bool> SymbolTable;
 extern cl::opt<bool> UnwindInfo;
 extern cl::opt<bool> PrintImmHex;
+extern cl::opt<DIDumpType> DwarfDumpType;
 
 // Various helper functions.
 void error(std::error_code ec);

tools/llvm-objdump/llvm-objdump.cpp

 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/CodeGen/FaultMaps.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler.h"

 cl::opt<bool> PrintFaultMaps("fault-map-section",
                              cl::desc("Display contents of faultmap section"));
 
+cl::opt<DIDumpType> llvm::DwarfDumpType(
+    "dwarf", cl::init(DIDT_Null), cl::desc("Dump of dwarf debug sections:"),
+    cl::values(
+        clEnumValN(DIDT_All, "all", "Dump all debug sections"),
+        clEnumValN(DIDT_Abbrev, "abbrev", ".debug_abbrev"),
+        clEnumValN(DIDT_AbbrevDwo, "abbrev.dwo", ".debug_abbrev.dwo"),
+        clEnumValN(DIDT_AppleNames, "apple_names", ".apple_names"),
+        clEnumValN(DIDT_AppleTypes, "apple_types", ".apple_types"),
+        clEnumValN(DIDT_AppleNamespaces, "apple_namespaces",
+                   ".apple_namespaces"),
+        clEnumValN(DIDT_AppleObjC, "apple_objc", ".apple_objc"),
+        clEnumValN(DIDT_Aranges, "aranges", ".debug_aranges"),
+        clEnumValN(DIDT_Info, "info", ".debug_info"),
+        clEnumValN(DIDT_InfoDwo, "info.dwo", ".debug_info.dwo"),
+        clEnumValN(DIDT_Types, "types", ".debug_types"),
+        clEnumValN(DIDT_TypesDwo, "types.dwo", ".debug_types.dwo"),
+        clEnumValN(DIDT_Line, "line", ".debug_line"),
+        clEnumValN(DIDT_LineDwo, "line.dwo", ".debug_line.dwo"),
+        clEnumValN(DIDT_Loc, "loc", ".debug_loc"),
+        clEnumValN(DIDT_LocDwo, "loc.dwo", ".debug_loc.dwo"),
+        clEnumValN(DIDT_Frames, "frames", ".debug_frame"),
+        clEnumValN(DIDT_Macro, "macro", ".debug_macinfo"),
+        clEnumValN(DIDT_Ranges, "ranges", ".debug_ranges"),
+        clEnumValN(DIDT_Pubnames, "pubnames", ".debug_pubnames"),
+        clEnumValN(DIDT_Pubtypes, "pubtypes", ".debug_pubtypes"),
+        clEnumValN(DIDT_GnuPubnames, "gnu_pubnames", ".debug_gnu_pubnames"),
+        clEnumValN(DIDT_GnuPubtypes, "gnu_pubtypes", ".debug_gnu_pubtypes"),
+        clEnumValN(DIDT_Str, "str", ".debug_str"),
+        clEnumValN(DIDT_StrDwo, "str.dwo", ".debug_str.dwo"),
+        clEnumValN(DIDT_StrOffsetsDwo, "str_offsets.dwo",
+                   ".debug_str_offsets.dwo"),
+        clEnumValN(DIDT_CUIndex, "cu_index", ".debug_cu_index"),
+        clEnumValN(DIDT_TUIndex, "tu_index", ".debug_tu_index"), clEnumValEnd));
+
 static StringRef ToolName;
 
 namespace {

     printRawClangAST(o);
   if (PrintFaultMaps)
     printFaultMaps(o);
+  if (DwarfDumpType != DIDT_Null) {
+    std::unique_ptr<DIContext> DICtx(new DWARFContextInMemory(*o));
+    // Dump the complete DWARF structure.
+    DICtx->dump(outs(), DwarfDumpType, true /* DumpEH */);
+  }
 }
 
 /// @brief Dump each object file in \a a;

       && !(DylibId && MachOOpt)
       && !(ObjcMetaData && MachOOpt)
       && !(FilterSections.size() != 0 && MachOOpt)
-      && !PrintFaultMaps) {
+      && !PrintFaultMaps
+      && DwarfDumpType == DIDT_Null) {
     cl::PrintHelpMessage();
     return 2;
   }