[dwarfdump][NFC] Move DebugFrameEntry classes to header.

[JDevlieghere]

Summary

I'm working on adding verification for debug frames to llvm-dwarfdump,
which requires access to the DWARDDebugFrame internals. Currently the
DWARDDebugFrame class only exposes a parse and dump method.

Rather than doing all of this in a single differential, I'm splitting up
the work. This first patch extends the interface to provide access to a
different entries (CIE/FDE) in a DWARDDebugFrame.

[aprantl]

include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

29

please remove all occurances of \brief .

include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

 //===- DWARFDebugFrame.h - Parsing of .debug_frame --------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_DWARF_DWARFDEBUGFRAME_H
 #define LLVM_DEBUGINFO_DWARF_DWARFDEBUGFRAME_H
 
+#include "llvm/ADT/SmallString.h"
 #include "llvm/Support/DataExtractor.h"
 #include <memory>
 #include <vector>
 
 namespace llvm {
 
-class FrameEntry;
 class raw_ostream;
 
 /// \brief A parsed .debug_frame or .eh_frame section
 ///
 class DWARFDebugFrame {
   // True if this is parsing an eh_frame section.
   bool IsEH;
 
 public:
+  /// \brief Abstract frame entry defining the common interface concrete
+  /// entries implement.
+  class FrameEntry {
+  public:
+    enum FrameKind { FK_CIE, FK_FDE };
+
+    FrameEntry(FrameKind K, uint64_t Offset, uint64_t Length)
+        : Kind(K), Offset(Offset), Length(Length) {}
+
+    virtual ~FrameEntry() = default;
+
+    FrameKind getKind() const { return Kind; }
+    virtual uint64_t getOffset() const { return Offset; }
+    uint64_t getLength() const { return Length; }
+
+    /// \brief Parse and store a sequence of CFI instructions from Data,
+    /// starting at *Offset and ending at EndOffset. If everything
+    /// goes well, *Offset should be equal to EndOffset when this method
+    /// returns. Otherwise, an error occurred.
+    virtual void parseInstructions(DataExtractor Data, uint32_t *Offset,
+                                   uint32_t EndOffset);
+
+    /// \brief Dump the entry header to the given output stream.
+    virtual void dumpHeader(raw_ostream &OS) const = 0;
+
+    /// \brief Dump the entry's instructions to the given output stream.
+    virtual void dumpInstructions(raw_ostream &OS) const;
+
+  protected:
+    const FrameKind Kind;
+
+    /// \brief Offset of this entry in the section.
+    uint64_t Offset;
+
+    /// \brief Entry length as specified in DWARF.
+    uint64_t Length;
+
+    /// An entry may contain CFI instructions. An instruction consists of an
+    /// opcode and an optional sequence of operands.
+    using Operands = std::vector<uint64_t>;
+    struct Instruction {
+      Instruction(uint8_t Opcode) : Opcode(Opcode) {}
+
+      uint8_t Opcode;
+      Operands Ops;
+    };
+
+    std::vector<Instruction> Instructions;
+
+    /// Convenience methods to add a new instruction with the given opcode and
+    /// operands to the Instructions vector.
+    void addInstruction(uint8_t Opcode) {
+      Instructions.push_back(Instruction(Opcode));
+    }
+
+    void addInstruction(uint8_t Opcode, uint64_t Operand1) {
+      Instructions.push_back(Instruction(Opcode));
+      Instructions.back().Ops.push_back(Operand1);
+    }
+
+    void addInstruction(uint8_t Opcode, uint64_t Operand1, uint64_t Operand2) {
+      Instructions.push_back(Instruction(Opcode));
+      Instructions.back().Ops.push_back(Operand1);
+      Instructions.back().Ops.push_back(Operand2);
+    }
+  };
+
+  /// \brief DWARF Common Information Entry (CIE)
+  class CIE : public FrameEntry {
+  public:
+    // CIEs (and FDEs) are simply container classes, so the only sensible way to
+    // create them is by providing the full parsed contents in the constructor.
+    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,
+        SmallString<8> AugmentationData, uint32_t FDEPointerEncoding,
+        uint32_t LSDAPointerEncoding)
+        : FrameEntry(DWARFDebugFrame::FrameEntry::FK_CIE, Offset, Length),
+          Version(Version), Augmentation(std::move(Augmentation)),
+          AddressSize(AddressSize),
+          SegmentDescriptorSize(SegmentDescriptorSize),
+          CodeAlignmentFactor(CodeAlignmentFactor),
+          DataAlignmentFactor(DataAlignmentFactor),
+          ReturnAddressRegister(ReturnAddressRegister),
+          AugmentationData(std::move(AugmentationData)),
+          FDEPointerEncoding(FDEPointerEncoding),
+          LSDAPointerEncoding(LSDAPointerEncoding) {}
+
+    ~CIE() override = default;
+
+    StringRef getAugmentationString() const { return Augmentation; }
+    uint64_t getCodeAlignmentFactor() const { return CodeAlignmentFactor; }
+    int64_t getDataAlignmentFactor() const { return DataAlignmentFactor; }
+
+    uint32_t getFDEPointerEncoding() const { return FDEPointerEncoding; }
+
+    uint32_t getLSDAPointerEncoding() const { return LSDAPointerEncoding; }
+
+    void dumpHeader(raw_ostream &OS) const override;
+
+    static bool classof(const DWARFDebugFrame::FrameEntry *FE) {
+      return FE->getKind() == DWARFDebugFrame::FrameEntry::FK_CIE;
+    }
+
+  private:
+    /// The following fields are defined in section 6.4.1 of the DWARF standard
+    /// v4
+    uint8_t Version;
+    SmallString<8> Augmentation;
+    uint8_t AddressSize;
+    uint8_t SegmentDescriptorSize;
+    uint64_t CodeAlignmentFactor;
+    int64_t DataAlignmentFactor;
+    uint64_t ReturnAddressRegister;
+
+    // The following are used when the CIE represents an EH frame entry.
+    SmallString<8> AugmentationData;
+    uint32_t FDEPointerEncoding;
+    uint32_t LSDAPointerEncoding;
+  };
+
+  /// \brief DWARF Frame Description Entry (FDE)
+  class FDE : public FrameEntry {
+  public:
+    // Each FDE has a CIE it's "linked to". Our FDE contains is constructed with
+    // an offset to the CIE (provided by parsing the FDE header). The CIE itself
+    // is obtained lazily once it's actually required.
+    FDE(uint64_t Offset, uint64_t Length, int64_t LinkedCIEOffset,
+        uint64_t InitialLocation, uint64_t AddressRange, CIE *Cie)
+        : FrameEntry(DWARFDebugFrame::FrameEntry::FK_FDE, Offset, Length),
+          LinkedCIEOffset(LinkedCIEOffset), InitialLocation(InitialLocation),
+          AddressRange(AddressRange), LinkedCIE(Cie) {}
+
+    ~FDE() override = default;
+
+    CIE *getLinkedCIE() const { return LinkedCIE; }
+
+    void dumpHeader(raw_ostream &OS) const override;
+
+    static bool classof(const DWARFDebugFrame::FrameEntry *FE) {
+      return FE->getKind() == DWARFDebugFrame::FrameEntry::FK_FDE;
+    }
+
+  private:
+    /// The following fields are defined in section 6.4.1 of the DWARF standard
+    /// v3
+    uint64_t LinkedCIEOffset;
+    uint64_t InitialLocation;
+    uint64_t AddressRange;
+    CIE *LinkedCIE;
+  };
+
   DWARFDebugFrame(bool IsEH);
   ~DWARFDebugFrame();
 
   /// \brief Dump the section data into the given stream.
   void dump(raw_ostream &OS) const;
 
   /// \brief Parse the section from raw data.
   /// data is assumed to be pointing to the beginning of the section.
   void parse(DataExtractor Data);
 
+  typedef std::vector<std::unique_ptr<FrameEntry>> FrameEntryContainer;
+  typedef FrameEntryContainer::const_iterator const_iterator;
+
+  iterator_range<const_iterator> entries() const {
+    return make_range(begin(), end());
+  }
+
+  const_iterator begin() const { return Entries.begin(); }
+
+  const_iterator end() const { return Entries.end(); }
+
 private:
-  std::vector<std::unique_ptr<FrameEntry>> Entries;
+  FrameEntryContainer Entries;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGFRAME_H

lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

 //===- DWARFDebugFrame.h - Parsing of .debug_frame ------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cinttypes>
 #include <cstdint>
 #include <string>
 #include <vector>
 
 using namespace llvm;
 using namespace dwarf;
 
-/// \brief Abstract frame entry defining the common interface concrete
-/// entries implement.
-class llvm::FrameEntry {
-public:
-  enum FrameKind {FK_CIE, FK_FDE};
-
-  FrameEntry(FrameKind K, uint64_t Offset, uint64_t Length)
-      : Kind(K), Offset(Offset), Length(Length) {}
-
-  virtual ~FrameEntry() = default;
-
-  FrameKind getKind() const { return Kind; }
-  virtual uint64_t getOffset() const { return Offset; }
-
-  /// \brief Parse and store a sequence of CFI instructions from Data,
-  /// starting at *Offset and ending at EndOffset. If everything
-  /// goes well, *Offset should be equal to EndOffset when this method
-  /// returns. Otherwise, an error occurred.
-  virtual void parseInstructions(DataExtractor Data, uint32_t *Offset,
-                                 uint32_t EndOffset);
-
-  /// \brief Dump the entry header to the given output stream.
-  virtual void dumpHeader(raw_ostream &OS) const = 0;
-
-  /// \brief Dump the entry's instructions to the given output stream.
-  virtual void dumpInstructions(raw_ostream &OS) const;
-
-protected:
-  const FrameKind Kind;
-
-  /// \brief Offset of this entry in the section.
-  uint64_t Offset;
-
-  /// \brief Entry length as specified in DWARF.
-  uint64_t Length;
-
-  /// An entry may contain CFI instructions. An instruction consists of an
-  /// opcode and an optional sequence of operands.
-  using Operands = std::vector<uint64_t>;
-  struct Instruction {
-    Instruction(uint8_t Opcode)
-      : Opcode(Opcode)
-    {}
-
-    uint8_t Opcode;
-    Operands Ops;
-  };
-
-  std::vector<Instruction> Instructions;
-
-  /// Convenience methods to add a new instruction with the given opcode and
-  /// operands to the Instructions vector.
-  void addInstruction(uint8_t Opcode) {
-    Instructions.push_back(Instruction(Opcode));
-  }
-
-  void addInstruction(uint8_t Opcode, uint64_t Operand1) {
-    Instructions.push_back(Instruction(Opcode));
-    Instructions.back().Ops.push_back(Operand1);
-  }
-
-  void addInstruction(uint8_t Opcode, uint64_t Operand1, uint64_t Operand2) {
-    Instructions.push_back(Instruction(Opcode));
-    Instructions.back().Ops.push_back(Operand1);
-    Instructions.back().Ops.push_back(Operand2);
-  }
-};
-
 // See DWARF standard v3, section 7.23
 const uint8_t DWARF_CFI_PRIMARY_OPCODE_MASK = 0xc0;
 const uint8_t DWARF_CFI_PRIMARY_OPERAND_MASK = 0x3f;
 
-void FrameEntry::parseInstructions(DataExtractor Data, uint32_t *Offset,
+void DWARFDebugFrame::FrameEntry::parseInstructions(DataExtractor Data,
+                                                    uint32_t *Offset,
                                                     uint32_t EndOffset) {
   while (*Offset < EndOffset) {
     uint8_t Opcode = Data.getU8(Offset);
     // Some instructions have a primary opcode encoded in the top bits.
     uint8_t Primary = Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK;
 
     if (Primary) {
       // If it's a primary opcode, the first operand is encoded in the bottom
       // bits of the opcode itself.
if (Primary) {
           report_fatal_error("Values with expressions not implemented yet!");
       }
     }
   }
 }
 
 namespace {
 
-/// \brief DWARF Common Information Entry (CIE)
-class CIE : public FrameEntry {
-public:
-  // CIEs (and FDEs) are simply container classes, so the only sensible way to
-  // create them is by providing the full parsed contents in the constructor.
-  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,
-      SmallString<8> AugmentationData, uint32_t FDEPointerEncoding,
-      uint32_t LSDAPointerEncoding)
-      : FrameEntry(FK_CIE, Offset, Length), Version(Version),
-        Augmentation(std::move(Augmentation)), AddressSize(AddressSize),
-        SegmentDescriptorSize(SegmentDescriptorSize),
-        CodeAlignmentFactor(CodeAlignmentFactor),
-        DataAlignmentFactor(DataAlignmentFactor),
-        ReturnAddressRegister(ReturnAddressRegister),
-        AugmentationData(std::move(AugmentationData)),
-        FDEPointerEncoding(FDEPointerEncoding),
-        LSDAPointerEncoding(LSDAPointerEncoding) {}
-
-  ~CIE() override = default;
-
-  StringRef getAugmentationString() const { return Augmentation; }
-  uint64_t getCodeAlignmentFactor() const { return CodeAlignmentFactor; }
-  int64_t getDataAlignmentFactor() const { return DataAlignmentFactor; }
-
-  uint32_t getFDEPointerEncoding() const {
-    return FDEPointerEncoding;
-  }
-
-  uint32_t getLSDAPointerEncoding() const {
-    return LSDAPointerEncoding;
-  }
-
-  void dumpHeader(raw_ostream &OS) const override {
-    OS << format("%08x %08x %08x CIE",
-                 (uint32_t)Offset, (uint32_t)Length, DW_CIE_ID)
-       << "\n";
-    OS << format("  Version:               %d\n", Version);
-    OS << "  Augmentation:          \"" << Augmentation << "\"\n";
-    if (Version >= 4) {
-      OS << format("  Address size:          %u\n",
-                   (uint32_t)AddressSize);
-      OS << format("  Segment desc size:     %u\n",
-                   (uint32_t)SegmentDescriptorSize);
-    }
-    OS << format("  Code alignment factor: %u\n",
-                 (uint32_t)CodeAlignmentFactor);
-    OS << format("  Data alignment factor: %d\n",
-                 (int32_t)DataAlignmentFactor);
-    OS << format("  Return address column: %d\n",
-                 (int32_t)ReturnAddressRegister);
-    if (!AugmentationData.empty()) {
-      OS << "  Augmentation data:    ";
-      for (uint8_t Byte : AugmentationData)
-        OS << ' ' << hexdigit(Byte >> 4) << hexdigit(Byte & 0xf);
-      OS << "\n";
-    }
-    OS << "\n";
-  }
-
-  static bool classof(const FrameEntry *FE) {
-    return FE->getKind() == FK_CIE;
-  }
-
-private:
-  /// The following fields are defined in section 6.4.1 of the DWARF standard v4
-  uint8_t Version;
-  SmallString<8> Augmentation;
-  uint8_t AddressSize;
-  uint8_t SegmentDescriptorSize;
-  uint64_t CodeAlignmentFactor;
-  int64_t DataAlignmentFactor;
-  uint64_t ReturnAddressRegister;
-
-  // The following are used when the CIE represents an EH frame entry.
-  SmallString<8> AugmentationData;
-  uint32_t FDEPointerEncoding;
-  uint32_t LSDAPointerEncoding;
-};
-
-/// \brief DWARF Frame Description Entry (FDE)
-class FDE : public FrameEntry {
-public:
-  // Each FDE has a CIE it's "linked to". Our FDE contains is constructed with
-  // an offset to the CIE (provided by parsing the FDE header). The CIE itself
-  // is obtained lazily once it's actually required.
-  FDE(uint64_t Offset, uint64_t Length, int64_t LinkedCIEOffset,
-      uint64_t InitialLocation, uint64_t AddressRange,
-      CIE *Cie)
-      : FrameEntry(FK_FDE, Offset, Length), LinkedCIEOffset(LinkedCIEOffset),
-        InitialLocation(InitialLocation), AddressRange(AddressRange),
-        LinkedCIE(Cie) {}
-
-  ~FDE() override = default;
-
-  CIE *getLinkedCIE() const { return LinkedCIE; }
-
-  void dumpHeader(raw_ostream &OS) const override {
-    OS << format("%08x %08x %08x FDE ",
-                 (uint32_t)Offset, (uint32_t)Length, (int32_t)LinkedCIEOffset);
-    OS << format("cie=%08x pc=%08x...%08x\n",
-                 (int32_t)LinkedCIEOffset,
-                 (uint32_t)InitialLocation,
-                 (uint32_t)InitialLocation + (uint32_t)AddressRange);
-  }
-
-  static bool classof(const FrameEntry *FE) {
-    return FE->getKind() == FK_FDE;
-  }
-
-private:
-  /// The following fields are defined in section 6.4.1 of the DWARF standard v3
-  uint64_t LinkedCIEOffset;
-  uint64_t InitialLocation;
-  uint64_t AddressRange;
-  CIE *LinkedCIE;
-};
-
 /// \brief Types of operands to CF instructions.
 enum OperandType {
   OT_Unset,
   OT_None,
   OT_Address,
   OT_Offset,
   OT_FactoredCodeOffset,
   OT_SignedFactDataOffset,
case OT_Register:
     OS << format(" reg%" PRId64, Operand);
     break;
   case OT_Expression:
     OS << " expression";
     break;
   }
 }
 
-void FrameEntry::dumpInstructions(raw_ostream &OS) const {
+void DWARFDebugFrame::FrameEntry::dumpInstructions(raw_ostream &OS) const {
   uint64_t CodeAlignmentFactor = 0;
   int64_t DataAlignmentFactor = 0;
-  const CIE *Cie = dyn_cast<CIE>(this);
+  const auto *Cie = dyn_cast<DWARFDebugFrame::CIE>(this);
 
   if (!Cie)
-    Cie = cast<FDE>(this)->getLinkedCIE();
+    Cie = cast<DWARFDebugFrame::FDE>(this)->getLinkedCIE();
   if (Cie) {
     CodeAlignmentFactor = Cie->getCodeAlignmentFactor();
     DataAlignmentFactor = Cie->getDataAlignmentFactor();
   }
 
   for (const auto &Instr : Instructions) {
     uint8_t Opcode = Instr.Opcode;
     if (Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK)
static void LLVM_ATTRIBUTE_NORETURN ReportError(uint32_t StartOffset,
   raw_string_ostream OS(Str);
   OS << format(ErrorMsg, StartOffset);
   OS.flush();
   report_fatal_error(Str);
 }
 
 void DWARFDebugFrame::parse(DataExtractor Data) {
   uint32_t Offset = 0;
-  DenseMap<uint32_t, CIE *> CIEs;
+  DenseMap<uint32_t, DWARFDebugFrame::CIE *> CIEs;
 
   while (Data.isValidOffset(Offset)) {
     uint32_t StartOffset = Offset;
 
     bool IsDWARF64 = false;
     uint64_t Length = Data.getU32(&Offset);
     uint64_t Id;
 
if (IsCIE) {
                                         LSDAPointerEncoding);
       CIEs[StartOffset] = Cie.get();
       Entries.emplace_back(std::move(Cie));
     } else {
       // FDE
       uint64_t CIEPointer = Id;
       uint64_t InitialLocation = 0;
       uint64_t AddressRange = 0;
-      CIE *Cie = CIEs[IsEH ? (StartStructureOffset - CIEPointer) : CIEPointer];
+      DWARFDebugFrame::CIE *Cie =
+          CIEs[IsEH ? (StartStructureOffset - CIEPointer) : CIEPointer];
 
       if (IsEH) {
         // The address size is encoded in the CIE we reference.
         if (!Cie)
           ReportError(StartOffset,
                       "Parsing FDE data at %lx failed due to missing CIE");
 
         InitialLocation = readPointer(Data, Offset,
if (IsCIE) {
           if (Offset != EndAugmentationOffset)
             ReportError(StartOffset, "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,
-                                   Cie));
+      Entries.emplace_back(new DWARFDebugFrame::FDE(
+          StartOffset, Length, CIEPointer, InitialLocation, AddressRange, Cie));
     }
 
     Entries.back()->parseInstructions(Data, &Offset, EndStructureOffset);
 
     if (Offset != EndStructureOffset)
       ReportError(StartOffset, "Parsing entry instructions at %lx failed");
   }
 }
 
+void DWARFDebugFrame::CIE::dumpHeader(raw_ostream &OS) const {
+  OS << format("%08x %08x %08x CIE", (uint32_t)Offset, (uint32_t)Length,
+               DW_CIE_ID)
+     << "\n";
+  OS << format("  Version:               %d\n", Version);
+  OS << "  Augmentation:          \"" << Augmentation << "\"\n";
+  if (Version >= 4) {
+    OS << format("  Address size:          %u\n", (uint32_t)AddressSize);
+    OS << format("  Segment desc size:     %u\n",
+                 (uint32_t)SegmentDescriptorSize);
+  }
+  OS << format("  Code alignment factor: %u\n", (uint32_t)CodeAlignmentFactor);
+  OS << format("  Data alignment factor: %d\n", (int32_t)DataAlignmentFactor);
+  OS << format("  Return address column: %d\n", (int32_t)ReturnAddressRegister);
+  if (!AugmentationData.empty()) {
+    OS << "  Augmentation data:    ";
+    for (uint8_t Byte : AugmentationData)
+      OS << ' ' << hexdigit(Byte >> 4) << hexdigit(Byte & 0xf);
+    OS << "\n";
+  }
+  OS << "\n";
+}
+
+void DWARFDebugFrame::FDE::dumpHeader(raw_ostream &OS) const {
+  OS << format("%08x %08x %08x FDE ", (uint32_t)Offset, (uint32_t)Length,
+               (int32_t)LinkedCIEOffset);
+  OS << format("cie=%08x pc=%08x...%08x\n", (int32_t)LinkedCIEOffset,
+               (uint32_t)InitialLocation,
+               (uint32_t)InitialLocation + (uint32_t)AddressRange);
+}
+
 void DWARFDebugFrame::dump(raw_ostream &OS) const {
   OS << "\n";
   for (const auto &Entry : Entries) {
     Entry->dumpHeader(OS);
     Entry->dumpInstructions(OS);
     OS << "\n";
   }
 }