DWARFDebugFrame.cpp revision b2ac7c09b17efadea2a9f90f45801d9d2ee687aa 
1//===-- DWARFDebugFrame.h - Parsing of .debug_frame -------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "DWARFDebugFrame.h"
11#include "llvm/ADT/SmallString.h"
12#include "llvm/Support/DataTypes.h"
13#include "llvm/Support/Dwarf.h"
14#include "llvm/Support/Format.h"
15
16using namespace llvm;
17using namespace dwarf;
18
19
20class llvm::FrameEntry {
21public:
22  enum FrameKind {FK_CIE, FK_FDE};
23  FrameEntry(FrameKind K, DataExtractor D, uint64_t Offset, uint64_t Length)
24    : Kind(K), Data(D), Offset(Offset), Length(Length) {}
25
26  virtual ~FrameEntry() {
27  }
28
29  FrameKind getKind() const { return Kind; }
30
31  virtual void dumpHeader(raw_ostream &OS) const = 0;
32
33protected:
34  const FrameKind Kind;
35
36  /// \brief The data stream holding the section from which the entry was
37  /// parsed.
38  DataExtractor Data;
39
40  /// \brief Offset of this entry in the section.
41  uint64_t Offset;
42
43  /// \brief Entry length as specified in DWARF.
44  uint64_t Length;
45};
46
47
48class CIE : public FrameEntry {
49public:
50  // CIEs (and FDEs) are simply container classes, so the only sensible way to
51  // create them is by providing the full parsed contents in the constructor.
52  CIE(DataExtractor D, uint64_t Offset, uint64_t Length, uint8_t Version,
53      SmallString<8> Augmentation, uint64_t CodeAlignmentFactor,
54      int64_t DataAlignmentFactor, uint64_t ReturnAddressRegister)
55   : FrameEntry(FK_CIE, D, Offset, Length), Version(Version),
56     Augmentation(Augmentation), CodeAlignmentFactor(CodeAlignmentFactor),
57     DataAlignmentFactor(DataAlignmentFactor),
58     ReturnAddressRegister(ReturnAddressRegister) {}
59
60  ~CIE() {
61  }
62
63  void dumpHeader(raw_ostream &OS) const {
64    OS << format("%08x %08x %08x CIE", Offset, Length, DW_CIE_ID) << "\n";
65    OS << format("  Version:               %d\n", Version);
66    OS << "  Augmentation:          \"" << Augmentation << "\"\n";
67    OS << format("  Code alignment factor: %u\n", CodeAlignmentFactor);
68    OS << format("  Data alignment factor: %d\n", DataAlignmentFactor);
69    OS << format("  Return address column: %d\n", ReturnAddressRegister);
70    OS << "\n";
71  }
72
73  static bool classof(const FrameEntry *FE) {
74    return FE->getKind() == FK_CIE;
75  }
76
77private:
78  /// The following fields are defined in section 6.4.1 of the DWARF standard v3
79  uint8_t Version;
80  SmallString<8> Augmentation;
81  uint64_t CodeAlignmentFactor;
82  int64_t DataAlignmentFactor;
83  uint64_t ReturnAddressRegister;
84};
85
86
87class FDE : public FrameEntry {
88public:
89  // Each FDE has a CIE it's "linked to". Our FDE contains is constructed with
90  // an offset to the CIE (provided by parsing the FDE header). The CIE itself
91  // is obtained lazily once it's actually required.
92  FDE(DataExtractor D, uint64_t Offset, uint64_t Length,
93      int64_t LinkedCIEOffset, uint64_t InitialLocation, uint64_t AddressRange)
94   : FrameEntry(FK_FDE, D, Offset, Length), LinkedCIEOffset(LinkedCIEOffset),
95     InitialLocation(InitialLocation), AddressRange(AddressRange),
96     LinkedCIE(NULL) {}
97
98  ~FDE() {
99  }
100
101  void dumpHeader(raw_ostream &OS) const {
102    OS << format("%08x %08x %08x FDE ", Offset, Length, LinkedCIEOffset);
103    OS << format("cie=%08x pc=%08x...%08x\n",
104                 LinkedCIEOffset, InitialLocation,
105                 InitialLocation + AddressRange);
106    OS << "\n";
107    if (LinkedCIE) {
108      OS << format("%p\n", LinkedCIE);
109    }
110  }
111
112  static bool classof(const FrameEntry *FE) {
113    return FE->getKind() == FK_FDE;
114  }
115private:
116
117  /// The following fields are defined in section 6.4.1 of the DWARF standard v3
118  uint64_t LinkedCIEOffset;
119  uint64_t InitialLocation;
120  uint64_t AddressRange;
121  CIE *LinkedCIE;
122};
123
124
125DWARFDebugFrame::DWARFDebugFrame() {
126}
127
128
129DWARFDebugFrame::~DWARFDebugFrame() {
130  for (EntryVector::iterator I = Entries.begin(), E = Entries.end();
131       I != E; ++I) {
132    delete *I;
133  }
134}
135
136
137static void LLVM_ATTRIBUTE_UNUSED dumpDataAux(DataExtractor Data,
138                                              uint32_t Offset, int Length) {
139  errs() << "DUMP: ";
140  for (int i = 0; i < Length; ++i) {
141    uint8_t c = Data.getU8(&Offset);
142    errs().write_hex(c); errs() << " ";
143  }
144  errs() << "\n";
145}
146
147
148void DWARFDebugFrame::parse(DataExtractor Data) {
149  uint32_t Offset = 0;
150
151  while (Data.isValidOffset(Offset)) {
152    uint32_t StartOffset = Offset;
153
154    bool IsDWARF64 = false;
155    uint64_t Length = Data.getU32(&Offset);
156    uint64_t Id;
157
158    if (Length == UINT32_MAX) {
159      // DWARF-64 is distinguished by the first 32 bits of the initial length
160      // field being 0xffffffff. Then, the next 64 bits are the actual entry
161      // length.
162      IsDWARF64 = true;
163      Length = Data.getU64(&Offset);
164    }
165
166    // At this point, Offset points to the next field after Length.
167    // Length is the structure size excluding itself. Compute an offset one
168    // past the end of the structure (needed to know how many instructions to
169    // read).
170    // TODO: For honest DWARF64 support, DataExtractor will have to treat
171    //       offset_ptr as uint64_t*
172    uint32_t EndStructureOffset = Offset + static_cast<uint32_t>(Length);
173
174    // The Id field's size depends on the DWARF format
175    Id = Data.getUnsigned(&Offset, IsDWARF64 ? 8 : 4);
176    bool IsCIE = ((IsDWARF64 && Id == DW64_CIE_ID) || Id == DW_CIE_ID);
177
178    if (IsCIE) {
179      // Note: this is specifically DWARFv3 CIE header structure. It was
180      // changed in DWARFv4.
181      uint8_t Version = Data.getU8(&Offset);
182      const char *Augmentation = Data.getCStr(&Offset);
183      uint64_t CodeAlignmentFactor = Data.getULEB128(&Offset);
184      int64_t DataAlignmentFactor = Data.getSLEB128(&Offset);
185      uint64_t ReturnAddressRegister = Data.getULEB128(&Offset);
186
187      CIE *NewCIE = new CIE(Data, StartOffset, Length, Version,
188                            StringRef(Augmentation), CodeAlignmentFactor,
189                            DataAlignmentFactor, ReturnAddressRegister);
190      Entries.push_back(NewCIE);
191    } else {
192      // FDE
193      uint64_t CIEPointer = Id;
194      uint64_t InitialLocation = Data.getAddress(&Offset);
195      uint64_t AddressRange = Data.getAddress(&Offset);
196
197      FDE *NewFDE = new FDE(Data, StartOffset, Length, CIEPointer,
198                            InitialLocation, AddressRange);
199      Entries.push_back(NewFDE);
200    }
201
202    Offset = EndStructureOffset;
203  }
204}
205
206
207void DWARFDebugFrame::dump(raw_ostream &OS) const {
208  OS << "\n";
209  for (EntryVector::const_iterator I = Entries.begin(), E = Entries.end();
210       I != E; ++I) {
211    (*I)->dumpHeader(OS);
212  }
213}
214
215