1 //===-- DWARFCallFrameInfo.h ------------------------------------*- C++ -*-===// 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 #ifndef LLDB_SYMBOL_DWARFCALLFRAMEINFO_H 10 #define LLDB_SYMBOL_DWARFCALLFRAMEINFO_H 11 12 #include <map> 13 #include <mutex> 14 #include <optional> 15 16 #include "lldb/Core/AddressRange.h" 17 #include "lldb/Core/dwarf.h" 18 #include "lldb/Symbol/ObjectFile.h" 19 #include "lldb/Symbol/UnwindPlan.h" 20 #include "lldb/Utility/Flags.h" 21 #include "lldb/Utility/RangeMap.h" 22 #include "lldb/Utility/VMRange.h" 23 #include "lldb/lldb-private.h" 24 25 namespace lldb_private { 26 27 // DWARFCallFrameInfo is a class which can read eh_frame and DWARF Call Frame 28 // Information FDEs. It stores little information internally. Only two APIs 29 // are exported - one to find the high/low pc values of a function given a text 30 // address via the information in the eh_frame / debug_frame, and one to 31 // generate an UnwindPlan based on the FDE in the eh_frame / debug_frame 32 // section. 33 34 class DWARFCallFrameInfo { 35 public: 36 enum Type { EH, DWARF }; 37 38 DWARFCallFrameInfo(ObjectFile &objfile, lldb::SectionSP §ion, Type type); 39 40 ~DWARFCallFrameInfo() = default; 41 42 // Locate an AddressRange that includes the provided Address in this object's 43 // eh_frame/debug_info Returns true if a range is found to cover that 44 // address. 45 bool GetAddressRange(Address addr, AddressRange &range); 46 47 /// Return an UnwindPlan based on the call frame information encoded in the 48 /// FDE of this DWARFCallFrameInfo section. The returned plan will be valid 49 /// (at least) for the given address. 50 std::unique_ptr<UnwindPlan> GetUnwindPlan(const Address &addr); 51 52 /// Return an UnwindPlan based on the call frame information encoded in the 53 /// FDE of this DWARFCallFrameInfo section. The returned plan will be valid 54 /// (at least) for some address in the given ranges. If no unwind information 55 /// is found, nullptr is returned. \a addr represents the entry point of the 56 /// function. It corresponds to the offset zero in the returned UnwindPlan. 57 std::unique_ptr<UnwindPlan> GetUnwindPlan(llvm::ArrayRef<AddressRange> ranges, 58 const Address &addr); 59 60 typedef RangeVector<lldb::addr_t, uint32_t> FunctionAddressAndSizeVector; 61 62 // Build a vector of file address and size for all functions in this Module 63 // based on the eh_frame FDE entries. 64 // 65 // The eh_frame information can be a useful source of file address and size 66 // of the functions in a Module. Often a binary's non-exported symbols are 67 // stripped before shipping so lldb won't know the start addr / size of many 68 // functions in the Module. But the eh_frame can help to give the addresses 69 // of these stripped symbols, at least. 70 // 71 // \param[out] function_info 72 // A vector provided by the caller is filled out. May be empty if no 73 // FDEs/no eh_frame 74 // is present in this Module. 75 76 void 77 GetFunctionAddressAndSizeVector(FunctionAddressAndSizeVector &function_info); 78 79 void ForEachFDEEntries( 80 const std::function<bool(lldb::addr_t, uint32_t, dw_offset_t)> &callback); 81 82 private: 83 enum { CFI_AUG_MAX_SIZE = 8, CFI_HEADER_SIZE = 8 }; 84 enum CFIVersion { 85 CFI_VERSION1 = 1, // DWARF v.2 86 CFI_VERSION3 = 3, // DWARF v.3 87 CFI_VERSION4 = 4 // DWARF v.4, v.5 88 }; 89 90 struct CIE { 91 dw_offset_t cie_offset; 92 uint8_t version; 93 char augmentation[CFI_AUG_MAX_SIZE]; // This is typically empty or very 94 // short. 95 uint8_t address_size = sizeof(uint32_t); // The size of a target address. 96 uint8_t segment_size = 0; // The size of a segment selector. 97 98 uint32_t code_align; 99 int32_t data_align; 100 uint32_t return_addr_reg_num; 101 dw_offset_t inst_offset; // offset of CIE instructions in mCFIData 102 uint32_t inst_length; // length of CIE instructions in mCFIData 103 uint8_t ptr_encoding; 104 uint8_t lsda_addr_encoding; // The encoding of the LSDA address in the FDE 105 // augmentation data 106 lldb::addr_t personality_loc; // (file) address of the pointer to the 107 // personality routine 108 lldb_private::UnwindPlan::Row initial_row; 109 CIECIE110 CIE(dw_offset_t offset) 111 : cie_offset(offset), version(-1), code_align(0), data_align(0), 112 return_addr_reg_num(LLDB_INVALID_REGNUM), inst_offset(0), 113 inst_length(0), ptr_encoding(0), 114 lsda_addr_encoding(llvm::dwarf::DW_EH_PE_omit), 115 personality_loc(LLDB_INVALID_ADDRESS) {} 116 }; 117 118 typedef std::shared_ptr<CIE> CIESP; 119 120 typedef std::map<dw_offset_t, CIESP> cie_map_t; 121 122 // Start address (file address), size, offset of FDE location used for 123 // finding an FDE for a given File address; the start address field is an 124 // offset into an individual Module. 125 typedef RangeDataVector<lldb::addr_t, uint32_t, dw_offset_t> FDEEntryMap; 126 127 bool IsEHFrame() const; 128 129 std::optional<FDEEntryMap::Entry> 130 GetFirstFDEEntryInRange(const AddressRange &range); 131 132 void GetFDEIndex(); 133 134 /// Parsed representation of a Frame Descriptor Entry. 135 struct FDE { 136 AddressRange range; 137 bool for_signal_trap = false; 138 uint32_t return_addr_reg_num = LLDB_INVALID_REGNUM; 139 std::vector<UnwindPlan::Row> rows; 140 }; 141 std::optional<FDE> ParseFDE(dw_offset_t offset, const Address &startaddr); 142 143 const CIE *GetCIE(dw_offset_t cie_offset); 144 145 void GetCFIData(); 146 147 // Applies the specified DWARF opcode to the given row. This function handle 148 // the commands operates only on a single row (these are the ones what can 149 // appear both in 150 // CIE and in FDE). 151 // Returns true if the opcode is handled and false otherwise. 152 bool HandleCommonDwarfOpcode(uint8_t primary_opcode, uint8_t extended_opcode, 153 int32_t data_align, lldb::offset_t &offset, 154 UnwindPlan::Row &row); 155 156 ObjectFile &m_objfile; 157 lldb::SectionSP m_section_sp; 158 Flags m_flags = 0; 159 cie_map_t m_cie_map; 160 161 DataExtractor m_cfi_data; 162 bool m_cfi_data_initialized = false; // only copy the section into the DE once 163 164 FDEEntryMap m_fde_index; 165 bool m_fde_index_initialized = false; // only scan the section for FDEs once 166 std::mutex m_fde_index_mutex; // and isolate the thread that does it 167 168 Type m_type; 169 170 CIESP 171 ParseCIE(const dw_offset_t cie_offset); 172 GetRegisterKind()173 lldb::RegisterKind GetRegisterKind() const { 174 return m_type == EH ? lldb::eRegisterKindEHFrame : lldb::eRegisterKindDWARF; 175 } 176 }; 177 178 } // namespace lldb_private 179 180 #endif // LLDB_SYMBOL_DWARFCALLFRAMEINFO_H 181