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 "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
11 #include "llvm/ADT/SmallString.h"
12 #include "llvm/Support/DataTypes.h"
13 #include "llvm/Support/Dwarf.h"
14 #include "llvm/Support/ErrorHandling.h"
15 #include "llvm/Support/Format.h"
16 #include "llvm/Support/raw_ostream.h"
17 #include <string>
18 #include <vector>
19 
20 using namespace llvm;
21 using namespace dwarf;
22 
23 
24 /// \brief Abstract frame entry defining the common interface concrete
25 /// entries implement.
26 class llvm::FrameEntry {
27 public:
28   enum FrameKind {FK_CIE, FK_FDE};
29   FrameEntry(FrameKind K, uint64_t Offset, uint64_t Length)
30       : Kind(K), Offset(Offset), Length(Length) {}
31 
32   virtual ~FrameEntry() {
33   }
34 
35   FrameKind getKind() const { return Kind; }
36   virtual uint64_t getOffset() const { return Offset; }
37 
38   /// \brief Parse and store a sequence of CFI instructions from Data,
39   /// starting at *Offset and ending at EndOffset. If everything
40   /// goes well, *Offset should be equal to EndOffset when this method
41   /// returns. Otherwise, an error occurred.
42   virtual void parseInstructions(DataExtractor Data, uint32_t *Offset,
43                                  uint32_t EndOffset);
44 
45   /// \brief Dump the entry header to the given output stream.
46   virtual void dumpHeader(raw_ostream &OS) const = 0;
47 
48   /// \brief Dump the entry's instructions to the given output stream.
49   virtual void dumpInstructions(raw_ostream &OS) const;
50 
51 protected:
52   const FrameKind Kind;
53 
54   /// \brief Offset of this entry in the section.
55   uint64_t Offset;
56 
57   /// \brief Entry length as specified in DWARF.
58   uint64_t Length;
59 
60   /// An entry may contain CFI instructions. An instruction consists of an
61   /// opcode and an optional sequence of operands.
62   typedef std::vector<uint64_t> Operands;
63   struct Instruction {
64     Instruction(uint8_t Opcode)
65       : Opcode(Opcode)
66     {}
67 
68     uint8_t Opcode;
69     Operands Ops;
70   };
71 
72   std::vector<Instruction> Instructions;
73 
74   /// Convenience methods to add a new instruction with the given opcode and
75   /// operands to the Instructions vector.
76   void addInstruction(uint8_t Opcode) {
77     Instructions.push_back(Instruction(Opcode));
78   }
79 
80   void addInstruction(uint8_t Opcode, uint64_t Operand1) {
81     Instructions.push_back(Instruction(Opcode));
82     Instructions.back().Ops.push_back(Operand1);
83   }
84 
85   void addInstruction(uint8_t Opcode, uint64_t Operand1, uint64_t Operand2) {
86     Instructions.push_back(Instruction(Opcode));
87     Instructions.back().Ops.push_back(Operand1);
88     Instructions.back().Ops.push_back(Operand2);
89   }
90 };
91 
92 
93 // See DWARF standard v3, section 7.23
94 const uint8_t DWARF_CFI_PRIMARY_OPCODE_MASK = 0xc0;
95 const uint8_t DWARF_CFI_PRIMARY_OPERAND_MASK = 0x3f;
96 
97 void FrameEntry::parseInstructions(DataExtractor Data, uint32_t *Offset,
98                                    uint32_t EndOffset) {
99   while (*Offset < EndOffset) {
100     uint8_t Opcode = Data.getU8(Offset);
101     // Some instructions have a primary opcode encoded in the top bits.
102     uint8_t Primary = Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK;
103 
104     if (Primary) {
105       // If it's a primary opcode, the first operand is encoded in the bottom
106       // bits of the opcode itself.
107       uint64_t Op1 = Opcode & DWARF_CFI_PRIMARY_OPERAND_MASK;
108       switch (Primary) {
109         default: llvm_unreachable("Impossible primary CFI opcode");
110         case DW_CFA_advance_loc:
111         case DW_CFA_restore:
112           addInstruction(Primary, Op1);
113           break;
114         case DW_CFA_offset:
115           addInstruction(Primary, Op1, Data.getULEB128(Offset));
116           break;
117       }
118     } else {
119       // Extended opcode - its value is Opcode itself.
120       switch (Opcode) {
121         default: llvm_unreachable("Invalid extended CFI opcode");
122         case DW_CFA_nop:
123         case DW_CFA_remember_state:
124         case DW_CFA_restore_state:
125         case DW_CFA_GNU_window_save:
126           // No operands
127           addInstruction(Opcode);
128           break;
129         case DW_CFA_set_loc:
130           // Operands: Address
131           addInstruction(Opcode, Data.getAddress(Offset));
132           break;
133         case DW_CFA_advance_loc1:
134           // Operands: 1-byte delta
135           addInstruction(Opcode, Data.getU8(Offset));
136           break;
137         case DW_CFA_advance_loc2:
138           // Operands: 2-byte delta
139           addInstruction(Opcode, Data.getU16(Offset));
140           break;
141         case DW_CFA_advance_loc4:
142           // Operands: 4-byte delta
143           addInstruction(Opcode, Data.getU32(Offset));
144           break;
145         case DW_CFA_restore_extended:
146         case DW_CFA_undefined:
147         case DW_CFA_same_value:
148         case DW_CFA_def_cfa_register:
149         case DW_CFA_def_cfa_offset:
150           // Operands: ULEB128
151           addInstruction(Opcode, Data.getULEB128(Offset));
152           break;
153         case DW_CFA_def_cfa_offset_sf:
154           // Operands: SLEB128
155           addInstruction(Opcode, Data.getSLEB128(Offset));
156           break;
157         case DW_CFA_offset_extended:
158         case DW_CFA_register:
159         case DW_CFA_def_cfa:
160         case DW_CFA_val_offset:
161           // Operands: ULEB128, ULEB128
162           addInstruction(Opcode, Data.getULEB128(Offset),
163                                  Data.getULEB128(Offset));
164           break;
165         case DW_CFA_offset_extended_sf:
166         case DW_CFA_def_cfa_sf:
167         case DW_CFA_val_offset_sf:
168           // Operands: ULEB128, SLEB128
169           addInstruction(Opcode, Data.getULEB128(Offset),
170                                  Data.getSLEB128(Offset));
171           break;
172         case DW_CFA_def_cfa_expression:
173         case DW_CFA_expression:
174         case DW_CFA_val_expression:
175           // TODO: implement this
176           report_fatal_error("Values with expressions not implemented yet!");
177       }
178     }
179   }
180 }
181 
182 
183 void FrameEntry::dumpInstructions(raw_ostream &OS) const {
184   // TODO: at the moment only instruction names are dumped. Expand this to
185   // dump operands as well.
186   for (const auto &Instr : Instructions) {
187     uint8_t Opcode = Instr.Opcode;
188     if (Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK)
189       Opcode &= DWARF_CFI_PRIMARY_OPCODE_MASK;
190     OS << "  " << CallFrameString(Opcode) << ":\n";
191   }
192 }
193 
194 
195 namespace {
196 /// \brief DWARF Common Information Entry (CIE)
197 class CIE : public FrameEntry {
198 public:
199   // CIEs (and FDEs) are simply container classes, so the only sensible way to
200   // create them is by providing the full parsed contents in the constructor.
201   CIE(uint64_t Offset, uint64_t Length, uint8_t Version,
202       SmallString<8> Augmentation, uint64_t CodeAlignmentFactor,
203       int64_t DataAlignmentFactor, uint64_t ReturnAddressRegister)
204       : FrameEntry(FK_CIE, Offset, Length), Version(Version),
205         Augmentation(std::move(Augmentation)),
206         CodeAlignmentFactor(CodeAlignmentFactor),
207         DataAlignmentFactor(DataAlignmentFactor),
208         ReturnAddressRegister(ReturnAddressRegister) {}
209 
210   ~CIE() {
211   }
212 
213   void dumpHeader(raw_ostream &OS) const override {
214     OS << format("%08x %08x %08x CIE",
215                  (uint32_t)Offset, (uint32_t)Length, DW_CIE_ID)
216        << "\n";
217     OS << format("  Version:               %d\n", Version);
218     OS << "  Augmentation:          \"" << Augmentation << "\"\n";
219     OS << format("  Code alignment factor: %u\n",
220                  (uint32_t)CodeAlignmentFactor);
221     OS << format("  Data alignment factor: %d\n",
222                  (int32_t)DataAlignmentFactor);
223     OS << format("  Return address column: %d\n",
224                  (int32_t)ReturnAddressRegister);
225     OS << "\n";
226   }
227 
228   static bool classof(const FrameEntry *FE) {
229     return FE->getKind() == FK_CIE;
230   }
231 
232 private:
233   /// The following fields are defined in section 6.4.1 of the DWARF standard v3
234   uint8_t Version;
235   SmallString<8> Augmentation;
236   uint64_t CodeAlignmentFactor;
237   int64_t DataAlignmentFactor;
238   uint64_t ReturnAddressRegister;
239 };
240 
241 
242 /// \brief DWARF Frame Description Entry (FDE)
243 class FDE : public FrameEntry {
244 public:
245   // Each FDE has a CIE it's "linked to". Our FDE contains is constructed with
246   // an offset to the CIE (provided by parsing the FDE header). The CIE itself
247   // is obtained lazily once it's actually required.
248   FDE(uint64_t Offset, uint64_t Length, int64_t LinkedCIEOffset,
249       uint64_t InitialLocation, uint64_t AddressRange)
250       : FrameEntry(FK_FDE, Offset, Length), LinkedCIEOffset(LinkedCIEOffset),
251         InitialLocation(InitialLocation), AddressRange(AddressRange),
252         LinkedCIE(nullptr) {}
253 
254   ~FDE() {
255   }
256 
257   void dumpHeader(raw_ostream &OS) const override {
258     OS << format("%08x %08x %08x FDE ",
259                  (uint32_t)Offset, (uint32_t)Length, (int32_t)LinkedCIEOffset);
260     OS << format("cie=%08x pc=%08x...%08x\n",
261                  (int32_t)LinkedCIEOffset,
262                  (uint32_t)InitialLocation,
263                  (uint32_t)InitialLocation + (uint32_t)AddressRange);
264     if (LinkedCIE) {
265       OS << format("%p\n", LinkedCIE);
266     }
267   }
268 
269   static bool classof(const FrameEntry *FE) {
270     return FE->getKind() == FK_FDE;
271   }
272 
273 private:
274   /// The following fields are defined in section 6.4.1 of the DWARF standard v3
275   uint64_t LinkedCIEOffset;
276   uint64_t InitialLocation;
277   uint64_t AddressRange;
278   CIE *LinkedCIE;
279 };
280 } // end anonymous namespace
281 
282 
283 DWARFDebugFrame::DWARFDebugFrame() {
284 }
285 
286 DWARFDebugFrame::~DWARFDebugFrame() {
287 }
288 
289 static void LLVM_ATTRIBUTE_UNUSED dumpDataAux(DataExtractor Data,
290                                               uint32_t Offset, int Length) {
291   errs() << "DUMP: ";
292   for (int i = 0; i < Length; ++i) {
293     uint8_t c = Data.getU8(&Offset);
294     errs().write_hex(c); errs() << " ";
295   }
296   errs() << "\n";
297 }
298 
299 
300 void DWARFDebugFrame::parse(DataExtractor Data) {
301   uint32_t Offset = 0;
302 
303   while (Data.isValidOffset(Offset)) {
304     uint32_t StartOffset = Offset;
305 
306     bool IsDWARF64 = false;
307     uint64_t Length = Data.getU32(&Offset);
308     uint64_t Id;
309 
310     if (Length == UINT32_MAX) {
311       // DWARF-64 is distinguished by the first 32 bits of the initial length
312       // field being 0xffffffff. Then, the next 64 bits are the actual entry
313       // length.
314       IsDWARF64 = true;
315       Length = Data.getU64(&Offset);
316     }
317 
318     // At this point, Offset points to the next field after Length.
319     // Length is the structure size excluding itself. Compute an offset one
320     // past the end of the structure (needed to know how many instructions to
321     // read).
322     // TODO: For honest DWARF64 support, DataExtractor will have to treat
323     //       offset_ptr as uint64_t*
324     uint32_t EndStructureOffset = Offset + static_cast<uint32_t>(Length);
325 
326     // The Id field's size depends on the DWARF format
327     Id = Data.getUnsigned(&Offset, IsDWARF64 ? 8 : 4);
328     bool IsCIE = ((IsDWARF64 && Id == DW64_CIE_ID) || Id == DW_CIE_ID);
329 
330     if (IsCIE) {
331       // Note: this is specifically DWARFv3 CIE header structure. It was
332       // changed in DWARFv4. We currently don't support reading DWARFv4
333       // here because LLVM itself does not emit it (and LLDB doesn't
334       // support it either).
335       uint8_t Version = Data.getU8(&Offset);
336       const char *Augmentation = Data.getCStr(&Offset);
337       uint64_t CodeAlignmentFactor = Data.getULEB128(&Offset);
338       int64_t DataAlignmentFactor = Data.getSLEB128(&Offset);
339       uint64_t ReturnAddressRegister = Data.getULEB128(&Offset);
340 
341       Entries.emplace_back(new CIE(StartOffset, Length, Version,
342                                    StringRef(Augmentation), CodeAlignmentFactor,
343                                    DataAlignmentFactor, ReturnAddressRegister));
344     } else {
345       // FDE
346       uint64_t CIEPointer = Id;
347       uint64_t InitialLocation = Data.getAddress(&Offset);
348       uint64_t AddressRange = Data.getAddress(&Offset);
349 
350       Entries.emplace_back(new FDE(StartOffset, Length, CIEPointer,
351                                    InitialLocation, AddressRange));
352     }
353 
354     Entries.back()->parseInstructions(Data, &Offset, EndStructureOffset);
355 
356     if (Offset != EndStructureOffset) {
357       std::string Str;
358       raw_string_ostream OS(Str);
359       OS << format("Parsing entry instructions at %lx failed", StartOffset);
360       report_fatal_error(Str);
361     }
362   }
363 }
364 
365 
366 void DWARFDebugFrame::dump(raw_ostream &OS) const {
367   OS << "\n";
368   for (const auto &Entry : Entries) {
369     Entry->dumpHeader(OS);
370     Entry->dumpInstructions(OS);
371     OS << "\n";
372   }
373 }
374 
375