xref: /freebsd/contrib/llvm-project/llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp (revision 0fca6ea1d4eea4c934cfff25ac9ee8ad6fe95583) 
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/StringExtras.h"
12  #include "llvm/ADT/StringRef.h"
13  #include "llvm/BinaryFormat/Dwarf.h"
14  #include "llvm/DebugInfo/DIContext.h"
15  #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.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 <optional>
27  
28  using namespace llvm;
29  using namespace dwarf;
30  
printRegister(raw_ostream & OS,DIDumpOptions DumpOpts,unsigned RegNum)31  static void printRegister(raw_ostream &OS, DIDumpOptions DumpOpts,
32                            unsigned RegNum) {
33    if (DumpOpts.GetNameForDWARFReg) {
34      auto RegName = DumpOpts.GetNameForDWARFReg(RegNum, DumpOpts.IsEH);
35      if (!RegName.empty()) {
36        OS << RegName;
37        return;
38      }
39    }
40    OS << "reg" << RegNum;
41  }
42  
createUnspecified()43  UnwindLocation UnwindLocation::createUnspecified() { return {Unspecified}; }
44  
createUndefined()45  UnwindLocation UnwindLocation::createUndefined() { return {Undefined}; }
46  
createSame()47  UnwindLocation UnwindLocation::createSame() { return {Same}; }
48  
createIsConstant(int32_t Value)49  UnwindLocation UnwindLocation::createIsConstant(int32_t Value) {
50    return {Constant, InvalidRegisterNumber, Value, std::nullopt, false};
51  }
52  
createIsCFAPlusOffset(int32_t Offset)53  UnwindLocation UnwindLocation::createIsCFAPlusOffset(int32_t Offset) {
54    return {CFAPlusOffset, InvalidRegisterNumber, Offset, std::nullopt, false};
55  }
56  
createAtCFAPlusOffset(int32_t Offset)57  UnwindLocation UnwindLocation::createAtCFAPlusOffset(int32_t Offset) {
58    return {CFAPlusOffset, InvalidRegisterNumber, Offset, std::nullopt, true};
59  }
60  
61  UnwindLocation
createIsRegisterPlusOffset(uint32_t RegNum,int32_t Offset,std::optional<uint32_t> AddrSpace)62  UnwindLocation::createIsRegisterPlusOffset(uint32_t RegNum, int32_t Offset,
63                                             std::optional<uint32_t> AddrSpace) {
64    return {RegPlusOffset, RegNum, Offset, AddrSpace, false};
65  }
66  
67  UnwindLocation
createAtRegisterPlusOffset(uint32_t RegNum,int32_t Offset,std::optional<uint32_t> AddrSpace)68  UnwindLocation::createAtRegisterPlusOffset(uint32_t RegNum, int32_t Offset,
69                                             std::optional<uint32_t> AddrSpace) {
70    return {RegPlusOffset, RegNum, Offset, AddrSpace, true};
71  }
72  
createIsDWARFExpression(DWARFExpression Expr)73  UnwindLocation UnwindLocation::createIsDWARFExpression(DWARFExpression Expr) {
74    return {Expr, false};
75  }
76  
createAtDWARFExpression(DWARFExpression Expr)77  UnwindLocation UnwindLocation::createAtDWARFExpression(DWARFExpression Expr) {
78    return {Expr, true};
79  }
80  
dump(raw_ostream & OS,DIDumpOptions DumpOpts) const81  void UnwindLocation::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const {
82    if (Dereference)
83      OS << '[';
84    switch (Kind) {
85    case Unspecified:
86      OS << "unspecified";
87      break;
88    case Undefined:
89      OS << "undefined";
90      break;
91    case Same:
92      OS << "same";
93      break;
94    case CFAPlusOffset:
95      OS << "CFA";
96      if (Offset == 0)
97        break;
98      if (Offset > 0)
99        OS << "+";
100      OS << Offset;
101      break;
102    case RegPlusOffset:
103      printRegister(OS, DumpOpts, RegNum);
104      if (Offset == 0 && !AddrSpace)
105        break;
106      if (Offset >= 0)
107        OS << "+";
108      OS << Offset;
109      if (AddrSpace)
110        OS << " in addrspace" << *AddrSpace;
111      break;
112    case DWARFExpr: {
113      Expr->print(OS, DumpOpts, nullptr);
114      break;
115    }
116    case Constant:
117      OS << Offset;
118      break;
119    }
120    if (Dereference)
121      OS << ']';
122  }
123  
operator <<(raw_ostream & OS,const UnwindLocation & UL)124  raw_ostream &llvm::dwarf::operator<<(raw_ostream &OS,
125                                       const UnwindLocation &UL) {
126    auto DumpOpts = DIDumpOptions();
127    UL.dump(OS, DumpOpts);
128    return OS;
129  }
130  
operator ==(const UnwindLocation & RHS) const131  bool UnwindLocation::operator==(const UnwindLocation &RHS) const {
132    if (Kind != RHS.Kind)
133      return false;
134    switch (Kind) {
135    case Unspecified:
136    case Undefined:
137    case Same:
138      return true;
139    case CFAPlusOffset:
140      return Offset == RHS.Offset && Dereference == RHS.Dereference;
141    case RegPlusOffset:
142      return RegNum == RHS.RegNum && Offset == RHS.Offset &&
143             Dereference == RHS.Dereference;
144    case DWARFExpr:
145      return *Expr == *RHS.Expr && Dereference == RHS.Dereference;
146    case Constant:
147      return Offset == RHS.Offset;
148    }
149    return false;
150  }
151  
dump(raw_ostream & OS,DIDumpOptions DumpOpts) const152  void RegisterLocations::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const {
153    bool First = true;
154    for (const auto &RegLocPair : Locations) {
155      if (First)
156        First = false;
157      else
158        OS << ", ";
159      printRegister(OS, DumpOpts, RegLocPair.first);
160      OS << '=';
161      RegLocPair.second.dump(OS, DumpOpts);
162    }
163  }
164  
operator <<(raw_ostream & OS,const RegisterLocations & RL)165  raw_ostream &llvm::dwarf::operator<<(raw_ostream &OS,
166                                       const RegisterLocations &RL) {
167    auto DumpOpts = DIDumpOptions();
168    RL.dump(OS, DumpOpts);
169    return OS;
170  }
171  
dump(raw_ostream & OS,DIDumpOptions DumpOpts,unsigned IndentLevel) const172  void UnwindRow::dump(raw_ostream &OS, DIDumpOptions DumpOpts,
173                       unsigned IndentLevel) const {
174    OS.indent(2 * IndentLevel);
175    if (hasAddress())
176      OS << format("0x%" PRIx64 ": ", *Address);
177    OS << "CFA=";
178    CFAValue.dump(OS, DumpOpts);
179    if (RegLocs.hasLocations()) {
180      OS << ": ";
181      RegLocs.dump(OS, DumpOpts);
182    }
183    OS << "\n";
184  }
185  
operator <<(raw_ostream & OS,const UnwindRow & Row)186  raw_ostream &llvm::dwarf::operator<<(raw_ostream &OS, const UnwindRow &Row) {
187    auto DumpOpts = DIDumpOptions();
188    Row.dump(OS, DumpOpts, 0);
189    return OS;
190  }
191  
dump(raw_ostream & OS,DIDumpOptions DumpOpts,unsigned IndentLevel) const192  void UnwindTable::dump(raw_ostream &OS, DIDumpOptions DumpOpts,
193                         unsigned IndentLevel) const {
194    for (const UnwindRow &Row : Rows)
195      Row.dump(OS, DumpOpts, IndentLevel);
196  }
197  
operator <<(raw_ostream & OS,const UnwindTable & Rows)198  raw_ostream &llvm::dwarf::operator<<(raw_ostream &OS, const UnwindTable &Rows) {
199    auto DumpOpts = DIDumpOptions();
200    Rows.dump(OS, DumpOpts, 0);
201    return OS;
202  }
203  
create(const FDE * Fde)204  Expected<UnwindTable> UnwindTable::create(const FDE *Fde) {
205    const CIE *Cie = Fde->getLinkedCIE();
206    if (Cie == nullptr)
207      return createStringError(errc::invalid_argument,
208                               "unable to get CIE for FDE at offset 0x%" PRIx64,
209                               Fde->getOffset());
210  
211    // Rows will be empty if there are no CFI instructions.
212    if (Cie->cfis().empty() && Fde->cfis().empty())
213      return UnwindTable();
214  
215    UnwindTable UT;
216    UnwindRow Row;
217    Row.setAddress(Fde->getInitialLocation());
218    UT.EndAddress = Fde->getInitialLocation() + Fde->getAddressRange();
219    if (Error CieError = UT.parseRows(Cie->cfis(), Row, nullptr))
220      return std::move(CieError);
221    // We need to save the initial locations of registers from the CIE parsing
222    // in case we run into DW_CFA_restore or DW_CFA_restore_extended opcodes.
223    const RegisterLocations InitialLocs = Row.getRegisterLocations();
224    if (Error FdeError = UT.parseRows(Fde->cfis(), Row, &InitialLocs))
225      return std::move(FdeError);
226    // May be all the CFI instructions were DW_CFA_nop amd Row becomes empty.
227    // Do not add that to the unwind table.
228    if (Row.getRegisterLocations().hasLocations() ||
229        Row.getCFAValue().getLocation() != UnwindLocation::Unspecified)
230      UT.Rows.push_back(Row);
231    return UT;
232  }
233  
create(const CIE * Cie)234  Expected<UnwindTable> UnwindTable::create(const CIE *Cie) {
235    // Rows will be empty if there are no CFI instructions.
236    if (Cie->cfis().empty())
237      return UnwindTable();
238  
239    UnwindTable UT;
240    UnwindRow Row;
241    if (Error CieError = UT.parseRows(Cie->cfis(), Row, nullptr))
242      return std::move(CieError);
243    // May be all the CFI instructions were DW_CFA_nop amd Row becomes empty.
244    // Do not add that to the unwind table.
245    if (Row.getRegisterLocations().hasLocations() ||
246        Row.getCFAValue().getLocation() != UnwindLocation::Unspecified)
247      UT.Rows.push_back(Row);
248    return UT;
249  }
250  
251  // See DWARF standard v3, section 7.23
252  const uint8_t DWARF_CFI_PRIMARY_OPCODE_MASK = 0xc0;
253  const uint8_t DWARF_CFI_PRIMARY_OPERAND_MASK = 0x3f;
254  
parse(DWARFDataExtractor Data,uint64_t * Offset,uint64_t EndOffset)255  Error CFIProgram::parse(DWARFDataExtractor Data, uint64_t *Offset,
256                          uint64_t EndOffset) {
257    DataExtractor::Cursor C(*Offset);
258    while (C && C.tell() < EndOffset) {
259      uint8_t Opcode = Data.getRelocatedValue(C, 1);
260      if (!C)
261        break;
262  
263      // Some instructions have a primary opcode encoded in the top bits.
264      if (uint8_t Primary = Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK) {
265        // If it's a primary opcode, the first operand is encoded in the bottom
266        // bits of the opcode itself.
267        uint64_t Op1 = Opcode & DWARF_CFI_PRIMARY_OPERAND_MASK;
268        switch (Primary) {
269        case DW_CFA_advance_loc:
270        case DW_CFA_restore:
271          addInstruction(Primary, Op1);
272          break;
273        case DW_CFA_offset:
274          addInstruction(Primary, Op1, Data.getULEB128(C));
275          break;
276        default:
277          llvm_unreachable("invalid primary CFI opcode");
278        }
279        continue;
280      }
281  
282      // Extended opcode - its value is Opcode itself.
283      switch (Opcode) {
284      default:
285        return createStringError(errc::illegal_byte_sequence,
286                                 "invalid extended CFI opcode 0x%" PRIx8, Opcode);
287      case DW_CFA_nop:
288      case DW_CFA_remember_state:
289      case DW_CFA_restore_state:
290      case DW_CFA_GNU_window_save:
291        // No operands
292        addInstruction(Opcode);
293        break;
294      case DW_CFA_set_loc:
295        // Operands: Address
296        addInstruction(Opcode, Data.getRelocatedAddress(C));
297        break;
298      case DW_CFA_advance_loc1:
299        // Operands: 1-byte delta
300        addInstruction(Opcode, Data.getRelocatedValue(C, 1));
301        break;
302      case DW_CFA_advance_loc2:
303        // Operands: 2-byte delta
304        addInstruction(Opcode, Data.getRelocatedValue(C, 2));
305        break;
306      case DW_CFA_advance_loc4:
307        // Operands: 4-byte delta
308        addInstruction(Opcode, Data.getRelocatedValue(C, 4));
309        break;
310      case DW_CFA_restore_extended:
311      case DW_CFA_undefined:
312      case DW_CFA_same_value:
313      case DW_CFA_def_cfa_register:
314      case DW_CFA_def_cfa_offset:
315      case DW_CFA_GNU_args_size:
316        // Operands: ULEB128
317        addInstruction(Opcode, Data.getULEB128(C));
318        break;
319      case DW_CFA_def_cfa_offset_sf:
320        // Operands: SLEB128
321        addInstruction(Opcode, Data.getSLEB128(C));
322        break;
323      case DW_CFA_LLVM_def_aspace_cfa:
324      case DW_CFA_LLVM_def_aspace_cfa_sf: {
325        auto RegNum = Data.getULEB128(C);
326        auto CfaOffset = Opcode == DW_CFA_LLVM_def_aspace_cfa
327                             ? Data.getULEB128(C)
328                             : Data.getSLEB128(C);
329        auto AddressSpace = Data.getULEB128(C);
330        addInstruction(Opcode, RegNum, CfaOffset, AddressSpace);
331        break;
332      }
333      case DW_CFA_offset_extended:
334      case DW_CFA_register:
335      case DW_CFA_def_cfa:
336      case DW_CFA_val_offset: {
337        // Operands: ULEB128, ULEB128
338        // Note: We can not embed getULEB128 directly into function
339        // argument list. getULEB128 changes Offset and order of evaluation
340        // for arguments is unspecified.
341        uint64_t op1 = Data.getULEB128(C);
342        uint64_t op2 = Data.getULEB128(C);
343        addInstruction(Opcode, op1, op2);
344        break;
345      }
346      case DW_CFA_offset_extended_sf:
347      case DW_CFA_def_cfa_sf:
348      case DW_CFA_val_offset_sf: {
349        // Operands: ULEB128, SLEB128
350        // Note: see comment for the previous case
351        uint64_t op1 = Data.getULEB128(C);
352        uint64_t op2 = (uint64_t)Data.getSLEB128(C);
353        addInstruction(Opcode, op1, op2);
354        break;
355      }
356      case DW_CFA_def_cfa_expression: {
357        uint64_t ExprLength = Data.getULEB128(C);
358        addInstruction(Opcode, 0);
359        StringRef Expression = Data.getBytes(C, ExprLength);
360  
361        DataExtractor Extractor(Expression, Data.isLittleEndian(),
362                                Data.getAddressSize());
363        // Note. We do not pass the DWARF format to DWARFExpression, because
364        // DW_OP_call_ref, the only operation which depends on the format, is
365        // prohibited in call frame instructions, see sec. 6.4.2 in DWARFv5.
366        Instructions.back().Expression =
367            DWARFExpression(Extractor, Data.getAddressSize());
368        break;
369      }
370      case DW_CFA_expression:
371      case DW_CFA_val_expression: {
372        uint64_t RegNum = Data.getULEB128(C);
373        addInstruction(Opcode, RegNum, 0);
374  
375        uint64_t BlockLength = Data.getULEB128(C);
376        StringRef Expression = Data.getBytes(C, BlockLength);
377        DataExtractor Extractor(Expression, Data.isLittleEndian(),
378                                Data.getAddressSize());
379        // Note. We do not pass the DWARF format to DWARFExpression, because
380        // DW_OP_call_ref, the only operation which depends on the format, is
381        // prohibited in call frame instructions, see sec. 6.4.2 in DWARFv5.
382        Instructions.back().Expression =
383            DWARFExpression(Extractor, Data.getAddressSize());
384        break;
385      }
386      }
387    }
388  
389    *Offset = C.tell();
390    return C.takeError();
391  }
392  
callFrameString(unsigned Opcode) const393  StringRef CFIProgram::callFrameString(unsigned Opcode) const {
394    return dwarf::CallFrameString(Opcode, Arch);
395  }
396  
operandTypeString(CFIProgram::OperandType OT)397  const char *CFIProgram::operandTypeString(CFIProgram::OperandType OT) {
398  #define ENUM_TO_CSTR(e)                                                        \
399    case e:                                                                      \
400      return #e;
401    switch (OT) {
402      ENUM_TO_CSTR(OT_Unset);
403      ENUM_TO_CSTR(OT_None);
404      ENUM_TO_CSTR(OT_Address);
405      ENUM_TO_CSTR(OT_Offset);
406      ENUM_TO_CSTR(OT_FactoredCodeOffset);
407      ENUM_TO_CSTR(OT_SignedFactDataOffset);
408      ENUM_TO_CSTR(OT_UnsignedFactDataOffset);
409      ENUM_TO_CSTR(OT_Register);
410      ENUM_TO_CSTR(OT_AddressSpace);
411      ENUM_TO_CSTR(OT_Expression);
412    }
413    return "<unknown CFIProgram::OperandType>";
414  }
415  
416  llvm::Expected<uint64_t>
getOperandAsUnsigned(const CFIProgram & CFIP,uint32_t OperandIdx) const417  CFIProgram::Instruction::getOperandAsUnsigned(const CFIProgram &CFIP,
418                                                uint32_t OperandIdx) const {
419    if (OperandIdx >= MaxOperands)
420      return createStringError(errc::invalid_argument,
421                               "operand index %" PRIu32 " is not valid",
422                               OperandIdx);
423    OperandType Type = CFIP.getOperandTypes()[Opcode][OperandIdx];
424    uint64_t Operand = Ops[OperandIdx];
425    switch (Type) {
426    case OT_Unset:
427    case OT_None:
428    case OT_Expression:
429      return createStringError(errc::invalid_argument,
430                               "op[%" PRIu32 "] has type %s which has no value",
431                               OperandIdx, CFIProgram::operandTypeString(Type));
432  
433    case OT_Offset:
434    case OT_SignedFactDataOffset:
435    case OT_UnsignedFactDataOffset:
436      return createStringError(
437          errc::invalid_argument,
438          "op[%" PRIu32 "] has OperandType OT_Offset which produces a signed "
439          "result, call getOperandAsSigned instead",
440          OperandIdx);
441  
442    case OT_Address:
443    case OT_Register:
444    case OT_AddressSpace:
445      return Operand;
446  
447    case OT_FactoredCodeOffset: {
448      const uint64_t CodeAlignmentFactor = CFIP.codeAlign();
449      if (CodeAlignmentFactor == 0)
450        return createStringError(
451            errc::invalid_argument,
452            "op[%" PRIu32 "] has type OT_FactoredCodeOffset but code alignment "
453            "is zero",
454            OperandIdx);
455      return Operand * CodeAlignmentFactor;
456    }
457    }
458    llvm_unreachable("invalid operand type");
459  }
460  
461  llvm::Expected<int64_t>
getOperandAsSigned(const CFIProgram & CFIP,uint32_t OperandIdx) const462  CFIProgram::Instruction::getOperandAsSigned(const CFIProgram &CFIP,
463                                              uint32_t OperandIdx) const {
464    if (OperandIdx >= MaxOperands)
465      return createStringError(errc::invalid_argument,
466                               "operand index %" PRIu32 " is not valid",
467                               OperandIdx);
468    OperandType Type = CFIP.getOperandTypes()[Opcode][OperandIdx];
469    uint64_t Operand = Ops[OperandIdx];
470    switch (Type) {
471    case OT_Unset:
472    case OT_None:
473    case OT_Expression:
474      return createStringError(errc::invalid_argument,
475                               "op[%" PRIu32 "] has type %s which has no value",
476                               OperandIdx, CFIProgram::operandTypeString(Type));
477  
478    case OT_Address:
479    case OT_Register:
480    case OT_AddressSpace:
481      return createStringError(
482          errc::invalid_argument,
483          "op[%" PRIu32 "] has OperandType %s which produces an unsigned result, "
484          "call getOperandAsUnsigned instead",
485          OperandIdx, CFIProgram::operandTypeString(Type));
486  
487    case OT_Offset:
488      return (int64_t)Operand;
489  
490    case OT_FactoredCodeOffset:
491    case OT_SignedFactDataOffset: {
492      const int64_t DataAlignmentFactor = CFIP.dataAlign();
493      if (DataAlignmentFactor == 0)
494        return createStringError(errc::invalid_argument,
495                                 "op[%" PRIu32 "] has type %s but data "
496                                 "alignment is zero",
497                                 OperandIdx, CFIProgram::operandTypeString(Type));
498      return int64_t(Operand) * DataAlignmentFactor;
499    }
500  
501    case OT_UnsignedFactDataOffset: {
502      const int64_t DataAlignmentFactor = CFIP.dataAlign();
503      if (DataAlignmentFactor == 0)
504        return createStringError(errc::invalid_argument,
505                                 "op[%" PRIu32
506                                 "] has type OT_UnsignedFactDataOffset but data "
507                                 "alignment is zero",
508                                 OperandIdx);
509      return Operand * DataAlignmentFactor;
510    }
511    }
512    llvm_unreachable("invalid operand type");
513  }
514  
parseRows(const CFIProgram & CFIP,UnwindRow & Row,const RegisterLocations * InitialLocs)515  Error UnwindTable::parseRows(const CFIProgram &CFIP, UnwindRow &Row,
516                               const RegisterLocations *InitialLocs) {
517    // State consists of CFA value and register locations.
518    std::vector<std::pair<UnwindLocation, RegisterLocations>> States;
519    for (const CFIProgram::Instruction &Inst : CFIP) {
520      switch (Inst.Opcode) {
521      case dwarf::DW_CFA_set_loc: {
522        // The DW_CFA_set_loc instruction takes a single operand that
523        // represents a target address. The required action is to create a new
524        // table row using the specified address as the location. All other
525        // values in the new row are initially identical to the current row.
526        // The new location value is always greater than the current one. If
527        // the segment_size field of this FDE's CIE is non- zero, the initial
528        // location is preceded by a segment selector of the given length
529        llvm::Expected<uint64_t> NewAddress = Inst.getOperandAsUnsigned(CFIP, 0);
530        if (!NewAddress)
531          return NewAddress.takeError();
532        if (*NewAddress <= Row.getAddress())
533          return createStringError(
534              errc::invalid_argument,
535              "%s with adrress 0x%" PRIx64 " which must be greater than the "
536              "current row address 0x%" PRIx64,
537              CFIP.callFrameString(Inst.Opcode).str().c_str(), *NewAddress,
538              Row.getAddress());
539        Rows.push_back(Row);
540        Row.setAddress(*NewAddress);
541        break;
542      }
543  
544      case dwarf::DW_CFA_advance_loc:
545      case dwarf::DW_CFA_advance_loc1:
546      case dwarf::DW_CFA_advance_loc2:
547      case dwarf::DW_CFA_advance_loc4: {
548        // The DW_CFA_advance instruction takes a single operand that
549        // represents a constant delta. The required action is to create a new
550        // table row with a location value that is computed by taking the
551        // current entry’s location value and adding the value of delta *
552        // code_alignment_factor. All other values in the new row are initially
553        // identical to the current row.
554        Rows.push_back(Row);
555        llvm::Expected<uint64_t> Offset = Inst.getOperandAsUnsigned(CFIP, 0);
556        if (!Offset)
557          return Offset.takeError();
558        Row.slideAddress(*Offset);
559        break;
560      }
561  
562      case dwarf::DW_CFA_restore:
563      case dwarf::DW_CFA_restore_extended: {
564        // The DW_CFA_restore instruction takes a single operand (encoded with
565        // the opcode) that represents a register number. The required action
566        // is to change the rule for the indicated register to the rule
567        // assigned it by the initial_instructions in the CIE.
568        if (InitialLocs == nullptr)
569          return createStringError(
570              errc::invalid_argument, "%s encountered while parsing a CIE",
571              CFIP.callFrameString(Inst.Opcode).str().c_str());
572        llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
573        if (!RegNum)
574          return RegNum.takeError();
575        if (std::optional<UnwindLocation> O =
576                InitialLocs->getRegisterLocation(*RegNum))
577          Row.getRegisterLocations().setRegisterLocation(*RegNum, *O);
578        else
579          Row.getRegisterLocations().removeRegisterLocation(*RegNum);
580        break;
581      }
582  
583      case dwarf::DW_CFA_offset:
584      case dwarf::DW_CFA_offset_extended:
585      case dwarf::DW_CFA_offset_extended_sf: {
586        llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
587        if (!RegNum)
588          return RegNum.takeError();
589        llvm::Expected<int64_t> Offset = Inst.getOperandAsSigned(CFIP, 1);
590        if (!Offset)
591          return Offset.takeError();
592        Row.getRegisterLocations().setRegisterLocation(
593            *RegNum, UnwindLocation::createAtCFAPlusOffset(*Offset));
594        break;
595      }
596  
597      case dwarf::DW_CFA_nop:
598        break;
599  
600      case dwarf::DW_CFA_remember_state:
601        States.push_back(
602            std::make_pair(Row.getCFAValue(), Row.getRegisterLocations()));
603        break;
604  
605      case dwarf::DW_CFA_restore_state:
606        if (States.empty())
607          return createStringError(errc::invalid_argument,
608                                   "DW_CFA_restore_state without a matching "
609                                   "previous DW_CFA_remember_state");
610        Row.getCFAValue() = States.back().first;
611        Row.getRegisterLocations() = States.back().second;
612        States.pop_back();
613        break;
614  
615      case dwarf::DW_CFA_GNU_window_save:
616        switch (CFIP.triple()) {
617        case Triple::aarch64:
618        case Triple::aarch64_be:
619        case Triple::aarch64_32: {
620          // DW_CFA_GNU_window_save is used for different things on different
621          // architectures. For aarch64 it is known as
622          // DW_CFA_AARCH64_negate_ra_state. The action is to toggle the
623          // value of the return address state between 1 and 0. If there is
624          // no rule for the AARCH64_DWARF_PAUTH_RA_STATE register, then it
625          // should be initially set to 1.
626          constexpr uint32_t AArch64DWARFPAuthRaState = 34;
627          auto LRLoc = Row.getRegisterLocations().getRegisterLocation(
628              AArch64DWARFPAuthRaState);
629          if (LRLoc) {
630            if (LRLoc->getLocation() == UnwindLocation::Constant) {
631              // Toggle the constant value from 0 to 1 or 1 to 0.
632              LRLoc->setConstant(LRLoc->getConstant() ^ 1);
633              Row.getRegisterLocations().setRegisterLocation(
634                  AArch64DWARFPAuthRaState, *LRLoc);
635            } else {
636              return createStringError(
637                  errc::invalid_argument,
638                  "%s encountered when existing rule for this register is not "
639                  "a constant",
640                  CFIP.callFrameString(Inst.Opcode).str().c_str());
641            }
642          } else {
643            Row.getRegisterLocations().setRegisterLocation(
644                AArch64DWARFPAuthRaState, UnwindLocation::createIsConstant(1));
645          }
646          break;
647        }
648  
649        case Triple::sparc:
650        case Triple::sparcv9:
651        case Triple::sparcel:
652          for (uint32_t RegNum = 16; RegNum < 32; ++RegNum) {
653            Row.getRegisterLocations().setRegisterLocation(
654                RegNum, UnwindLocation::createAtCFAPlusOffset((RegNum - 16) * 8));
655          }
656          break;
657  
658        default: {
659          return createStringError(
660              errc::not_supported,
661              "DW_CFA opcode %#x is not supported for architecture %s",
662              Inst.Opcode, Triple::getArchTypeName(CFIP.triple()).str().c_str());
663  
664          break;
665        }
666        }
667        break;
668  
669      case dwarf::DW_CFA_undefined: {
670        llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
671        if (!RegNum)
672          return RegNum.takeError();
673        Row.getRegisterLocations().setRegisterLocation(
674            *RegNum, UnwindLocation::createUndefined());
675        break;
676      }
677  
678      case dwarf::DW_CFA_same_value: {
679        llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
680        if (!RegNum)
681          return RegNum.takeError();
682        Row.getRegisterLocations().setRegisterLocation(
683            *RegNum, UnwindLocation::createSame());
684        break;
685      }
686  
687      case dwarf::DW_CFA_GNU_args_size:
688        break;
689  
690      case dwarf::DW_CFA_register: {
691        llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
692        if (!RegNum)
693          return RegNum.takeError();
694        llvm::Expected<uint64_t> NewRegNum = Inst.getOperandAsUnsigned(CFIP, 1);
695        if (!NewRegNum)
696          return NewRegNum.takeError();
697        Row.getRegisterLocations().setRegisterLocation(
698            *RegNum, UnwindLocation::createIsRegisterPlusOffset(*NewRegNum, 0));
699        break;
700      }
701  
702      case dwarf::DW_CFA_val_offset:
703      case dwarf::DW_CFA_val_offset_sf: {
704        llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
705        if (!RegNum)
706          return RegNum.takeError();
707        llvm::Expected<int64_t> Offset = Inst.getOperandAsSigned(CFIP, 1);
708        if (!Offset)
709          return Offset.takeError();
710        Row.getRegisterLocations().setRegisterLocation(
711            *RegNum, UnwindLocation::createIsCFAPlusOffset(*Offset));
712        break;
713      }
714  
715      case dwarf::DW_CFA_expression: {
716        llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
717        if (!RegNum)
718          return RegNum.takeError();
719        Row.getRegisterLocations().setRegisterLocation(
720            *RegNum, UnwindLocation::createAtDWARFExpression(*Inst.Expression));
721        break;
722      }
723  
724      case dwarf::DW_CFA_val_expression: {
725        llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
726        if (!RegNum)
727          return RegNum.takeError();
728        Row.getRegisterLocations().setRegisterLocation(
729            *RegNum, UnwindLocation::createIsDWARFExpression(*Inst.Expression));
730        break;
731      }
732  
733      case dwarf::DW_CFA_def_cfa_register: {
734        llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
735        if (!RegNum)
736          return RegNum.takeError();
737        if (Row.getCFAValue().getLocation() != UnwindLocation::RegPlusOffset)
738          Row.getCFAValue() =
739              UnwindLocation::createIsRegisterPlusOffset(*RegNum, 0);
740        else
741          Row.getCFAValue().setRegister(*RegNum);
742        break;
743      }
744  
745      case dwarf::DW_CFA_def_cfa_offset:
746      case dwarf::DW_CFA_def_cfa_offset_sf: {
747        llvm::Expected<int64_t> Offset = Inst.getOperandAsSigned(CFIP, 0);
748        if (!Offset)
749          return Offset.takeError();
750        if (Row.getCFAValue().getLocation() != UnwindLocation::RegPlusOffset) {
751          return createStringError(
752              errc::invalid_argument,
753              "%s found when CFA rule was not RegPlusOffset",
754              CFIP.callFrameString(Inst.Opcode).str().c_str());
755        }
756        Row.getCFAValue().setOffset(*Offset);
757        break;
758      }
759  
760      case dwarf::DW_CFA_def_cfa:
761      case dwarf::DW_CFA_def_cfa_sf: {
762        llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
763        if (!RegNum)
764          return RegNum.takeError();
765        llvm::Expected<int64_t> Offset = Inst.getOperandAsSigned(CFIP, 1);
766        if (!Offset)
767          return Offset.takeError();
768        Row.getCFAValue() =
769            UnwindLocation::createIsRegisterPlusOffset(*RegNum, *Offset);
770        break;
771      }
772  
773      case dwarf::DW_CFA_LLVM_def_aspace_cfa:
774      case dwarf::DW_CFA_LLVM_def_aspace_cfa_sf: {
775        llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
776        if (!RegNum)
777          return RegNum.takeError();
778        llvm::Expected<int64_t> Offset = Inst.getOperandAsSigned(CFIP, 1);
779        if (!Offset)
780          return Offset.takeError();
781        llvm::Expected<uint32_t> CFAAddrSpace =
782            Inst.getOperandAsUnsigned(CFIP, 2);
783        if (!CFAAddrSpace)
784          return CFAAddrSpace.takeError();
785        Row.getCFAValue() = UnwindLocation::createIsRegisterPlusOffset(
786            *RegNum, *Offset, *CFAAddrSpace);
787        break;
788      }
789  
790      case dwarf::DW_CFA_def_cfa_expression:
791        Row.getCFAValue() =
792            UnwindLocation::createIsDWARFExpression(*Inst.Expression);
793        break;
794      }
795    }
796    return Error::success();
797  }
798  
799  ArrayRef<CFIProgram::OperandType[CFIProgram::MaxOperands]>
getOperandTypes()800  CFIProgram::getOperandTypes() {
801    static OperandType OpTypes[DW_CFA_restore + 1][MaxOperands];
802    static bool Initialized = false;
803    if (Initialized) {
804      return ArrayRef<OperandType[MaxOperands]>(&OpTypes[0], DW_CFA_restore + 1);
805    }
806    Initialized = true;
807  
808  #define DECLARE_OP3(OP, OPTYPE0, OPTYPE1, OPTYPE2)                             \
809    do {                                                                         \
810      OpTypes[OP][0] = OPTYPE0;                                                  \
811      OpTypes[OP][1] = OPTYPE1;                                                  \
812      OpTypes[OP][2] = OPTYPE2;                                                  \
813    } while (false)
814  #define DECLARE_OP2(OP, OPTYPE0, OPTYPE1)                                      \
815    DECLARE_OP3(OP, OPTYPE0, OPTYPE1, OT_None)
816  #define DECLARE_OP1(OP, OPTYPE0) DECLARE_OP2(OP, OPTYPE0, OT_None)
817  #define DECLARE_OP0(OP) DECLARE_OP1(OP, OT_None)
818  
819    DECLARE_OP1(DW_CFA_set_loc, OT_Address);
820    DECLARE_OP1(DW_CFA_advance_loc, OT_FactoredCodeOffset);
821    DECLARE_OP1(DW_CFA_advance_loc1, OT_FactoredCodeOffset);
822    DECLARE_OP1(DW_CFA_advance_loc2, OT_FactoredCodeOffset);
823    DECLARE_OP1(DW_CFA_advance_loc4, OT_FactoredCodeOffset);
824    DECLARE_OP1(DW_CFA_MIPS_advance_loc8, OT_FactoredCodeOffset);
825    DECLARE_OP2(DW_CFA_def_cfa, OT_Register, OT_Offset);
826    DECLARE_OP2(DW_CFA_def_cfa_sf, OT_Register, OT_SignedFactDataOffset);
827    DECLARE_OP1(DW_CFA_def_cfa_register, OT_Register);
828    DECLARE_OP3(DW_CFA_LLVM_def_aspace_cfa, OT_Register, OT_Offset,
829                OT_AddressSpace);
830    DECLARE_OP3(DW_CFA_LLVM_def_aspace_cfa_sf, OT_Register,
831                OT_SignedFactDataOffset, OT_AddressSpace);
832    DECLARE_OP1(DW_CFA_def_cfa_offset, OT_Offset);
833    DECLARE_OP1(DW_CFA_def_cfa_offset_sf, OT_SignedFactDataOffset);
834    DECLARE_OP1(DW_CFA_def_cfa_expression, OT_Expression);
835    DECLARE_OP1(DW_CFA_undefined, OT_Register);
836    DECLARE_OP1(DW_CFA_same_value, OT_Register);
837    DECLARE_OP2(DW_CFA_offset, OT_Register, OT_UnsignedFactDataOffset);
838    DECLARE_OP2(DW_CFA_offset_extended, OT_Register, OT_UnsignedFactDataOffset);
839    DECLARE_OP2(DW_CFA_offset_extended_sf, OT_Register, OT_SignedFactDataOffset);
840    DECLARE_OP2(DW_CFA_val_offset, OT_Register, OT_UnsignedFactDataOffset);
841    DECLARE_OP2(DW_CFA_val_offset_sf, OT_Register, OT_SignedFactDataOffset);
842    DECLARE_OP2(DW_CFA_register, OT_Register, OT_Register);
843    DECLARE_OP2(DW_CFA_expression, OT_Register, OT_Expression);
844    DECLARE_OP2(DW_CFA_val_expression, OT_Register, OT_Expression);
845    DECLARE_OP1(DW_CFA_restore, OT_Register);
846    DECLARE_OP1(DW_CFA_restore_extended, OT_Register);
847    DECLARE_OP0(DW_CFA_remember_state);
848    DECLARE_OP0(DW_CFA_restore_state);
849    DECLARE_OP0(DW_CFA_GNU_window_save);
850    DECLARE_OP1(DW_CFA_GNU_args_size, OT_Offset);
851    DECLARE_OP0(DW_CFA_nop);
852  
853  #undef DECLARE_OP0
854  #undef DECLARE_OP1
855  #undef DECLARE_OP2
856  
857    return ArrayRef<OperandType[MaxOperands]>(&OpTypes[0], DW_CFA_restore + 1);
858  }
859  
860  /// Print \p Opcode's operand number \p OperandIdx which has value \p Operand.
printOperand(raw_ostream & OS,DIDumpOptions DumpOpts,const Instruction & Instr,unsigned OperandIdx,uint64_t Operand,std::optional<uint64_t> & Address) const861  void CFIProgram::printOperand(raw_ostream &OS, DIDumpOptions DumpOpts,
862                                const Instruction &Instr, unsigned OperandIdx,
863                                uint64_t Operand,
864                                std::optional<uint64_t> &Address) const {
865    assert(OperandIdx < MaxOperands);
866    uint8_t Opcode = Instr.Opcode;
867    OperandType Type = getOperandTypes()[Opcode][OperandIdx];
868  
869    switch (Type) {
870    case OT_Unset: {
871      OS << " Unsupported " << (OperandIdx ? "second" : "first") << " operand to";
872      auto OpcodeName = callFrameString(Opcode);
873      if (!OpcodeName.empty())
874        OS << " " << OpcodeName;
875      else
876        OS << format(" Opcode %x",  Opcode);
877      break;
878    }
879    case OT_None:
880      break;
881    case OT_Address:
882      OS << format(" %" PRIx64, Operand);
883      Address = Operand;
884      break;
885    case OT_Offset:
886      // The offsets are all encoded in a unsigned form, but in practice
887      // consumers use them signed. It's most certainly legacy due to
888      // the lack of signed variants in the first Dwarf standards.
889      OS << format(" %+" PRId64, int64_t(Operand));
890      break;
891    case OT_FactoredCodeOffset: // Always Unsigned
892      if (CodeAlignmentFactor)
893        OS << format(" %" PRId64, Operand * CodeAlignmentFactor);
894      else
895        OS << format(" %" PRId64 "*code_alignment_factor", Operand);
896      if (Address && CodeAlignmentFactor) {
897        *Address += Operand * CodeAlignmentFactor;
898        OS << format(" to 0x%" PRIx64, *Address);
899      }
900      break;
901    case OT_SignedFactDataOffset:
902      if (DataAlignmentFactor)
903        OS << format(" %" PRId64, int64_t(Operand) * DataAlignmentFactor);
904      else
905        OS << format(" %" PRId64 "*data_alignment_factor" , int64_t(Operand));
906      break;
907    case OT_UnsignedFactDataOffset:
908      if (DataAlignmentFactor)
909        OS << format(" %" PRId64, Operand * DataAlignmentFactor);
910      else
911        OS << format(" %" PRId64 "*data_alignment_factor" , Operand);
912      break;
913    case OT_Register:
914      OS << ' ';
915      printRegister(OS, DumpOpts, Operand);
916      break;
917    case OT_AddressSpace:
918      OS << format(" in addrspace%" PRId64, Operand);
919      break;
920    case OT_Expression:
921      assert(Instr.Expression && "missing DWARFExpression object");
922      OS << " ";
923      Instr.Expression->print(OS, DumpOpts, nullptr);
924      break;
925    }
926  }
927  
dump(raw_ostream & OS,DIDumpOptions DumpOpts,unsigned IndentLevel,std::optional<uint64_t> Address) const928  void CFIProgram::dump(raw_ostream &OS, DIDumpOptions DumpOpts,
929                        unsigned IndentLevel,
930                        std::optional<uint64_t> Address) const {
931    for (const auto &Instr : Instructions) {
932      uint8_t Opcode = Instr.Opcode;
933      OS.indent(2 * IndentLevel);
934      OS << callFrameString(Opcode) << ":";
935      for (unsigned i = 0; i < Instr.Ops.size(); ++i)
936        printOperand(OS, DumpOpts, Instr, i, Instr.Ops[i], Address);
937      OS << '\n';
938    }
939  }
940  
941  // Returns the CIE identifier to be used by the requested format.
942  // CIE ids for .debug_frame sections are defined in Section 7.24 of DWARFv5.
943  // For CIE ID in .eh_frame sections see
944  // https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html
getCIEId(bool IsDWARF64,bool IsEH)945  constexpr uint64_t getCIEId(bool IsDWARF64, bool IsEH) {
946    if (IsEH)
947      return 0;
948    if (IsDWARF64)
949      return DW64_CIE_ID;
950    return DW_CIE_ID;
951  }
952  
dump(raw_ostream & OS,DIDumpOptions DumpOpts) const953  void CIE::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const {
954    // A CIE with a zero length is a terminator entry in the .eh_frame section.
955    if (DumpOpts.IsEH && Length == 0) {
956      OS << format("%08" PRIx64, Offset) << " ZERO terminator\n";
957      return;
958    }
959  
960    OS << format("%08" PRIx64, Offset)
961       << format(" %0*" PRIx64, IsDWARF64 ? 16 : 8, Length)
962       << format(" %0*" PRIx64, IsDWARF64 && !DumpOpts.IsEH ? 16 : 8,
963                 getCIEId(IsDWARF64, DumpOpts.IsEH))
964       << " CIE\n"
965       << "  Format:                " << FormatString(IsDWARF64) << "\n";
966    if (DumpOpts.IsEH && Version != 1)
967      OS << "WARNING: unsupported CIE version\n";
968    OS << format("  Version:               %d\n", Version)
969       << "  Augmentation:          \"" << Augmentation << "\"\n";
970    if (Version >= 4) {
971      OS << format("  Address size:          %u\n", (uint32_t)AddressSize);
972      OS << format("  Segment desc size:     %u\n",
973                   (uint32_t)SegmentDescriptorSize);
974    }
975    OS << format("  Code alignment factor: %u\n", (uint32_t)CodeAlignmentFactor);
976    OS << format("  Data alignment factor: %d\n", (int32_t)DataAlignmentFactor);
977    OS << format("  Return address column: %d\n", (int32_t)ReturnAddressRegister);
978    if (Personality)
979      OS << format("  Personality Address: %016" PRIx64 "\n", *Personality);
980    if (!AugmentationData.empty()) {
981      OS << "  Augmentation data:    ";
982      for (uint8_t Byte : AugmentationData)
983        OS << ' ' << hexdigit(Byte >> 4) << hexdigit(Byte & 0xf);
984      OS << "\n";
985    }
986    OS << "\n";
987    CFIs.dump(OS, DumpOpts, /*IndentLevel=*/1, /*InitialLocation=*/{});
988    OS << "\n";
989  
990    if (Expected<UnwindTable> RowsOrErr = UnwindTable::create(this))
991      RowsOrErr->dump(OS, DumpOpts, 1);
992    else {
993      DumpOpts.RecoverableErrorHandler(joinErrors(
994          createStringError(errc::invalid_argument,
995                            "decoding the CIE opcodes into rows failed"),
996          RowsOrErr.takeError()));
997    }
998    OS << "\n";
999  }
1000  
dump(raw_ostream & OS,DIDumpOptions DumpOpts) const1001  void FDE::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const {
1002    OS << format("%08" PRIx64, Offset)
1003       << format(" %0*" PRIx64, IsDWARF64 ? 16 : 8, Length)
1004       << format(" %0*" PRIx64, IsDWARF64 && !DumpOpts.IsEH ? 16 : 8, CIEPointer)
1005       << " FDE cie=";
1006    if (LinkedCIE)
1007      OS << format("%08" PRIx64, LinkedCIE->getOffset());
1008    else
1009      OS << "<invalid offset>";
1010    OS << format(" pc=%08" PRIx64 "...%08" PRIx64 "\n", InitialLocation,
1011                 InitialLocation + AddressRange);
1012    OS << "  Format:       " << FormatString(IsDWARF64) << "\n";
1013    if (LSDAAddress)
1014      OS << format("  LSDA Address: %016" PRIx64 "\n", *LSDAAddress);
1015    CFIs.dump(OS, DumpOpts, /*IndentLevel=*/1, InitialLocation);
1016    OS << "\n";
1017  
1018    if (Expected<UnwindTable> RowsOrErr = UnwindTable::create(this))
1019      RowsOrErr->dump(OS, DumpOpts, 1);
1020    else {
1021      DumpOpts.RecoverableErrorHandler(joinErrors(
1022          createStringError(errc::invalid_argument,
1023                            "decoding the FDE opcodes into rows failed"),
1024          RowsOrErr.takeError()));
1025    }
1026    OS << "\n";
1027  }
1028  
DWARFDebugFrame(Triple::ArchType Arch,bool IsEH,uint64_t EHFrameAddress)1029  DWARFDebugFrame::DWARFDebugFrame(Triple::ArchType Arch,
1030      bool IsEH, uint64_t EHFrameAddress)
1031      : Arch(Arch), IsEH(IsEH), EHFrameAddress(EHFrameAddress) {}
1032  
1033  DWARFDebugFrame::~DWARFDebugFrame() = default;
1034  
dumpDataAux(DataExtractor Data,uint64_t Offset,int Length)1035  static void LLVM_ATTRIBUTE_UNUSED dumpDataAux(DataExtractor Data,
1036                                                uint64_t Offset, int Length) {
1037    errs() << "DUMP: ";
1038    for (int i = 0; i < Length; ++i) {
1039      uint8_t c = Data.getU8(&Offset);
1040      errs().write_hex(c); errs() << " ";
1041    }
1042    errs() << "\n";
1043  }
1044  
parse(DWARFDataExtractor Data)1045  Error DWARFDebugFrame::parse(DWARFDataExtractor Data) {
1046    uint64_t Offset = 0;
1047    DenseMap<uint64_t, CIE *> CIEs;
1048  
1049    while (Data.isValidOffset(Offset)) {
1050      uint64_t StartOffset = Offset;
1051  
1052      uint64_t Length;
1053      DwarfFormat Format;
1054      std::tie(Length, Format) = Data.getInitialLength(&Offset);
1055      bool IsDWARF64 = Format == DWARF64;
1056  
1057      // If the Length is 0, then this CIE is a terminator. We add it because some
1058      // dumper tools might need it to print something special for such entries
1059      // (e.g. llvm-objdump --dwarf=frames prints "ZERO terminator").
1060      if (Length == 0) {
1061        auto Cie = std::make_unique<CIE>(
1062            IsDWARF64, StartOffset, 0, 0, SmallString<8>(), 0, 0, 0, 0, 0,
1063            SmallString<8>(), 0, 0, std::nullopt, std::nullopt, Arch);
1064        CIEs[StartOffset] = Cie.get();
1065        Entries.push_back(std::move(Cie));
1066        break;
1067      }
1068  
1069      // At this point, Offset points to the next field after Length.
1070      // Length is the structure size excluding itself. Compute an offset one
1071      // past the end of the structure (needed to know how many instructions to
1072      // read).
1073      uint64_t StartStructureOffset = Offset;
1074      uint64_t EndStructureOffset = Offset + Length;
1075  
1076      // The Id field's size depends on the DWARF format
1077      Error Err = Error::success();
1078      uint64_t Id = Data.getRelocatedValue((IsDWARF64 && !IsEH) ? 8 : 4, &Offset,
1079                                           /*SectionIndex=*/nullptr, &Err);
1080      if (Err)
1081        return Err;
1082  
1083      if (Id == getCIEId(IsDWARF64, IsEH)) {
1084        uint8_t Version = Data.getU8(&Offset);
1085        const char *Augmentation = Data.getCStr(&Offset);
1086        StringRef AugmentationString(Augmentation ? Augmentation : "");
1087        uint8_t AddressSize = Version < 4 ? Data.getAddressSize() :
1088                                            Data.getU8(&Offset);
1089        Data.setAddressSize(AddressSize);
1090        uint8_t SegmentDescriptorSize = Version < 4 ? 0 : Data.getU8(&Offset);
1091        uint64_t CodeAlignmentFactor = Data.getULEB128(&Offset);
1092        int64_t DataAlignmentFactor = Data.getSLEB128(&Offset);
1093        uint64_t ReturnAddressRegister =
1094            Version == 1 ? Data.getU8(&Offset) : Data.getULEB128(&Offset);
1095  
1096        // Parse the augmentation data for EH CIEs
1097        StringRef AugmentationData("");
1098        uint32_t FDEPointerEncoding = DW_EH_PE_absptr;
1099        uint32_t LSDAPointerEncoding = DW_EH_PE_omit;
1100        std::optional<uint64_t> Personality;
1101        std::optional<uint32_t> PersonalityEncoding;
1102        if (IsEH) {
1103          std::optional<uint64_t> AugmentationLength;
1104          uint64_t StartAugmentationOffset;
1105          uint64_t EndAugmentationOffset;
1106  
1107          // Walk the augmentation string to get all the augmentation data.
1108          for (unsigned i = 0, e = AugmentationString.size(); i != e; ++i) {
1109            switch (AugmentationString[i]) {
1110            default:
1111              return createStringError(
1112                  errc::invalid_argument,
1113                  "unknown augmentation character %c in entry at 0x%" PRIx64,
1114                  AugmentationString[i], StartOffset);
1115            case 'L':
1116              LSDAPointerEncoding = Data.getU8(&Offset);
1117              break;
1118            case 'P': {
1119              if (Personality)
1120                return createStringError(
1121                    errc::invalid_argument,
1122                    "duplicate personality in entry at 0x%" PRIx64, StartOffset);
1123              PersonalityEncoding = Data.getU8(&Offset);
1124              Personality = Data.getEncodedPointer(
1125                  &Offset, *PersonalityEncoding,
1126                  EHFrameAddress ? EHFrameAddress + Offset : 0);
1127              break;
1128            }
1129            case 'R':
1130              FDEPointerEncoding = Data.getU8(&Offset);
1131              break;
1132            case 'S':
1133              // Current frame is a signal trampoline.
1134              break;
1135            case 'z':
1136              if (i)
1137                return createStringError(
1138                    errc::invalid_argument,
1139                    "'z' must be the first character at 0x%" PRIx64, StartOffset);
1140              // Parse the augmentation length first.  We only parse it if
1141              // the string contains a 'z'.
1142              AugmentationLength = Data.getULEB128(&Offset);
1143              StartAugmentationOffset = Offset;
1144              EndAugmentationOffset = Offset + *AugmentationLength;
1145              break;
1146            case 'B':
1147              // B-Key is used for signing functions associated with this
1148              // augmentation string
1149              break;
1150              // This stack frame contains MTE tagged data, so needs to be
1151              // untagged on unwind.
1152            case 'G':
1153              break;
1154            }
1155          }
1156  
1157          if (AugmentationLength) {
1158            if (Offset != EndAugmentationOffset)
1159              return createStringError(errc::invalid_argument,
1160                                       "parsing augmentation data at 0x%" PRIx64
1161                                       " failed",
1162                                       StartOffset);
1163            AugmentationData = Data.getData().slice(StartAugmentationOffset,
1164                                                    EndAugmentationOffset);
1165          }
1166        }
1167  
1168        auto Cie = std::make_unique<CIE>(
1169            IsDWARF64, StartOffset, Length, Version, AugmentationString,
1170            AddressSize, SegmentDescriptorSize, CodeAlignmentFactor,
1171            DataAlignmentFactor, ReturnAddressRegister, AugmentationData,
1172            FDEPointerEncoding, LSDAPointerEncoding, Personality,
1173            PersonalityEncoding, Arch);
1174        CIEs[StartOffset] = Cie.get();
1175        Entries.emplace_back(std::move(Cie));
1176      } else {
1177        // FDE
1178        uint64_t CIEPointer = Id;
1179        uint64_t InitialLocation = 0;
1180        uint64_t AddressRange = 0;
1181        std::optional<uint64_t> LSDAAddress;
1182        CIE *Cie = CIEs[IsEH ? (StartStructureOffset - CIEPointer) : CIEPointer];
1183  
1184        if (IsEH) {
1185          // The address size is encoded in the CIE we reference.
1186          if (!Cie)
1187            return createStringError(errc::invalid_argument,
1188                                     "parsing FDE data at 0x%" PRIx64
1189                                     " failed due to missing CIE",
1190                                     StartOffset);
1191          if (auto Val =
1192                  Data.getEncodedPointer(&Offset, Cie->getFDEPointerEncoding(),
1193                                         EHFrameAddress + Offset)) {
1194            InitialLocation = *Val;
1195          }
1196          if (auto Val = Data.getEncodedPointer(
1197                  &Offset, Cie->getFDEPointerEncoding(), 0)) {
1198            AddressRange = *Val;
1199          }
1200  
1201          StringRef AugmentationString = Cie->getAugmentationString();
1202          if (!AugmentationString.empty()) {
1203            // Parse the augmentation length and data for this FDE.
1204            uint64_t AugmentationLength = Data.getULEB128(&Offset);
1205  
1206            uint64_t EndAugmentationOffset = Offset + AugmentationLength;
1207  
1208            // Decode the LSDA if the CIE augmentation string said we should.
1209            if (Cie->getLSDAPointerEncoding() != DW_EH_PE_omit) {
1210              LSDAAddress = Data.getEncodedPointer(
1211                  &Offset, Cie->getLSDAPointerEncoding(),
1212                  EHFrameAddress ? Offset + EHFrameAddress : 0);
1213            }
1214  
1215            if (Offset != EndAugmentationOffset)
1216              return createStringError(errc::invalid_argument,
1217                                       "parsing augmentation data at 0x%" PRIx64
1218                                       " failed",
1219                                       StartOffset);
1220          }
1221        } else {
1222          InitialLocation = Data.getRelocatedAddress(&Offset);
1223          AddressRange = Data.getRelocatedAddress(&Offset);
1224        }
1225  
1226        Entries.emplace_back(new FDE(IsDWARF64, StartOffset, Length, CIEPointer,
1227                                     InitialLocation, AddressRange, Cie,
1228                                     LSDAAddress, Arch));
1229      }
1230  
1231      if (Error E =
1232              Entries.back()->cfis().parse(Data, &Offset, EndStructureOffset))
1233        return E;
1234  
1235      if (Offset != EndStructureOffset)
1236        return createStringError(
1237            errc::invalid_argument,
1238            "parsing entry instructions at 0x%" PRIx64 " failed", StartOffset);
1239    }
1240  
1241    return Error::success();
1242  }
1243  
getEntryAtOffset(uint64_t Offset) const1244  FrameEntry *DWARFDebugFrame::getEntryAtOffset(uint64_t Offset) const {
1245    auto It = partition_point(Entries, [=](const std::unique_ptr<FrameEntry> &E) {
1246      return E->getOffset() < Offset;
1247    });
1248    if (It != Entries.end() && (*It)->getOffset() == Offset)
1249      return It->get();
1250    return nullptr;
1251  }
1252  
dump(raw_ostream & OS,DIDumpOptions DumpOpts,std::optional<uint64_t> Offset) const1253  void DWARFDebugFrame::dump(raw_ostream &OS, DIDumpOptions DumpOpts,
1254                             std::optional<uint64_t> Offset) const {
1255    DumpOpts.IsEH = IsEH;
1256    if (Offset) {
1257      if (auto *Entry = getEntryAtOffset(*Offset))
1258        Entry->dump(OS, DumpOpts);
1259      return;
1260    }
1261  
1262    OS << "\n";
1263    for (const auto &Entry : Entries)
1264      Entry->dump(OS, DumpOpts);
1265  }
1266