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/ArrayRef.h"
12 #include "llvm/ADT/SmallString.h"
13 #include "llvm/Support/Casting.h"
14 #include "llvm/Support/DataTypes.h"
15 #include "llvm/Support/Dwarf.h"
16 #include "llvm/Support/ErrorHandling.h"
17 #include "llvm/Support/Format.h"
18 #include "llvm/Support/raw_ostream.h"
19 #include <string>
20 #include <vector>
21 
22 using namespace llvm;
23 using namespace dwarf;
24 
25 
26 /// \brief Abstract frame entry defining the common interface concrete
27 /// entries implement.
28 class llvm::FrameEntry {
29 public:
30   enum FrameKind {FK_CIE, FK_FDE};
31   FrameEntry(FrameKind K, uint64_t Offset, uint64_t Length)
32       : Kind(K), Offset(Offset), Length(Length) {}
33 
34   virtual ~FrameEntry() {
35   }
36 
37   FrameKind getKind() const { return Kind; }
38   virtual uint64_t getOffset() const { return Offset; }
39 
40   /// \brief Parse and store a sequence of CFI instructions from Data,
41   /// starting at *Offset and ending at EndOffset. If everything
42   /// goes well, *Offset should be equal to EndOffset when this method
43   /// returns. Otherwise, an error occurred.
44   virtual void parseInstructions(DataExtractor Data, uint32_t *Offset,
45                                  uint32_t EndOffset);
46 
47   /// \brief Dump the entry header to the given output stream.
48   virtual void dumpHeader(raw_ostream &OS) const = 0;
49 
50   /// \brief Dump the entry's instructions to the given output stream.
51   virtual void dumpInstructions(raw_ostream &OS) const;
52 
53 protected:
54   const FrameKind Kind;
55 
56   /// \brief Offset of this entry in the section.
57   uint64_t Offset;
58 
59   /// \brief Entry length as specified in DWARF.
60   uint64_t Length;
61 
62   /// An entry may contain CFI instructions. An instruction consists of an
63   /// opcode and an optional sequence of operands.
64   typedef std::vector<uint64_t> Operands;
65   struct Instruction {
66     Instruction(uint8_t Opcode)
67       : Opcode(Opcode)
68     {}
69 
70     uint8_t Opcode;
71     Operands Ops;
72   };
73 
74   std::vector<Instruction> Instructions;
75 
76   /// Convenience methods to add a new instruction with the given opcode and
77   /// operands to the Instructions vector.
78   void addInstruction(uint8_t Opcode) {
79     Instructions.push_back(Instruction(Opcode));
80   }
81 
82   void addInstruction(uint8_t Opcode, uint64_t Operand1) {
83     Instructions.push_back(Instruction(Opcode));
84     Instructions.back().Ops.push_back(Operand1);
85   }
86 
87   void addInstruction(uint8_t Opcode, uint64_t Operand1, uint64_t Operand2) {
88     Instructions.push_back(Instruction(Opcode));
89     Instructions.back().Ops.push_back(Operand1);
90     Instructions.back().Ops.push_back(Operand2);
91   }
92 };
93 
94 
95 // See DWARF standard v3, section 7.23
96 const uint8_t DWARF_CFI_PRIMARY_OPCODE_MASK = 0xc0;
97 const uint8_t DWARF_CFI_PRIMARY_OPERAND_MASK = 0x3f;
98 
99 void FrameEntry::parseInstructions(DataExtractor Data, uint32_t *Offset,
100                                    uint32_t EndOffset) {
101   while (*Offset < EndOffset) {
102     uint8_t Opcode = Data.getU8(Offset);
103     // Some instructions have a primary opcode encoded in the top bits.
104     uint8_t Primary = Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK;
105 
106     if (Primary) {
107       // If it's a primary opcode, the first operand is encoded in the bottom
108       // bits of the opcode itself.
109       uint64_t Op1 = Opcode & DWARF_CFI_PRIMARY_OPERAND_MASK;
110       switch (Primary) {
111         default: llvm_unreachable("Impossible primary CFI opcode");
112         case DW_CFA_advance_loc:
113         case DW_CFA_restore:
114           addInstruction(Primary, Op1);
115           break;
116         case DW_CFA_offset:
117           addInstruction(Primary, Op1, Data.getULEB128(Offset));
118           break;
119       }
120     } else {
121       // Extended opcode - its value is Opcode itself.
122       switch (Opcode) {
123         default: llvm_unreachable("Invalid extended CFI opcode");
124         case DW_CFA_nop:
125         case DW_CFA_remember_state:
126         case DW_CFA_restore_state:
127         case DW_CFA_GNU_window_save:
128           // No operands
129           addInstruction(Opcode);
130           break;
131         case DW_CFA_set_loc:
132           // Operands: Address
133           addInstruction(Opcode, Data.getAddress(Offset));
134           break;
135         case DW_CFA_advance_loc1:
136           // Operands: 1-byte delta
137           addInstruction(Opcode, Data.getU8(Offset));
138           break;
139         case DW_CFA_advance_loc2:
140           // Operands: 2-byte delta
141           addInstruction(Opcode, Data.getU16(Offset));
142           break;
143         case DW_CFA_advance_loc4:
144           // Operands: 4-byte delta
145           addInstruction(Opcode, Data.getU32(Offset));
146           break;
147         case DW_CFA_restore_extended:
148         case DW_CFA_undefined:
149         case DW_CFA_same_value:
150         case DW_CFA_def_cfa_register:
151         case DW_CFA_def_cfa_offset:
152           // Operands: ULEB128
153           addInstruction(Opcode, Data.getULEB128(Offset));
154           break;
155         case DW_CFA_def_cfa_offset_sf:
156           // Operands: SLEB128
157           addInstruction(Opcode, Data.getSLEB128(Offset));
158           break;
159         case DW_CFA_offset_extended:
160         case DW_CFA_register:
161         case DW_CFA_def_cfa:
162         case DW_CFA_val_offset:
163           // Operands: ULEB128, ULEB128
164           addInstruction(Opcode, Data.getULEB128(Offset),
165                                  Data.getULEB128(Offset));
166           break;
167         case DW_CFA_offset_extended_sf:
168         case DW_CFA_def_cfa_sf:
169         case DW_CFA_val_offset_sf:
170           // Operands: ULEB128, SLEB128
171           addInstruction(Opcode, Data.getULEB128(Offset),
172                                  Data.getSLEB128(Offset));
173           break;
174         case DW_CFA_def_cfa_expression:
175         case DW_CFA_expression:
176         case DW_CFA_val_expression:
177           // TODO: implement this
178           report_fatal_error("Values with expressions not implemented yet!");
179       }
180     }
181   }
182 }
183 
184 namespace {
185 /// \brief DWARF Common Information Entry (CIE)
186 class CIE : public FrameEntry {
187 public:
188   // CIEs (and FDEs) are simply container classes, so the only sensible way to
189   // create them is by providing the full parsed contents in the constructor.
190   CIE(uint64_t Offset, uint64_t Length, uint8_t Version,
191       SmallString<8> Augmentation, uint64_t CodeAlignmentFactor,
192       int64_t DataAlignmentFactor, uint64_t ReturnAddressRegister)
193       : FrameEntry(FK_CIE, Offset, Length), Version(Version),
194         Augmentation(std::move(Augmentation)),
195         CodeAlignmentFactor(CodeAlignmentFactor),
196         DataAlignmentFactor(DataAlignmentFactor),
197         ReturnAddressRegister(ReturnAddressRegister) {}
198 
199   ~CIE() {
200   }
201 
202   uint64_t getCodeAlignmentFactor() const { return CodeAlignmentFactor; }
203   int64_t getDataAlignmentFactor() const { return DataAlignmentFactor; }
204 
205   void dumpHeader(raw_ostream &OS) const override {
206     OS << format("%08x %08x %08x CIE",
207                  (uint32_t)Offset, (uint32_t)Length, DW_CIE_ID)
208        << "\n";
209     OS << format("  Version:               %d\n", Version);
210     OS << "  Augmentation:          \"" << Augmentation << "\"\n";
211     OS << format("  Code alignment factor: %u\n",
212                  (uint32_t)CodeAlignmentFactor);
213     OS << format("  Data alignment factor: %d\n",
214                  (int32_t)DataAlignmentFactor);
215     OS << format("  Return address column: %d\n",
216                  (int32_t)ReturnAddressRegister);
217     OS << "\n";
218   }
219 
220   static bool classof(const FrameEntry *FE) {
221     return FE->getKind() == FK_CIE;
222   }
223 
224 private:
225   /// The following fields are defined in section 6.4.1 of the DWARF standard v3
226   uint8_t Version;
227   SmallString<8> Augmentation;
228   uint64_t CodeAlignmentFactor;
229   int64_t DataAlignmentFactor;
230   uint64_t ReturnAddressRegister;
231 };
232 
233 
234 /// \brief DWARF Frame Description Entry (FDE)
235 class FDE : public FrameEntry {
236 public:
237   // Each FDE has a CIE it's "linked to". Our FDE contains is constructed with
238   // an offset to the CIE (provided by parsing the FDE header). The CIE itself
239   // is obtained lazily once it's actually required.
240   FDE(uint64_t Offset, uint64_t Length, int64_t LinkedCIEOffset,
241       uint64_t InitialLocation, uint64_t AddressRange,
242       CIE *Cie)
243       : FrameEntry(FK_FDE, Offset, Length), LinkedCIEOffset(LinkedCIEOffset),
244         InitialLocation(InitialLocation), AddressRange(AddressRange),
245         LinkedCIE(Cie) {}
246 
247   ~FDE() {
248   }
249 
250   CIE *getLinkedCIE() const { return LinkedCIE; }
251 
252   void dumpHeader(raw_ostream &OS) const override {
253     OS << format("%08x %08x %08x FDE ",
254                  (uint32_t)Offset, (uint32_t)Length, (int32_t)LinkedCIEOffset);
255     OS << format("cie=%08x pc=%08x...%08x\n",
256                  (int32_t)LinkedCIEOffset,
257                  (uint32_t)InitialLocation,
258                  (uint32_t)InitialLocation + (uint32_t)AddressRange);
259   }
260 
261   static bool classof(const FrameEntry *FE) {
262     return FE->getKind() == FK_FDE;
263   }
264 
265 private:
266   /// The following fields are defined in section 6.4.1 of the DWARF standard v3
267   uint64_t LinkedCIEOffset;
268   uint64_t InitialLocation;
269   uint64_t AddressRange;
270   CIE *LinkedCIE;
271 };
272 
273 /// \brief Types of operands to CF instructions.
274 enum OperandType {
275   OT_Unset,
276   OT_None,
277   OT_Address,
278   OT_Offset,
279   OT_FactoredCodeOffset,
280   OT_SignedFactDataOffset,
281   OT_UnsignedFactDataOffset,
282   OT_Register,
283   OT_Expression
284 };
285 
286 } // end anonymous namespace
287 
288 /// \brief Initialize the array describing the types of operands.
289 static ArrayRef<OperandType[2]> getOperandTypes() {
290   static OperandType OpTypes[DW_CFA_restore+1][2];
291 
292 #define DECLARE_OP2(OP, OPTYPE0, OPTYPE1)       \
293   do {                                          \
294     OpTypes[OP][0] = OPTYPE0;                   \
295     OpTypes[OP][1] = OPTYPE1;                   \
296   } while (0)
297 #define DECLARE_OP1(OP, OPTYPE0) DECLARE_OP2(OP, OPTYPE0, OT_None)
298 #define DECLARE_OP0(OP) DECLARE_OP1(OP, OT_None)
299 
300   DECLARE_OP1(DW_CFA_set_loc, OT_Address);
301   DECLARE_OP1(DW_CFA_advance_loc, OT_FactoredCodeOffset);
302   DECLARE_OP1(DW_CFA_advance_loc1, OT_FactoredCodeOffset);
303   DECLARE_OP1(DW_CFA_advance_loc2, OT_FactoredCodeOffset);
304   DECLARE_OP1(DW_CFA_advance_loc4, OT_FactoredCodeOffset);
305   DECLARE_OP1(DW_CFA_MIPS_advance_loc8, OT_FactoredCodeOffset);
306   DECLARE_OP2(DW_CFA_def_cfa, OT_Register, OT_Offset);
307   DECLARE_OP2(DW_CFA_def_cfa_sf, OT_Register, OT_SignedFactDataOffset);
308   DECLARE_OP1(DW_CFA_def_cfa_register, OT_Register);
309   DECLARE_OP1(DW_CFA_def_cfa_offset, OT_Offset);
310   DECLARE_OP1(DW_CFA_def_cfa_offset_sf, OT_SignedFactDataOffset);
311   DECLARE_OP1(DW_CFA_def_cfa_expression, OT_Expression);
312   DECLARE_OP1(DW_CFA_undefined, OT_Register);
313   DECLARE_OP1(DW_CFA_same_value, OT_Register);
314   DECLARE_OP2(DW_CFA_offset, OT_Register, OT_UnsignedFactDataOffset);
315   DECLARE_OP2(DW_CFA_offset_extended, OT_Register, OT_UnsignedFactDataOffset);
316   DECLARE_OP2(DW_CFA_offset_extended_sf, OT_Register, OT_SignedFactDataOffset);
317   DECLARE_OP2(DW_CFA_val_offset, OT_Register, OT_UnsignedFactDataOffset);
318   DECLARE_OP2(DW_CFA_val_offset_sf, OT_Register, OT_SignedFactDataOffset);
319   DECLARE_OP2(DW_CFA_register, OT_Register, OT_Register);
320   DECLARE_OP2(DW_CFA_expression, OT_Register, OT_Expression);
321   DECLARE_OP2(DW_CFA_val_expression, OT_Register, OT_Expression);
322   DECLARE_OP1(DW_CFA_restore, OT_Register);
323   DECLARE_OP1(DW_CFA_restore_extended, OT_Register);
324   DECLARE_OP0(DW_CFA_remember_state);
325   DECLARE_OP0(DW_CFA_restore_state);
326   DECLARE_OP0(DW_CFA_GNU_window_save);
327   DECLARE_OP1(DW_CFA_GNU_args_size, OT_Offset);
328   DECLARE_OP0(DW_CFA_nop);
329 
330 #undef DECLARE_OP0
331 #undef DECLARE_OP1
332 #undef DECLARE_OP2
333   return ArrayRef<OperandType[2]>(&OpTypes[0], DW_CFA_restore+1);
334 }
335 
336 static ArrayRef<OperandType[2]> OpTypes = getOperandTypes();
337 
338 /// \brief Print \p Opcode's operand number \p OperandIdx which has
339 /// value \p Operand.
340 static void printOperand(raw_ostream &OS, uint8_t Opcode, unsigned OperandIdx,
341                          uint64_t Operand, uint64_t CodeAlignmentFactor,
342                          int64_t DataAlignmentFactor) {
343   assert(OperandIdx < 2);
344   OperandType Type = OpTypes[Opcode][OperandIdx];
345 
346   switch (Type) {
347   case OT_Unset:
348     OS << " Unsupported " << (OperandIdx ? "second" : "first") << " operand to";
349     if (const char *OpcodeName = CallFrameString(Opcode))
350       OS << " " << OpcodeName;
351     else
352       OS << format(" Opcode %x",  Opcode);
353     break;
354   case OT_None:
355     break;
356   case OT_Address:
357     OS << format(" %" PRIx64, Operand);
358     break;
359   case OT_Offset:
360     // The offsets are all encoded in a unsigned form, but in practice
361     // consumers use them signed. It's most certainly legacy due to
362     // the lack of signed variants in the first Dwarf standards.
363     OS << format(" %+" PRId64, int64_t(Operand));
364     break;
365   case OT_FactoredCodeOffset: // Always Unsigned
366     if (CodeAlignmentFactor)
367       OS << format(" %" PRId64, Operand * CodeAlignmentFactor);
368     else
369       OS << format(" %" PRId64 "*code_alignment_factor" , Operand);
370     break;
371   case OT_SignedFactDataOffset:
372     if (DataAlignmentFactor)
373       OS << format(" %" PRId64, int64_t(Operand) * DataAlignmentFactor);
374     else
375       OS << format(" %" PRId64 "*data_alignment_factor" , int64_t(Operand));
376     break;
377   case OT_UnsignedFactDataOffset:
378     if (DataAlignmentFactor)
379       OS << format(" %" PRId64, Operand * DataAlignmentFactor);
380     else
381       OS << format(" %" PRId64 "*data_alignment_factor" , Operand);
382     break;
383   case OT_Register:
384     OS << format(" reg%" PRId64, Operand);
385     break;
386   case OT_Expression:
387     OS << " expression";
388     break;
389   }
390 }
391 
392 void FrameEntry::dumpInstructions(raw_ostream &OS) const {
393   uint64_t CodeAlignmentFactor = 0;
394   int64_t DataAlignmentFactor = 0;
395   const CIE *Cie = dyn_cast<CIE>(this);
396 
397   if (!Cie)
398     Cie = cast<FDE>(this)->getLinkedCIE();
399   if (Cie) {
400     CodeAlignmentFactor = Cie->getCodeAlignmentFactor();
401     DataAlignmentFactor = Cie->getDataAlignmentFactor();
402   }
403 
404   for (const auto &Instr : Instructions) {
405     uint8_t Opcode = Instr.Opcode;
406     if (Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK)
407       Opcode &= DWARF_CFI_PRIMARY_OPCODE_MASK;
408     OS << "  " << CallFrameString(Opcode) << ":";
409     for (unsigned i = 0; i < Instr.Ops.size(); ++i)
410       printOperand(OS, Opcode, i, Instr.Ops[i], CodeAlignmentFactor,
411                    DataAlignmentFactor);
412     OS << '\n';
413   }
414 }
415 
416 DWARFDebugFrame::DWARFDebugFrame() {
417 }
418 
419 DWARFDebugFrame::~DWARFDebugFrame() {
420 }
421 
422 static void LLVM_ATTRIBUTE_UNUSED dumpDataAux(DataExtractor Data,
423                                               uint32_t Offset, int Length) {
424   errs() << "DUMP: ";
425   for (int i = 0; i < Length; ++i) {
426     uint8_t c = Data.getU8(&Offset);
427     errs().write_hex(c); errs() << " ";
428   }
429   errs() << "\n";
430 }
431 
432 
433 void DWARFDebugFrame::parse(DataExtractor Data) {
434   uint32_t Offset = 0;
435   DenseMap<uint32_t, CIE *> CIEs;
436 
437   while (Data.isValidOffset(Offset)) {
438     uint32_t StartOffset = Offset;
439 
440     bool IsDWARF64 = false;
441     uint64_t Length = Data.getU32(&Offset);
442     uint64_t Id;
443 
444     if (Length == UINT32_MAX) {
445       // DWARF-64 is distinguished by the first 32 bits of the initial length
446       // field being 0xffffffff. Then, the next 64 bits are the actual entry
447       // length.
448       IsDWARF64 = true;
449       Length = Data.getU64(&Offset);
450     }
451 
452     // At this point, Offset points to the next field after Length.
453     // Length is the structure size excluding itself. Compute an offset one
454     // past the end of the structure (needed to know how many instructions to
455     // read).
456     // TODO: For honest DWARF64 support, DataExtractor will have to treat
457     //       offset_ptr as uint64_t*
458     uint32_t EndStructureOffset = Offset + static_cast<uint32_t>(Length);
459 
460     // The Id field's size depends on the DWARF format
461     Id = Data.getUnsigned(&Offset, IsDWARF64 ? 8 : 4);
462     bool IsCIE = ((IsDWARF64 && Id == DW64_CIE_ID) || Id == DW_CIE_ID);
463 
464     if (IsCIE) {
465       // Note: this is specifically DWARFv3 CIE header structure. It was
466       // changed in DWARFv4. We currently don't support reading DWARFv4
467       // here because LLVM itself does not emit it (and LLDB doesn't
468       // support it either).
469       uint8_t Version = Data.getU8(&Offset);
470       const char *Augmentation = Data.getCStr(&Offset);
471       uint64_t CodeAlignmentFactor = Data.getULEB128(&Offset);
472       int64_t DataAlignmentFactor = Data.getSLEB128(&Offset);
473       uint64_t ReturnAddressRegister = Data.getULEB128(&Offset);
474 
475       auto Cie = make_unique<CIE>(StartOffset, Length, Version,
476                                   StringRef(Augmentation), CodeAlignmentFactor,
477                                   DataAlignmentFactor, ReturnAddressRegister);
478       CIEs[StartOffset] = Cie.get();
479       Entries.emplace_back(std::move(Cie));
480     } else {
481       // FDE
482       uint64_t CIEPointer = Id;
483       uint64_t InitialLocation = Data.getAddress(&Offset);
484       uint64_t AddressRange = Data.getAddress(&Offset);
485 
486       Entries.emplace_back(new FDE(StartOffset, Length, CIEPointer,
487                                    InitialLocation, AddressRange,
488                                    CIEs[CIEPointer]));
489     }
490 
491     Entries.back()->parseInstructions(Data, &Offset, EndStructureOffset);
492 
493     if (Offset != EndStructureOffset) {
494       std::string Str;
495       raw_string_ostream OS(Str);
496       OS << format("Parsing entry instructions at %lx failed", StartOffset);
497       report_fatal_error(Str);
498     }
499   }
500 }
501 
502 
503 void DWARFDebugFrame::dump(raw_ostream &OS) const {
504   OS << "\n";
505   for (const auto &Entry : Entries) {
506     Entry->dumpHeader(OS);
507     Entry->dumpInstructions(OS);
508     OS << "\n";
509   }
510 }
511 
512