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/DenseMap.h"
13 #include "llvm/ADT/Optional.h"
14 #include "llvm/ADT/SmallString.h"
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/ADT/StringExtras.h"
17 #include "llvm/ADT/StringRef.h"
18 #include "llvm/Support/Casting.h"
19 #include "llvm/Support/Compiler.h"
20 #include "llvm/Support/DataExtractor.h"
21 #include "llvm/Support/Dwarf.h"
22 #include "llvm/Support/ErrorHandling.h"
23 #include "llvm/Support/Format.h"
24 #include "llvm/Support/raw_ostream.h"
25 #include <algorithm>
26 #include <cassert>
27 #include <cinttypes>
28 #include <cstdint>
29 #include <string>
30 #include <vector>
31 
32 using namespace llvm;
33 using namespace dwarf;
34 
35 /// \brief Abstract frame entry defining the common interface concrete
36 /// entries implement.
37 class llvm::FrameEntry {
38 public:
39   enum FrameKind {FK_CIE, FK_FDE};
40   FrameEntry(FrameKind K, uint64_t Offset, uint64_t Length)
41       : Kind(K), Offset(Offset), Length(Length) {}
42 
43   virtual ~FrameEntry() {
44   }
45 
46   FrameKind getKind() const { return Kind; }
47   virtual uint64_t getOffset() const { return Offset; }
48 
49   /// \brief Parse and store a sequence of CFI instructions from Data,
50   /// starting at *Offset and ending at EndOffset. If everything
51   /// goes well, *Offset should be equal to EndOffset when this method
52   /// returns. Otherwise, an error occurred.
53   virtual void parseInstructions(DataExtractor Data, uint32_t *Offset,
54                                  uint32_t EndOffset);
55 
56   /// \brief Dump the entry header to the given output stream.
57   virtual void dumpHeader(raw_ostream &OS) const = 0;
58 
59   /// \brief Dump the entry's instructions to the given output stream.
60   virtual void dumpInstructions(raw_ostream &OS) const;
61 
62 protected:
63   const FrameKind Kind;
64 
65   /// \brief Offset of this entry in the section.
66   uint64_t Offset;
67 
68   /// \brief Entry length as specified in DWARF.
69   uint64_t Length;
70 
71   /// An entry may contain CFI instructions. An instruction consists of an
72   /// opcode and an optional sequence of operands.
73   typedef std::vector<uint64_t> Operands;
74   struct Instruction {
75     Instruction(uint8_t Opcode)
76       : Opcode(Opcode)
77     {}
78 
79     uint8_t Opcode;
80     Operands Ops;
81   };
82 
83   std::vector<Instruction> Instructions;
84 
85   /// Convenience methods to add a new instruction with the given opcode and
86   /// operands to the Instructions vector.
87   void addInstruction(uint8_t Opcode) {
88     Instructions.push_back(Instruction(Opcode));
89   }
90 
91   void addInstruction(uint8_t Opcode, uint64_t Operand1) {
92     Instructions.push_back(Instruction(Opcode));
93     Instructions.back().Ops.push_back(Operand1);
94   }
95 
96   void addInstruction(uint8_t Opcode, uint64_t Operand1, uint64_t Operand2) {
97     Instructions.push_back(Instruction(Opcode));
98     Instructions.back().Ops.push_back(Operand1);
99     Instructions.back().Ops.push_back(Operand2);
100   }
101 };
102 
103 // See DWARF standard v3, section 7.23
104 const uint8_t DWARF_CFI_PRIMARY_OPCODE_MASK = 0xc0;
105 const uint8_t DWARF_CFI_PRIMARY_OPERAND_MASK = 0x3f;
106 
107 void FrameEntry::parseInstructions(DataExtractor Data, uint32_t *Offset,
108                                    uint32_t EndOffset) {
109   while (*Offset < EndOffset) {
110     uint8_t Opcode = Data.getU8(Offset);
111     // Some instructions have a primary opcode encoded in the top bits.
112     uint8_t Primary = Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK;
113 
114     if (Primary) {
115       // If it's a primary opcode, the first operand is encoded in the bottom
116       // bits of the opcode itself.
117       uint64_t Op1 = Opcode & DWARF_CFI_PRIMARY_OPERAND_MASK;
118       switch (Primary) {
119         default: llvm_unreachable("Impossible primary CFI opcode");
120         case DW_CFA_advance_loc:
121         case DW_CFA_restore:
122           addInstruction(Primary, Op1);
123           break;
124         case DW_CFA_offset:
125           addInstruction(Primary, Op1, Data.getULEB128(Offset));
126           break;
127       }
128     } else {
129       // Extended opcode - its value is Opcode itself.
130       switch (Opcode) {
131         default: llvm_unreachable("Invalid extended CFI opcode");
132         case DW_CFA_nop:
133         case DW_CFA_remember_state:
134         case DW_CFA_restore_state:
135         case DW_CFA_GNU_window_save:
136           // No operands
137           addInstruction(Opcode);
138           break;
139         case DW_CFA_set_loc:
140           // Operands: Address
141           addInstruction(Opcode, Data.getAddress(Offset));
142           break;
143         case DW_CFA_advance_loc1:
144           // Operands: 1-byte delta
145           addInstruction(Opcode, Data.getU8(Offset));
146           break;
147         case DW_CFA_advance_loc2:
148           // Operands: 2-byte delta
149           addInstruction(Opcode, Data.getU16(Offset));
150           break;
151         case DW_CFA_advance_loc4:
152           // Operands: 4-byte delta
153           addInstruction(Opcode, Data.getU32(Offset));
154           break;
155         case DW_CFA_restore_extended:
156         case DW_CFA_undefined:
157         case DW_CFA_same_value:
158         case DW_CFA_def_cfa_register:
159         case DW_CFA_def_cfa_offset:
160           // Operands: ULEB128
161           addInstruction(Opcode, Data.getULEB128(Offset));
162           break;
163         case DW_CFA_def_cfa_offset_sf:
164           // Operands: SLEB128
165           addInstruction(Opcode, Data.getSLEB128(Offset));
166           break;
167         case DW_CFA_offset_extended:
168         case DW_CFA_register:
169         case DW_CFA_def_cfa:
170         case DW_CFA_val_offset: {
171           // Operands: ULEB128, ULEB128
172           // Note: We can not embed getULEB128 directly into function
173           // argument list. getULEB128 changes Offset and order of evaluation
174           // for arguments is unspecified.
175           auto op1 = Data.getULEB128(Offset);
176           auto op2 = Data.getULEB128(Offset);
177           addInstruction(Opcode, op1, op2);
178           break;
179         }
180         case DW_CFA_offset_extended_sf:
181         case DW_CFA_def_cfa_sf:
182         case DW_CFA_val_offset_sf: {
183           // Operands: ULEB128, SLEB128
184           // Note: see comment for the previous case
185           auto op1 = Data.getULEB128(Offset);
186           auto op2 = (uint64_t)Data.getSLEB128(Offset);
187           addInstruction(Opcode, op1, op2);
188           break;
189         }
190         case DW_CFA_def_cfa_expression:
191         case DW_CFA_expression:
192         case DW_CFA_val_expression:
193           // TODO: implement this
194           report_fatal_error("Values with expressions not implemented yet!");
195       }
196     }
197   }
198 }
199 
200 namespace {
201 
202 /// \brief DWARF Common Information Entry (CIE)
203 class CIE : public FrameEntry {
204 public:
205   // CIEs (and FDEs) are simply container classes, so the only sensible way to
206   // create them is by providing the full parsed contents in the constructor.
207   CIE(uint64_t Offset, uint64_t Length, uint8_t Version,
208       SmallString<8> Augmentation, uint8_t AddressSize,
209       uint8_t SegmentDescriptorSize, uint64_t CodeAlignmentFactor,
210       int64_t DataAlignmentFactor, uint64_t ReturnAddressRegister,
211       SmallString<8> AugmentationData, uint32_t FDEPointerEncoding,
212       uint32_t LSDAPointerEncoding)
213       : FrameEntry(FK_CIE, Offset, Length), Version(Version),
214         Augmentation(std::move(Augmentation)), AddressSize(AddressSize),
215         SegmentDescriptorSize(SegmentDescriptorSize),
216         CodeAlignmentFactor(CodeAlignmentFactor),
217         DataAlignmentFactor(DataAlignmentFactor),
218         ReturnAddressRegister(ReturnAddressRegister),
219         AugmentationData(std::move(AugmentationData)),
220         FDEPointerEncoding(FDEPointerEncoding),
221         LSDAPointerEncoding(LSDAPointerEncoding) {}
222 
223   ~CIE() override {}
224 
225   StringRef getAugmentationString() const { return Augmentation; }
226   uint64_t getCodeAlignmentFactor() const { return CodeAlignmentFactor; }
227   int64_t getDataAlignmentFactor() const { return DataAlignmentFactor; }
228 
229   uint32_t getFDEPointerEncoding() const {
230     return FDEPointerEncoding;
231   }
232 
233   uint32_t getLSDAPointerEncoding() const {
234     return LSDAPointerEncoding;
235   }
236 
237   void dumpHeader(raw_ostream &OS) const override {
238     OS << format("%08x %08x %08x CIE",
239                  (uint32_t)Offset, (uint32_t)Length, DW_CIE_ID)
240        << "\n";
241     OS << format("  Version:               %d\n", Version);
242     OS << "  Augmentation:          \"" << Augmentation << "\"\n";
243     if (Version >= 4) {
244       OS << format("  Address size:          %u\n",
245                    (uint32_t)AddressSize);
246       OS << format("  Segment desc size:     %u\n",
247                    (uint32_t)SegmentDescriptorSize);
248     }
249     OS << format("  Code alignment factor: %u\n",
250                  (uint32_t)CodeAlignmentFactor);
251     OS << format("  Data alignment factor: %d\n",
252                  (int32_t)DataAlignmentFactor);
253     OS << format("  Return address column: %d\n",
254                  (int32_t)ReturnAddressRegister);
255     if (!AugmentationData.empty()) {
256       OS << "  Augmentation data:    ";
257       for (uint8_t Byte : AugmentationData)
258         OS << ' ' << hexdigit(Byte >> 4) << hexdigit(Byte & 0xf);
259       OS << "\n";
260     }
261     OS << "\n";
262   }
263 
264   static bool classof(const FrameEntry *FE) {
265     return FE->getKind() == FK_CIE;
266   }
267 
268 private:
269   /// The following fields are defined in section 6.4.1 of the DWARF standard v4
270   uint8_t Version;
271   SmallString<8> Augmentation;
272   uint8_t AddressSize;
273   uint8_t SegmentDescriptorSize;
274   uint64_t CodeAlignmentFactor;
275   int64_t DataAlignmentFactor;
276   uint64_t ReturnAddressRegister;
277 
278   // The following are used when the CIE represents an EH frame entry.
279   SmallString<8> AugmentationData;
280   uint32_t FDEPointerEncoding;
281   uint32_t LSDAPointerEncoding;
282 };
283 
284 /// \brief DWARF Frame Description Entry (FDE)
285 class FDE : public FrameEntry {
286 public:
287   // Each FDE has a CIE it's "linked to". Our FDE contains is constructed with
288   // an offset to the CIE (provided by parsing the FDE header). The CIE itself
289   // is obtained lazily once it's actually required.
290   FDE(uint64_t Offset, uint64_t Length, int64_t LinkedCIEOffset,
291       uint64_t InitialLocation, uint64_t AddressRange,
292       CIE *Cie)
293       : FrameEntry(FK_FDE, Offset, Length), LinkedCIEOffset(LinkedCIEOffset),
294         InitialLocation(InitialLocation), AddressRange(AddressRange),
295         LinkedCIE(Cie) {}
296 
297   ~FDE() override {}
298 
299   CIE *getLinkedCIE() const { return LinkedCIE; }
300 
301   void dumpHeader(raw_ostream &OS) const override {
302     OS << format("%08x %08x %08x FDE ",
303                  (uint32_t)Offset, (uint32_t)Length, (int32_t)LinkedCIEOffset);
304     OS << format("cie=%08x pc=%08x...%08x\n",
305                  (int32_t)LinkedCIEOffset,
306                  (uint32_t)InitialLocation,
307                  (uint32_t)InitialLocation + (uint32_t)AddressRange);
308   }
309 
310   static bool classof(const FrameEntry *FE) {
311     return FE->getKind() == FK_FDE;
312   }
313 
314 private:
315   /// The following fields are defined in section 6.4.1 of the DWARF standard v3
316   uint64_t LinkedCIEOffset;
317   uint64_t InitialLocation;
318   uint64_t AddressRange;
319   CIE *LinkedCIE;
320 };
321 
322 /// \brief Types of operands to CF instructions.
323 enum OperandType {
324   OT_Unset,
325   OT_None,
326   OT_Address,
327   OT_Offset,
328   OT_FactoredCodeOffset,
329   OT_SignedFactDataOffset,
330   OT_UnsignedFactDataOffset,
331   OT_Register,
332   OT_Expression
333 };
334 
335 } // end anonymous namespace
336 
337 /// \brief Initialize the array describing the types of operands.
338 static ArrayRef<OperandType[2]> getOperandTypes() {
339   static OperandType OpTypes[DW_CFA_restore+1][2];
340 
341 #define DECLARE_OP2(OP, OPTYPE0, OPTYPE1)       \
342   do {                                          \
343     OpTypes[OP][0] = OPTYPE0;                   \
344     OpTypes[OP][1] = OPTYPE1;                   \
345   } while (false)
346 #define DECLARE_OP1(OP, OPTYPE0) DECLARE_OP2(OP, OPTYPE0, OT_None)
347 #define DECLARE_OP0(OP) DECLARE_OP1(OP, OT_None)
348 
349   DECLARE_OP1(DW_CFA_set_loc, OT_Address);
350   DECLARE_OP1(DW_CFA_advance_loc, OT_FactoredCodeOffset);
351   DECLARE_OP1(DW_CFA_advance_loc1, OT_FactoredCodeOffset);
352   DECLARE_OP1(DW_CFA_advance_loc2, OT_FactoredCodeOffset);
353   DECLARE_OP1(DW_CFA_advance_loc4, OT_FactoredCodeOffset);
354   DECLARE_OP1(DW_CFA_MIPS_advance_loc8, OT_FactoredCodeOffset);
355   DECLARE_OP2(DW_CFA_def_cfa, OT_Register, OT_Offset);
356   DECLARE_OP2(DW_CFA_def_cfa_sf, OT_Register, OT_SignedFactDataOffset);
357   DECLARE_OP1(DW_CFA_def_cfa_register, OT_Register);
358   DECLARE_OP1(DW_CFA_def_cfa_offset, OT_Offset);
359   DECLARE_OP1(DW_CFA_def_cfa_offset_sf, OT_SignedFactDataOffset);
360   DECLARE_OP1(DW_CFA_def_cfa_expression, OT_Expression);
361   DECLARE_OP1(DW_CFA_undefined, OT_Register);
362   DECLARE_OP1(DW_CFA_same_value, OT_Register);
363   DECLARE_OP2(DW_CFA_offset, OT_Register, OT_UnsignedFactDataOffset);
364   DECLARE_OP2(DW_CFA_offset_extended, OT_Register, OT_UnsignedFactDataOffset);
365   DECLARE_OP2(DW_CFA_offset_extended_sf, OT_Register, OT_SignedFactDataOffset);
366   DECLARE_OP2(DW_CFA_val_offset, OT_Register, OT_UnsignedFactDataOffset);
367   DECLARE_OP2(DW_CFA_val_offset_sf, OT_Register, OT_SignedFactDataOffset);
368   DECLARE_OP2(DW_CFA_register, OT_Register, OT_Register);
369   DECLARE_OP2(DW_CFA_expression, OT_Register, OT_Expression);
370   DECLARE_OP2(DW_CFA_val_expression, OT_Register, OT_Expression);
371   DECLARE_OP1(DW_CFA_restore, OT_Register);
372   DECLARE_OP1(DW_CFA_restore_extended, OT_Register);
373   DECLARE_OP0(DW_CFA_remember_state);
374   DECLARE_OP0(DW_CFA_restore_state);
375   DECLARE_OP0(DW_CFA_GNU_window_save);
376   DECLARE_OP1(DW_CFA_GNU_args_size, OT_Offset);
377   DECLARE_OP0(DW_CFA_nop);
378 
379 #undef DECLARE_OP0
380 #undef DECLARE_OP1
381 #undef DECLARE_OP2
382 
383   return ArrayRef<OperandType[2]>(&OpTypes[0], DW_CFA_restore+1);
384 }
385 
386 static ArrayRef<OperandType[2]> OpTypes = getOperandTypes();
387 
388 /// \brief Print \p Opcode's operand number \p OperandIdx which has
389 /// value \p Operand.
390 static void printOperand(raw_ostream &OS, uint8_t Opcode, unsigned OperandIdx,
391                          uint64_t Operand, uint64_t CodeAlignmentFactor,
392                          int64_t DataAlignmentFactor) {
393   assert(OperandIdx < 2);
394   OperandType Type = OpTypes[Opcode][OperandIdx];
395 
396   switch (Type) {
397   case OT_Unset: {
398     OS << " Unsupported " << (OperandIdx ? "second" : "first") << " operand to";
399     auto OpcodeName = CallFrameString(Opcode);
400     if (!OpcodeName.empty())
401       OS << " " << OpcodeName;
402     else
403       OS << format(" Opcode %x",  Opcode);
404     break;
405   }
406   case OT_None:
407     break;
408   case OT_Address:
409     OS << format(" %" PRIx64, Operand);
410     break;
411   case OT_Offset:
412     // The offsets are all encoded in a unsigned form, but in practice
413     // consumers use them signed. It's most certainly legacy due to
414     // the lack of signed variants in the first Dwarf standards.
415     OS << format(" %+" PRId64, int64_t(Operand));
416     break;
417   case OT_FactoredCodeOffset: // Always Unsigned
418     if (CodeAlignmentFactor)
419       OS << format(" %" PRId64, Operand * CodeAlignmentFactor);
420     else
421       OS << format(" %" PRId64 "*code_alignment_factor" , Operand);
422     break;
423   case OT_SignedFactDataOffset:
424     if (DataAlignmentFactor)
425       OS << format(" %" PRId64, int64_t(Operand) * DataAlignmentFactor);
426     else
427       OS << format(" %" PRId64 "*data_alignment_factor" , int64_t(Operand));
428     break;
429   case OT_UnsignedFactDataOffset:
430     if (DataAlignmentFactor)
431       OS << format(" %" PRId64, Operand * DataAlignmentFactor);
432     else
433       OS << format(" %" PRId64 "*data_alignment_factor" , Operand);
434     break;
435   case OT_Register:
436     OS << format(" reg%" PRId64, Operand);
437     break;
438   case OT_Expression:
439     OS << " expression";
440     break;
441   }
442 }
443 
444 void FrameEntry::dumpInstructions(raw_ostream &OS) const {
445   uint64_t CodeAlignmentFactor = 0;
446   int64_t DataAlignmentFactor = 0;
447   const CIE *Cie = dyn_cast<CIE>(this);
448 
449   if (!Cie)
450     Cie = cast<FDE>(this)->getLinkedCIE();
451   if (Cie) {
452     CodeAlignmentFactor = Cie->getCodeAlignmentFactor();
453     DataAlignmentFactor = Cie->getDataAlignmentFactor();
454   }
455 
456   for (const auto &Instr : Instructions) {
457     uint8_t Opcode = Instr.Opcode;
458     if (Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK)
459       Opcode &= DWARF_CFI_PRIMARY_OPCODE_MASK;
460     OS << "  " << CallFrameString(Opcode) << ":";
461     for (unsigned i = 0; i < Instr.Ops.size(); ++i)
462       printOperand(OS, Opcode, i, Instr.Ops[i], CodeAlignmentFactor,
463                    DataAlignmentFactor);
464     OS << '\n';
465   }
466 }
467 
468 DWARFDebugFrame::DWARFDebugFrame(bool IsEH) : IsEH(IsEH) {
469 }
470 
471 DWARFDebugFrame::~DWARFDebugFrame() {
472 }
473 
474 static void LLVM_ATTRIBUTE_UNUSED dumpDataAux(DataExtractor Data,
475                                               uint32_t Offset, int Length) {
476   errs() << "DUMP: ";
477   for (int i = 0; i < Length; ++i) {
478     uint8_t c = Data.getU8(&Offset);
479     errs().write_hex(c); errs() << " ";
480   }
481   errs() << "\n";
482 }
483 
484 static unsigned getSizeForEncoding(const DataExtractor &Data,
485                                    unsigned symbolEncoding) {
486   unsigned format = symbolEncoding & 0x0f;
487   switch (format) {
488     default: llvm_unreachable("Unknown Encoding");
489     case dwarf::DW_EH_PE_absptr:
490     case dwarf::DW_EH_PE_signed:
491       return Data.getAddressSize();
492     case dwarf::DW_EH_PE_udata2:
493     case dwarf::DW_EH_PE_sdata2:
494       return 2;
495     case dwarf::DW_EH_PE_udata4:
496     case dwarf::DW_EH_PE_sdata4:
497       return 4;
498     case dwarf::DW_EH_PE_udata8:
499     case dwarf::DW_EH_PE_sdata8:
500       return 8;
501   }
502 }
503 
504 static uint64_t readPointer(const DataExtractor &Data, uint32_t &Offset,
505                             unsigned Encoding) {
506   switch (getSizeForEncoding(Data, Encoding)) {
507     case 2:
508       return Data.getU16(&Offset);
509     case 4:
510       return Data.getU32(&Offset);
511     case 8:
512       return Data.getU64(&Offset);
513     default:
514       llvm_unreachable("Illegal data size");
515   }
516 }
517 
518 void DWARFDebugFrame::parse(DataExtractor Data) {
519   uint32_t Offset = 0;
520   DenseMap<uint32_t, CIE *> CIEs;
521 
522   while (Data.isValidOffset(Offset)) {
523     uint32_t StartOffset = Offset;
524 
525     auto ReportError = [StartOffset](const char *ErrorMsg) {
526       std::string Str;
527       raw_string_ostream OS(Str);
528       OS << format(ErrorMsg, StartOffset);
529       OS.flush();
530       report_fatal_error(Str);
531     };
532 
533     bool IsDWARF64 = false;
534     uint64_t Length = Data.getU32(&Offset);
535     uint64_t Id;
536 
537     if (Length == UINT32_MAX) {
538       // DWARF-64 is distinguished by the first 32 bits of the initial length
539       // field being 0xffffffff. Then, the next 64 bits are the actual entry
540       // length.
541       IsDWARF64 = true;
542       Length = Data.getU64(&Offset);
543     }
544 
545     // At this point, Offset points to the next field after Length.
546     // Length is the structure size excluding itself. Compute an offset one
547     // past the end of the structure (needed to know how many instructions to
548     // read).
549     // TODO: For honest DWARF64 support, DataExtractor will have to treat
550     //       offset_ptr as uint64_t*
551     uint32_t StartStructureOffset = Offset;
552     uint32_t EndStructureOffset = Offset + static_cast<uint32_t>(Length);
553 
554     // The Id field's size depends on the DWARF format
555     Id = Data.getUnsigned(&Offset, (IsDWARF64 && !IsEH) ? 8 : 4);
556     bool IsCIE = ((IsDWARF64 && Id == DW64_CIE_ID) ||
557                   Id == DW_CIE_ID ||
558                   (IsEH && !Id));
559 
560     if (IsCIE) {
561       uint8_t Version = Data.getU8(&Offset);
562       const char *Augmentation = Data.getCStr(&Offset);
563       StringRef AugmentationString(Augmentation ? Augmentation : "");
564       uint8_t AddressSize = Version < 4 ? Data.getAddressSize() :
565                                           Data.getU8(&Offset);
566       Data.setAddressSize(AddressSize);
567       uint8_t SegmentDescriptorSize = Version < 4 ? 0 : Data.getU8(&Offset);
568       uint64_t CodeAlignmentFactor = Data.getULEB128(&Offset);
569       int64_t DataAlignmentFactor = Data.getSLEB128(&Offset);
570       uint64_t ReturnAddressRegister = Data.getULEB128(&Offset);
571 
572       // Parse the augmentation data for EH CIEs
573       StringRef AugmentationData("");
574       uint32_t FDEPointerEncoding = DW_EH_PE_omit;
575       uint32_t LSDAPointerEncoding = DW_EH_PE_omit;
576       if (IsEH) {
577         Optional<uint32_t> PersonalityEncoding;
578         Optional<uint64_t> Personality;
579 
580         Optional<uint64_t> AugmentationLength;
581         uint32_t StartAugmentationOffset;
582         uint32_t EndAugmentationOffset;
583 
584         // Walk the augmentation string to get all the augmentation data.
585         for (unsigned i = 0, e = AugmentationString.size(); i != e; ++i) {
586           switch (AugmentationString[i]) {
587             default:
588               ReportError("Unknown augmentation character in entry at %lx");
589             case 'L':
590               LSDAPointerEncoding = Data.getU8(&Offset);
591               break;
592             case 'P': {
593               if (Personality)
594                 ReportError("Duplicate personality in entry at %lx");
595               PersonalityEncoding = Data.getU8(&Offset);
596               Personality = readPointer(Data, Offset, *PersonalityEncoding);
597               break;
598             }
599             case 'R':
600               FDEPointerEncoding = Data.getU8(&Offset);
601               break;
602             case 'z':
603               if (i)
604                 ReportError("'z' must be the first character at %lx");
605               // Parse the augmentation length first.  We only parse it if
606               // the string contains a 'z'.
607               AugmentationLength = Data.getULEB128(&Offset);
608               StartAugmentationOffset = Offset;
609               EndAugmentationOffset = Offset +
610                 static_cast<uint32_t>(*AugmentationLength);
611           }
612         }
613 
614         if (AugmentationLength.hasValue()) {
615           if (Offset != EndAugmentationOffset)
616             ReportError("Parsing augmentation data at %lx failed");
617 
618           AugmentationData = Data.getData().slice(StartAugmentationOffset,
619                                                   EndAugmentationOffset);
620         }
621       }
622 
623       auto Cie = make_unique<CIE>(StartOffset, Length, Version,
624                                   AugmentationString, AddressSize,
625                                   SegmentDescriptorSize, CodeAlignmentFactor,
626                                   DataAlignmentFactor, ReturnAddressRegister,
627                                   AugmentationData, FDEPointerEncoding,
628                                   LSDAPointerEncoding);
629       CIEs[StartOffset] = Cie.get();
630       Entries.emplace_back(std::move(Cie));
631     } else {
632       // FDE
633       uint64_t CIEPointer = Id;
634       uint64_t InitialLocation = 0;
635       uint64_t AddressRange = 0;
636       CIE *Cie = CIEs[IsEH ? (StartStructureOffset - CIEPointer) : CIEPointer];
637 
638       if (IsEH) {
639         // The address size is encoded in the CIE we reference.
640         if (!Cie)
641           ReportError("Parsing FDE data at %lx failed due to missing CIE");
642 
643         InitialLocation = readPointer(Data, Offset,
644                                       Cie->getFDEPointerEncoding());
645         AddressRange = readPointer(Data, Offset,
646                                    Cie->getFDEPointerEncoding());
647 
648         StringRef AugmentationString = Cie->getAugmentationString();
649         if (!AugmentationString.empty()) {
650           // Parse the augmentation length and data for this FDE.
651           uint64_t AugmentationLength = Data.getULEB128(&Offset);
652 
653           uint32_t EndAugmentationOffset =
654             Offset + static_cast<uint32_t>(AugmentationLength);
655 
656           // Decode the LSDA if the CIE augmentation string said we should.
657           if (Cie->getLSDAPointerEncoding() != DW_EH_PE_omit)
658             readPointer(Data, Offset, Cie->getLSDAPointerEncoding());
659 
660           if (Offset != EndAugmentationOffset)
661             ReportError("Parsing augmentation data at %lx failed");
662         }
663       } else {
664         InitialLocation = Data.getAddress(&Offset);
665         AddressRange = Data.getAddress(&Offset);
666       }
667 
668       Entries.emplace_back(new FDE(StartOffset, Length, CIEPointer,
669                                    InitialLocation, AddressRange,
670                                    Cie));
671     }
672 
673     Entries.back()->parseInstructions(Data, &Offset, EndStructureOffset);
674 
675     if (Offset != EndStructureOffset)
676       ReportError("Parsing entry instructions at %lx failed");
677   }
678 }
679 
680 void DWARFDebugFrame::dump(raw_ostream &OS) const {
681   OS << "\n";
682   for (const auto &Entry : Entries) {
683     Entry->dumpHeader(OS);
684     Entry->dumpInstructions(OS);
685     OS << "\n";
686   }
687 }
688