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 if (const char *OpcodeName = CallFrameString(Opcode)) 400 OS << " " << OpcodeName; 401 else 402 OS << format(" Opcode %x", Opcode); 403 break; 404 case OT_None: 405 break; 406 case OT_Address: 407 OS << format(" %" PRIx64, Operand); 408 break; 409 case OT_Offset: 410 // The offsets are all encoded in a unsigned form, but in practice 411 // consumers use them signed. It's most certainly legacy due to 412 // the lack of signed variants in the first Dwarf standards. 413 OS << format(" %+" PRId64, int64_t(Operand)); 414 break; 415 case OT_FactoredCodeOffset: // Always Unsigned 416 if (CodeAlignmentFactor) 417 OS << format(" %" PRId64, Operand * CodeAlignmentFactor); 418 else 419 OS << format(" %" PRId64 "*code_alignment_factor" , Operand); 420 break; 421 case OT_SignedFactDataOffset: 422 if (DataAlignmentFactor) 423 OS << format(" %" PRId64, int64_t(Operand) * DataAlignmentFactor); 424 else 425 OS << format(" %" PRId64 "*data_alignment_factor" , int64_t(Operand)); 426 break; 427 case OT_UnsignedFactDataOffset: 428 if (DataAlignmentFactor) 429 OS << format(" %" PRId64, Operand * DataAlignmentFactor); 430 else 431 OS << format(" %" PRId64 "*data_alignment_factor" , Operand); 432 break; 433 case OT_Register: 434 OS << format(" reg%" PRId64, Operand); 435 break; 436 case OT_Expression: 437 OS << " expression"; 438 break; 439 } 440 } 441 442 void FrameEntry::dumpInstructions(raw_ostream &OS) const { 443 uint64_t CodeAlignmentFactor = 0; 444 int64_t DataAlignmentFactor = 0; 445 const CIE *Cie = dyn_cast<CIE>(this); 446 447 if (!Cie) 448 Cie = cast<FDE>(this)->getLinkedCIE(); 449 if (Cie) { 450 CodeAlignmentFactor = Cie->getCodeAlignmentFactor(); 451 DataAlignmentFactor = Cie->getDataAlignmentFactor(); 452 } 453 454 for (const auto &Instr : Instructions) { 455 uint8_t Opcode = Instr.Opcode; 456 if (Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK) 457 Opcode &= DWARF_CFI_PRIMARY_OPCODE_MASK; 458 OS << " " << CallFrameString(Opcode) << ":"; 459 for (unsigned i = 0; i < Instr.Ops.size(); ++i) 460 printOperand(OS, Opcode, i, Instr.Ops[i], CodeAlignmentFactor, 461 DataAlignmentFactor); 462 OS << '\n'; 463 } 464 } 465 466 DWARFDebugFrame::DWARFDebugFrame(bool IsEH) : IsEH(IsEH) { 467 } 468 469 DWARFDebugFrame::~DWARFDebugFrame() { 470 } 471 472 static void LLVM_ATTRIBUTE_UNUSED dumpDataAux(DataExtractor Data, 473 uint32_t Offset, int Length) { 474 errs() << "DUMP: "; 475 for (int i = 0; i < Length; ++i) { 476 uint8_t c = Data.getU8(&Offset); 477 errs().write_hex(c); errs() << " "; 478 } 479 errs() << "\n"; 480 } 481 482 static unsigned getSizeForEncoding(const DataExtractor &Data, 483 unsigned symbolEncoding) { 484 unsigned format = symbolEncoding & 0x0f; 485 switch (format) { 486 default: llvm_unreachable("Unknown Encoding"); 487 case dwarf::DW_EH_PE_absptr: 488 case dwarf::DW_EH_PE_signed: 489 return Data.getAddressSize(); 490 case dwarf::DW_EH_PE_udata2: 491 case dwarf::DW_EH_PE_sdata2: 492 return 2; 493 case dwarf::DW_EH_PE_udata4: 494 case dwarf::DW_EH_PE_sdata4: 495 return 4; 496 case dwarf::DW_EH_PE_udata8: 497 case dwarf::DW_EH_PE_sdata8: 498 return 8; 499 } 500 } 501 502 static uint64_t readPointer(const DataExtractor &Data, uint32_t &Offset, 503 unsigned Encoding) { 504 switch (getSizeForEncoding(Data, Encoding)) { 505 case 2: 506 return Data.getU16(&Offset); 507 case 4: 508 return Data.getU32(&Offset); 509 case 8: 510 return Data.getU64(&Offset); 511 default: 512 llvm_unreachable("Illegal data size"); 513 } 514 } 515 516 void DWARFDebugFrame::parse(DataExtractor Data) { 517 uint32_t Offset = 0; 518 DenseMap<uint32_t, CIE *> CIEs; 519 520 while (Data.isValidOffset(Offset)) { 521 uint32_t StartOffset = Offset; 522 523 auto ReportError = [StartOffset](const char *ErrorMsg) { 524 std::string Str; 525 raw_string_ostream OS(Str); 526 OS << format(ErrorMsg, StartOffset); 527 OS.flush(); 528 report_fatal_error(Str); 529 }; 530 531 bool IsDWARF64 = false; 532 uint64_t Length = Data.getU32(&Offset); 533 uint64_t Id; 534 535 if (Length == UINT32_MAX) { 536 // DWARF-64 is distinguished by the first 32 bits of the initial length 537 // field being 0xffffffff. Then, the next 64 bits are the actual entry 538 // length. 539 IsDWARF64 = true; 540 Length = Data.getU64(&Offset); 541 } 542 543 // At this point, Offset points to the next field after Length. 544 // Length is the structure size excluding itself. Compute an offset one 545 // past the end of the structure (needed to know how many instructions to 546 // read). 547 // TODO: For honest DWARF64 support, DataExtractor will have to treat 548 // offset_ptr as uint64_t* 549 uint32_t StartStructureOffset = Offset; 550 uint32_t EndStructureOffset = Offset + static_cast<uint32_t>(Length); 551 552 // The Id field's size depends on the DWARF format 553 Id = Data.getUnsigned(&Offset, (IsDWARF64 && !IsEH) ? 8 : 4); 554 bool IsCIE = ((IsDWARF64 && Id == DW64_CIE_ID) || 555 Id == DW_CIE_ID || 556 (IsEH && !Id)); 557 558 if (IsCIE) { 559 uint8_t Version = Data.getU8(&Offset); 560 const char *Augmentation = Data.getCStr(&Offset); 561 StringRef AugmentationString(Augmentation ? Augmentation : ""); 562 uint8_t AddressSize = Version < 4 ? Data.getAddressSize() : 563 Data.getU8(&Offset); 564 Data.setAddressSize(AddressSize); 565 uint8_t SegmentDescriptorSize = Version < 4 ? 0 : Data.getU8(&Offset); 566 uint64_t CodeAlignmentFactor = Data.getULEB128(&Offset); 567 int64_t DataAlignmentFactor = Data.getSLEB128(&Offset); 568 uint64_t ReturnAddressRegister = Data.getULEB128(&Offset); 569 570 // Parse the augmentation data for EH CIEs 571 StringRef AugmentationData(""); 572 uint32_t FDEPointerEncoding = DW_EH_PE_omit; 573 uint32_t LSDAPointerEncoding = DW_EH_PE_omit; 574 if (IsEH) { 575 Optional<uint32_t> PersonalityEncoding; 576 Optional<uint64_t> Personality; 577 578 Optional<uint64_t> AugmentationLength; 579 uint32_t StartAugmentationOffset; 580 uint32_t EndAugmentationOffset; 581 582 // Walk the augmentation string to get all the augmentation data. 583 for (unsigned i = 0, e = AugmentationString.size(); i != e; ++i) { 584 switch (AugmentationString[i]) { 585 default: 586 ReportError("Unknown augmentation character in entry at %lx"); 587 case 'L': 588 LSDAPointerEncoding = Data.getU8(&Offset); 589 break; 590 case 'P': { 591 if (Personality) 592 ReportError("Duplicate personality in entry at %lx"); 593 PersonalityEncoding = Data.getU8(&Offset); 594 Personality = readPointer(Data, Offset, *PersonalityEncoding); 595 break; 596 } 597 case 'R': 598 FDEPointerEncoding = Data.getU8(&Offset); 599 break; 600 case 'z': 601 if (i) 602 ReportError("'z' must be the first character at %lx"); 603 // Parse the augmentation length first. We only parse it if 604 // the string contains a 'z'. 605 AugmentationLength = Data.getULEB128(&Offset); 606 StartAugmentationOffset = Offset; 607 EndAugmentationOffset = Offset + 608 static_cast<uint32_t>(*AugmentationLength); 609 } 610 } 611 612 if (AugmentationLength.hasValue()) { 613 if (Offset != EndAugmentationOffset) 614 ReportError("Parsing augmentation data at %lx failed"); 615 616 AugmentationData = Data.getData().slice(StartAugmentationOffset, 617 EndAugmentationOffset); 618 } 619 } 620 621 auto Cie = make_unique<CIE>(StartOffset, Length, Version, 622 AugmentationString, AddressSize, 623 SegmentDescriptorSize, CodeAlignmentFactor, 624 DataAlignmentFactor, ReturnAddressRegister, 625 AugmentationData, FDEPointerEncoding, 626 LSDAPointerEncoding); 627 CIEs[StartOffset] = Cie.get(); 628 Entries.emplace_back(std::move(Cie)); 629 } else { 630 // FDE 631 uint64_t CIEPointer = Id; 632 uint64_t InitialLocation = 0; 633 uint64_t AddressRange = 0; 634 CIE *Cie = CIEs[IsEH ? (StartStructureOffset - CIEPointer) : CIEPointer]; 635 636 if (IsEH) { 637 // The address size is encoded in the CIE we reference. 638 if (!Cie) 639 ReportError("Parsing FDE data at %lx failed due to missing CIE"); 640 641 InitialLocation = readPointer(Data, Offset, 642 Cie->getFDEPointerEncoding()); 643 AddressRange = readPointer(Data, Offset, 644 Cie->getFDEPointerEncoding()); 645 646 StringRef AugmentationString = Cie->getAugmentationString(); 647 if (!AugmentationString.empty()) { 648 // Parse the augmentation length and data for this FDE. 649 uint64_t AugmentationLength = Data.getULEB128(&Offset); 650 651 uint32_t EndAugmentationOffset = 652 Offset + static_cast<uint32_t>(AugmentationLength); 653 654 // Decode the LSDA if the CIE augmentation string said we should. 655 if (Cie->getLSDAPointerEncoding() != DW_EH_PE_omit) 656 readPointer(Data, Offset, Cie->getLSDAPointerEncoding()); 657 658 if (Offset != EndAugmentationOffset) 659 ReportError("Parsing augmentation data at %lx failed"); 660 } 661 } else { 662 InitialLocation = Data.getAddress(&Offset); 663 AddressRange = Data.getAddress(&Offset); 664 } 665 666 Entries.emplace_back(new FDE(StartOffset, Length, CIEPointer, 667 InitialLocation, AddressRange, 668 Cie)); 669 } 670 671 Entries.back()->parseInstructions(Data, &Offset, EndStructureOffset); 672 673 if (Offset != EndStructureOffset) 674 ReportError("Parsing entry instructions at %lx failed"); 675 } 676 } 677 678 void DWARFDebugFrame::dump(raw_ostream &OS) const { 679 OS << "\n"; 680 for (const auto &Entry : Entries) { 681 Entry->dumpHeader(OS); 682 Entry->dumpInstructions(OS); 683 OS << "\n"; 684 } 685 } 686