contrib/llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

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