lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

   1 //===- DWARFDebugFrame.h - Parsing of .debug_frame ------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
  10 #include "llvm/ADT/DenseMap.h"
  11 #include "llvm/ADT/Optional.h"
  12 #include "llvm/ADT/StringExtras.h"
  13 #include "llvm/ADT/StringRef.h"
  14 #include "llvm/BinaryFormat/Dwarf.h"
  15 #include "llvm/Support/Casting.h"
  16 #include "llvm/Support/Compiler.h"
  17 #include "llvm/Support/DataExtractor.h"
  18 #include "llvm/Support/Errc.h"
  19 #include "llvm/Support/ErrorHandling.h"
  20 #include "llvm/Support/Format.h"
  21 #include "llvm/Support/raw_ostream.h"
  22 #include <algorithm>
  23 #include <cassert>
  24 #include <cinttypes>
  25 #include <cstdint>
  26 #include <string>
  27 #include <vector>
  28
  29 using namespace llvm;
  30 using namespace dwarf;
  31
  32
  33 // See DWARF standard v3, section 7.23
  34 const uint8_t DWARF_CFI_PRIMARY_OPCODE_MASK = 0xc0;
  35 const uint8_t DWARF_CFI_PRIMARY_OPERAND_MASK = 0x3f;
  36
  37 Error CFIProgram::parse(DataExtractor Data, uint32_t *Offset,
  38                         uint32_t EndOffset) {
  39   while (*Offset < EndOffset) {
  40     uint8_t Opcode = Data.getU8(Offset);
  41     // Some instructions have a primary opcode encoded in the top bits.
  42     uint8_t Primary = Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK;
  43
  44     if (Primary) {
  45       // If it's a primary opcode, the first operand is encoded in the bottom
  46       // bits of the opcode itself.
  47       uint64_t Op1 = Opcode & DWARF_CFI_PRIMARY_OPERAND_MASK;
  48       switch (Primary) {
  49       default:
  50         return createStringError(errc::illegal_byte_sequence,
  51                                  "Invalid primary CFI opcode 0x%" PRIx8,
  52                                  Primary);
  53       case DW_CFA_advance_loc:
  54       case DW_CFA_restore:
  55         addInstruction(Primary, Op1);
  56         break;
  57       case DW_CFA_offset:
  58         addInstruction(Primary, Op1, Data.getULEB128(Offset));
  59         break;
  60       }
  61     } else {
  62       // Extended opcode - its value is Opcode itself.
  63       switch (Opcode) {
  64       default:
  65         return createStringError(errc::illegal_byte_sequence,
  66                                  "Invalid extended CFI opcode 0x%" PRIx8,
  67                                  Opcode);
  68       case DW_CFA_nop:
  69       case DW_CFA_remember_state:
  70       case DW_CFA_restore_state:
  71       case DW_CFA_GNU_window_save:
  72         // No operands
  73         addInstruction(Opcode);
  74         break;
  75       case DW_CFA_set_loc:
  76         // Operands: Address
  77         addInstruction(Opcode, Data.getAddress(Offset));
  78         break;
  79       case DW_CFA_advance_loc1:
  80         // Operands: 1-byte delta
  81         addInstruction(Opcode, Data.getU8(Offset));
  82         break;
  83       case DW_CFA_advance_loc2:
  84         // Operands: 2-byte delta
  85         addInstruction(Opcode, Data.getU16(Offset));
  86         break;
  87       case DW_CFA_advance_loc4:
  88         // Operands: 4-byte delta
  89         addInstruction(Opcode, Data.getU32(Offset));
  90         break;
  91       case DW_CFA_restore_extended:
  92       case DW_CFA_undefined:
  93       case DW_CFA_same_value:
  94       case DW_CFA_def_cfa_register:
  95       case DW_CFA_def_cfa_offset:
  96       case DW_CFA_GNU_args_size:
  97         // Operands: ULEB128
  98         addInstruction(Opcode, Data.getULEB128(Offset));
  99         break;
 100       case DW_CFA_def_cfa_offset_sf:
 101         // Operands: SLEB128
 102         addInstruction(Opcode, Data.getSLEB128(Offset));
 103         break;
 104       case DW_CFA_offset_extended:
 105       case DW_CFA_register:
 106       case DW_CFA_def_cfa:
 107       case DW_CFA_val_offset: {
 108         // Operands: ULEB128, ULEB128
 109         // Note: We can not embed getULEB128 directly into function
 110         // argument list. getULEB128 changes Offset and order of evaluation
 111         // for arguments is unspecified.
 112         auto op1 = Data.getULEB128(Offset);
 113         auto op2 = Data.getULEB128(Offset);
 114         addInstruction(Opcode, op1, op2);
 115         break;
 116         }
 117         case DW_CFA_offset_extended_sf:
 118         case DW_CFA_def_cfa_sf:
 119         case DW_CFA_val_offset_sf: {
 120           // Operands: ULEB128, SLEB128
 121           // Note: see comment for the previous case
 122           auto op1 = Data.getULEB128(Offset);
 123           auto op2 = (uint64_t)Data.getSLEB128(Offset);
 124           addInstruction(Opcode, op1, op2);
 125           break;
 126         }
 127         case DW_CFA_def_cfa_expression: {
 128           uint32_t ExprLength = Data.getULEB128(Offset);
 129           addInstruction(Opcode, 0);
 130           DataExtractor Extractor(
 131               Data.getData().slice(*Offset, *Offset + ExprLength),
 132               Data.isLittleEndian(), Data.getAddressSize());
 133           Instructions.back().Expression = DWARFExpression(
 134               Extractor, Data.getAddressSize(), dwarf::DWARF_VERSION);
 135           *Offset += ExprLength;
 136           break;
 137         }
 138         case DW_CFA_expression:
 139         case DW_CFA_val_expression: {
 140           auto RegNum = Data.getULEB128(Offset);
 141           auto BlockLength = Data.getULEB128(Offset);
 142           addInstruction(Opcode, RegNum, 0);
 143           DataExtractor Extractor(
 144               Data.getData().slice(*Offset, *Offset + BlockLength),
 145               Data.isLittleEndian(), Data.getAddressSize());
 146           Instructions.back().Expression = DWARFExpression(
 147               Extractor, Data.getAddressSize(), dwarf::DWARF_VERSION);
 148           *Offset += BlockLength;
 149           break;
 150         }
 151       }
 152     }
 153   }
 154
 155   return Error::success();
 156 }
 157
 158 namespace {
 159
 160
 161 } // end anonymous namespace
 162
 163 ArrayRef<CFIProgram::OperandType[2]> CFIProgram::getOperandTypes() {
 164   static OperandType OpTypes[DW_CFA_restore+1][2];
 165   static bool Initialized = false;
 166   if (Initialized) {
 167     return ArrayRef<OperandType[2]>(&OpTypes[0], DW_CFA_restore+1);
 168   }
 169   Initialized = true;
 170
 171 #define DECLARE_OP2(OP, OPTYPE0, OPTYPE1)       \
 172   do {                                          \
 173     OpTypes[OP][0] = OPTYPE0;                   \
 174     OpTypes[OP][1] = OPTYPE1;                   \
 175   } while (false)
 176 #define DECLARE_OP1(OP, OPTYPE0) DECLARE_OP2(OP, OPTYPE0, OT_None)
 177 #define DECLARE_OP0(OP) DECLARE_OP1(OP, OT_None)
 178
 179   DECLARE_OP1(DW_CFA_set_loc, OT_Address);
 180   DECLARE_OP1(DW_CFA_advance_loc, OT_FactoredCodeOffset);
 181   DECLARE_OP1(DW_CFA_advance_loc1, OT_FactoredCodeOffset);
 182   DECLARE_OP1(DW_CFA_advance_loc2, OT_FactoredCodeOffset);
 183   DECLARE_OP1(DW_CFA_advance_loc4, OT_FactoredCodeOffset);
 184   DECLARE_OP1(DW_CFA_MIPS_advance_loc8, OT_FactoredCodeOffset);
 185   DECLARE_OP2(DW_CFA_def_cfa, OT_Register, OT_Offset);
 186   DECLARE_OP2(DW_CFA_def_cfa_sf, OT_Register, OT_SignedFactDataOffset);
 187   DECLARE_OP1(DW_CFA_def_cfa_register, OT_Register);
 188   DECLARE_OP1(DW_CFA_def_cfa_offset, OT_Offset);
 189   DECLARE_OP1(DW_CFA_def_cfa_offset_sf, OT_SignedFactDataOffset);
 190   DECLARE_OP1(DW_CFA_def_cfa_expression, OT_Expression);
 191   DECLARE_OP1(DW_CFA_undefined, OT_Register);
 192   DECLARE_OP1(DW_CFA_same_value, OT_Register);
 193   DECLARE_OP2(DW_CFA_offset, OT_Register, OT_UnsignedFactDataOffset);
 194   DECLARE_OP2(DW_CFA_offset_extended, OT_Register, OT_UnsignedFactDataOffset);
 195   DECLARE_OP2(DW_CFA_offset_extended_sf, OT_Register, OT_SignedFactDataOffset);
 196   DECLARE_OP2(DW_CFA_val_offset, OT_Register, OT_UnsignedFactDataOffset);
 197   DECLARE_OP2(DW_CFA_val_offset_sf, OT_Register, OT_SignedFactDataOffset);
 198   DECLARE_OP2(DW_CFA_register, OT_Register, OT_Register);
 199   DECLARE_OP2(DW_CFA_expression, OT_Register, OT_Expression);
 200   DECLARE_OP2(DW_CFA_val_expression, OT_Register, OT_Expression);
 201   DECLARE_OP1(DW_CFA_restore, OT_Register);
 202   DECLARE_OP1(DW_CFA_restore_extended, OT_Register);
 203   DECLARE_OP0(DW_CFA_remember_state);
 204   DECLARE_OP0(DW_CFA_restore_state);
 205   DECLARE_OP0(DW_CFA_GNU_window_save);
 206   DECLARE_OP1(DW_CFA_GNU_args_size, OT_Offset);
 207   DECLARE_OP0(DW_CFA_nop);
 208
 209 #undef DECLARE_OP0
 210 #undef DECLARE_OP1
 211 #undef DECLARE_OP2
 212
 213   return ArrayRef<OperandType[2]>(&OpTypes[0], DW_CFA_restore+1);
 214 }
 215
 216 /// Print \p Opcode's operand number \p OperandIdx which has value \p Operand.
 217 void CFIProgram::printOperand(raw_ostream &OS, const MCRegisterInfo *MRI,
 218                               bool IsEH, const Instruction &Instr,
 219                               unsigned OperandIdx, uint64_t Operand) const {
 220   assert(OperandIdx < 2);
 221   uint8_t Opcode = Instr.Opcode;
 222   OperandType Type = getOperandTypes()[Opcode][OperandIdx];
 223
 224   switch (Type) {
 225   case OT_Unset: {
 226     OS << " Unsupported " << (OperandIdx ? "second" : "first") << " operand to";
 227     auto OpcodeName = CallFrameString(Opcode, Arch);
 228     if (!OpcodeName.empty())
 229       OS << " " << OpcodeName;
 230     else
 231       OS << format(" Opcode %x",  Opcode);
 232     break;
 233   }
 234   case OT_None:
 235     break;
 236   case OT_Address:
 237     OS << format(" %" PRIx64, Operand);
 238     break;
 239   case OT_Offset:
 240     // The offsets are all encoded in a unsigned form, but in practice
 241     // consumers use them signed. It's most certainly legacy due to
 242     // the lack of signed variants in the first Dwarf standards.
 243     OS << format(" %+" PRId64, int64_t(Operand));
 244     break;
 245   case OT_FactoredCodeOffset: // Always Unsigned
 246     if (CodeAlignmentFactor)
 247       OS << format(" %" PRId64, Operand * CodeAlignmentFactor);
 248     else
 249       OS << format(" %" PRId64 "*code_alignment_factor" , Operand);
 250     break;
 251   case OT_SignedFactDataOffset:
 252     if (DataAlignmentFactor)
 253       OS << format(" %" PRId64, int64_t(Operand) * DataAlignmentFactor);
 254     else
 255       OS << format(" %" PRId64 "*data_alignment_factor" , int64_t(Operand));
 256     break;
 257   case OT_UnsignedFactDataOffset:
 258     if (DataAlignmentFactor)
 259       OS << format(" %" PRId64, Operand * DataAlignmentFactor);
 260     else
 261       OS << format(" %" PRId64 "*data_alignment_factor" , Operand);
 262     break;
 263   case OT_Register:
 264     OS << format(" reg%" PRId64, Operand);
 265     break;
 266   case OT_Expression:
 267     assert(Instr.Expression && "missing DWARFExpression object");
 268     OS << " ";
 269     Instr.Expression->print(OS, MRI, nullptr, IsEH);
 270     break;
 271   }
 272 }
 273
 274 void CFIProgram::dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH,
 275                       unsigned IndentLevel) const {
 276   for (const auto &Instr : Instructions) {
 277     uint8_t Opcode = Instr.Opcode;
 278     if (Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK)
 279       Opcode &= DWARF_CFI_PRIMARY_OPCODE_MASK;
 280     OS.indent(2 * IndentLevel);
 281     OS << CallFrameString(Opcode, Arch) << ":";
 282     for (unsigned i = 0; i < Instr.Ops.size(); ++i)
 283       printOperand(OS, MRI, IsEH, Instr, i, Instr.Ops[i]);
 284     OS << '\n';
 285   }
 286 }
 287
 288 void CIE::dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH) const {
 289   OS << format("%08x %08x %08x CIE", (uint32_t)Offset, (uint32_t)Length,
 290                DW_CIE_ID)
 291      << "\n";
 292   OS << format("  Version:               %d\n", Version);
 293   OS << "  Augmentation:          \"" << Augmentation << "\"\n";
 294   if (Version >= 4) {
 295     OS << format("  Address size:          %u\n", (uint32_t)AddressSize);
 296     OS << format("  Segment desc size:     %u\n",
 297                  (uint32_t)SegmentDescriptorSize);
 298   }
 299   OS << format("  Code alignment factor: %u\n", (uint32_t)CodeAlignmentFactor);
 300   OS << format("  Data alignment factor: %d\n", (int32_t)DataAlignmentFactor);
 301   OS << format("  Return address column: %d\n", (int32_t)ReturnAddressRegister);
 302   if (Personality)
 303     OS << format("  Personality Address: %016" PRIx64 "\n", *Personality);
 304   if (!AugmentationData.empty()) {
 305     OS << "  Augmentation data:    ";
 306     for (uint8_t Byte : AugmentationData)
 307       OS << ' ' << hexdigit(Byte >> 4) << hexdigit(Byte & 0xf);
 308     OS << "\n";
 309   }
 310   OS << "\n";
 311   CFIs.dump(OS, MRI, IsEH);
 312   OS << "\n";
 313 }
 314
 315 void FDE::dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH) const {
 316   OS << format("%08x %08x %08x FDE ", (uint32_t)Offset, (uint32_t)Length,
 317                (int32_t)LinkedCIEOffset);
 318   OS << format("cie=%08x pc=%08x...%08x\n", (int32_t)LinkedCIEOffset,
 319                (uint32_t)InitialLocation,
 320                (uint32_t)InitialLocation + (uint32_t)AddressRange);
 321   if (LSDAAddress)
 322     OS << format("  LSDA Address: %016" PRIx64 "\n", *LSDAAddress);
 323   CFIs.dump(OS, MRI, IsEH);
 324   OS << "\n";
 325 }
 326
 327 DWARFDebugFrame::DWARFDebugFrame(Triple::ArchType Arch,
 328     bool IsEH, uint64_t EHFrameAddress)
 329     : Arch(Arch), IsEH(IsEH), EHFrameAddress(EHFrameAddress) {}
 330
 331 DWARFDebugFrame::~DWARFDebugFrame() = default;
 332
 333 static void LLVM_ATTRIBUTE_UNUSED dumpDataAux(DataExtractor Data,
 334                                               uint32_t Offset, int Length) {
 335   errs() << "DUMP: ";
 336   for (int i = 0; i < Length; ++i) {
 337     uint8_t c = Data.getU8(&Offset);
 338     errs().write_hex(c); errs() << " ";
 339   }
 340   errs() << "\n";
 341 }
 342
 343 // This is a workaround for old compilers which do not allow
 344 // noreturn attribute usage in lambdas. Once the support for those
 345 // compilers are phased out, we can remove this and return back to
 346 // a ReportError lambda: [StartOffset](const char *ErrorMsg).
 347 static void LLVM_ATTRIBUTE_NORETURN ReportError(uint32_t StartOffset,
 348                                                 const char *ErrorMsg) {
 349   std::string Str;
 350   raw_string_ostream OS(Str);
 351   OS << format(ErrorMsg, StartOffset);
 352   OS.flush();
 353   report_fatal_error(Str);
 354 }
 355
 356 void DWARFDebugFrame::parse(DWARFDataExtractor Data) {
 357   uint32_t Offset = 0;
 358   DenseMap<uint32_t, CIE *> CIEs;
 359
 360   while (Data.isValidOffset(Offset)) {
 361     uint32_t StartOffset = Offset;
 362
 363     bool IsDWARF64 = false;
 364     uint64_t Length = Data.getU32(&Offset);
 365     uint64_t Id;
 366
 367     if (Length == UINT32_MAX) {
 368       // DWARF-64 is distinguished by the first 32 bits of the initial length
 369       // field being 0xffffffff. Then, the next 64 bits are the actual entry
 370       // length.
 371       IsDWARF64 = true;
 372       Length = Data.getU64(&Offset);
 373     }
 374
 375     // At this point, Offset points to the next field after Length.
 376     // Length is the structure size excluding itself. Compute an offset one
 377     // past the end of the structure (needed to know how many instructions to
 378     // read).
 379     // TODO: For honest DWARF64 support, DataExtractor will have to treat
 380     //       offset_ptr as uint64_t*
 381     uint32_t StartStructureOffset = Offset;
 382     uint32_t EndStructureOffset = Offset + static_cast<uint32_t>(Length);
 383
 384     // The Id field's size depends on the DWARF format
 385     Id = Data.getUnsigned(&Offset, (IsDWARF64 && !IsEH) ? 8 : 4);
 386     bool IsCIE =
 387         ((IsDWARF64 && Id == DW64_CIE_ID) || Id == DW_CIE_ID || (IsEH && !Id));
 388
 389     if (IsCIE) {
 390       uint8_t Version = Data.getU8(&Offset);
 391       const char *Augmentation = Data.getCStr(&Offset);
 392       StringRef AugmentationString(Augmentation ? Augmentation : "");
 393       uint8_t AddressSize = Version < 4 ? Data.getAddressSize() :
 394                                           Data.getU8(&Offset);
 395       Data.setAddressSize(AddressSize);
 396       uint8_t SegmentDescriptorSize = Version < 4 ? 0 : Data.getU8(&Offset);
 397       uint64_t CodeAlignmentFactor = Data.getULEB128(&Offset);
 398       int64_t DataAlignmentFactor = Data.getSLEB128(&Offset);
 399       uint64_t ReturnAddressRegister =
 400           Version == 1 ? Data.getU8(&Offset) : Data.getULEB128(&Offset);
 401
 402       // Parse the augmentation data for EH CIEs
 403       StringRef AugmentationData("");
 404       uint32_t FDEPointerEncoding = DW_EH_PE_absptr;
 405       uint32_t LSDAPointerEncoding = DW_EH_PE_omit;
 406       Optional<uint64_t> Personality;
 407       Optional<uint32_t> PersonalityEncoding;
 408       if (IsEH) {
 409         Optional<uint64_t> AugmentationLength;
 410         uint32_t StartAugmentationOffset;
 411         uint32_t EndAugmentationOffset;
 412
 413         // Walk the augmentation string to get all the augmentation data.
 414         for (unsigned i = 0, e = AugmentationString.size(); i != e; ++i) {
 415           switch (AugmentationString[i]) {
 416             default:
 417               ReportError(StartOffset,
 418                           "Unknown augmentation character in entry at %lx");
 419             case 'L':
 420               LSDAPointerEncoding = Data.getU8(&Offset);
 421               break;
 422             case 'P': {
 423               if (Personality)
 424                 ReportError(StartOffset,
 425                             "Duplicate personality in entry at %lx");
 426               PersonalityEncoding = Data.getU8(&Offset);
 427               Personality = Data.getEncodedPointer(
 428                   &Offset, *PersonalityEncoding,
 429                   EHFrameAddress ? EHFrameAddress + Offset : 0);
 430               break;
 431             }
 432             case 'R':
 433               FDEPointerEncoding = Data.getU8(&Offset);
 434               break;
 435             case 'S':
 436               // Current frame is a signal trampoline.
 437               break;
 438             case 'z':
 439               if (i)
 440                 ReportError(StartOffset,
 441                             "'z' must be the first character at %lx");
 442               // Parse the augmentation length first.  We only parse it if
 443               // the string contains a 'z'.
 444               AugmentationLength = Data.getULEB128(&Offset);
 445               StartAugmentationOffset = Offset;
 446               EndAugmentationOffset = Offset +
 447                 static_cast<uint32_t>(*AugmentationLength);
 448               break;
 449             case 'B':
 450               // B-Key is used for signing functions associated with this
 451               // augmentation string
 452               break;
 453           }
 454         }
 455
 456         if (AugmentationLength.hasValue()) {
 457           if (Offset != EndAugmentationOffset)
 458             ReportError(StartOffset, "Parsing augmentation data at %lx failed");
 459
 460           AugmentationData = Data.getData().slice(StartAugmentationOffset,
 461                                                   EndAugmentationOffset);
 462         }
 463       }
 464
 465       auto Cie = llvm::make_unique<CIE>(
 466           StartOffset, Length, Version, AugmentationString, AddressSize,
 467           SegmentDescriptorSize, CodeAlignmentFactor, DataAlignmentFactor,
 468           ReturnAddressRegister, AugmentationData, FDEPointerEncoding,
 469           LSDAPointerEncoding, Personality, PersonalityEncoding, Arch);
 470       CIEs[StartOffset] = Cie.get();
 471       Entries.emplace_back(std::move(Cie));
 472     } else {
 473       // FDE
 474       uint64_t CIEPointer = Id;
 475       uint64_t InitialLocation = 0;
 476       uint64_t AddressRange = 0;
 477       Optional<uint64_t> LSDAAddress;
 478       CIE *Cie = CIEs[IsEH ? (StartStructureOffset - CIEPointer) : CIEPointer];
 479
 480       if (IsEH) {
 481         // The address size is encoded in the CIE we reference.
 482         if (!Cie)
 483           ReportError(StartOffset,
 484                       "Parsing FDE data at %lx failed due to missing CIE");
 485
 486         if (auto Val = Data.getEncodedPointer(
 487                 &Offset, Cie->getFDEPointerEncoding(),
 488                 EHFrameAddress ? EHFrameAddress + Offset : 0)) {
 489           InitialLocation = *Val;
 490         }
 491         if (auto Val = Data.getEncodedPointer(
 492                 &Offset, Cie->getFDEPointerEncoding(), 0)) {
 493           AddressRange = *Val;
 494         }
 495
 496         StringRef AugmentationString = Cie->getAugmentationString();
 497         if (!AugmentationString.empty()) {
 498           // Parse the augmentation length and data for this FDE.
 499           uint64_t AugmentationLength = Data.getULEB128(&Offset);
 500
 501           uint32_t EndAugmentationOffset =
 502             Offset + static_cast<uint32_t>(AugmentationLength);
 503
 504           // Decode the LSDA if the CIE augmentation string said we should.
 505           if (Cie->getLSDAPointerEncoding() != DW_EH_PE_omit) {
 506             LSDAAddress = Data.getEncodedPointer(
 507                 &Offset, Cie->getLSDAPointerEncoding(),
 508                 EHFrameAddress ? Offset + EHFrameAddress : 0);
 509           }
 510
 511           if (Offset != EndAugmentationOffset)
 512             ReportError(StartOffset, "Parsing augmentation data at %lx failed");
 513         }
 514       } else {
 515         InitialLocation = Data.getAddress(&Offset);
 516         AddressRange = Data.getAddress(&Offset);
 517       }
 518
 519       Entries.emplace_back(new FDE(StartOffset, Length, CIEPointer,
 520                                    InitialLocation, AddressRange,
 521                                    Cie, LSDAAddress, Arch));
 522     }
 523
 524     if (Error E =
 525             Entries.back()->cfis().parse(Data, &Offset, EndStructureOffset)) {
 526       report_fatal_error(toString(std::move(E)));
 527     }
 528
 529     if (Offset != EndStructureOffset)
 530       ReportError(StartOffset, "Parsing entry instructions at %lx failed");
 531   }
 532 }
 533
 534 FrameEntry *DWARFDebugFrame::getEntryAtOffset(uint64_t Offset) const {
 535   auto It = llvm::bsearch(Entries, [=](const std::unique_ptr<FrameEntry> &E) {
 536     return Offset <= E->getOffset();
 537   });
 538   if (It != Entries.end() && (*It)->getOffset() == Offset)
 539     return It->get();
 540   return nullptr;
 541 }
 542
 543 void DWARFDebugFrame::dump(raw_ostream &OS, const MCRegisterInfo *MRI,
 544                            Optional<uint64_t> Offset) const {
 545   if (Offset) {
 546     if (auto *Entry = getEntryAtOffset(*Offset))
 547       Entry->dump(OS, MRI, IsEH);
 548     return;
 549   }
 550
 551   OS << "\n";
 552   for (const auto &Entry : Entries)
 553     Entry->dump(OS, MRI, IsEH);
 554 }