1 //===-- UnwindAssemblyInstEmulation.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_SOURCE_PLUGINS_UNWINDASSEMBLY_INSTEMULATION_UNWINDASSEMBLYINSTEMULATION_H 10 #define LLDB_SOURCE_PLUGINS_UNWINDASSEMBLY_INSTEMULATION_UNWINDASSEMBLYINSTEMULATION_H 11 12 #include "lldb/Core/EmulateInstruction.h" 13 #include "lldb/Symbol/UnwindPlan.h" 14 #include "lldb/Target/UnwindAssembly.h" 15 #include "lldb/Utility/RegisterValue.h" 16 #include "lldb/lldb-private.h" 17 18 class UnwindAssemblyInstEmulation : public lldb_private::UnwindAssembly { 19 public: 20 ~UnwindAssemblyInstEmulation() override = default; 21 22 bool GetNonCallSiteUnwindPlanFromAssembly( 23 lldb_private::AddressRange &func, lldb_private::Thread &thread, 24 lldb_private::UnwindPlan &unwind_plan) override; 25 26 bool 27 GetNonCallSiteUnwindPlanFromAssembly(lldb_private::AddressRange &func, 28 uint8_t *opcode_data, size_t opcode_size, 29 lldb_private::UnwindPlan &unwind_plan); 30 31 bool 32 AugmentUnwindPlanFromCallSite(lldb_private::AddressRange &func, 33 lldb_private::Thread &thread, 34 lldb_private::UnwindPlan &unwind_plan) override; 35 36 bool GetFastUnwindPlan(lldb_private::AddressRange &func, 37 lldb_private::Thread &thread, 38 lldb_private::UnwindPlan &unwind_plan) override; 39 40 // thread may be NULL in which case we only use the Target (e.g. if this is 41 // called pre-process-launch). 42 bool 43 FirstNonPrologueInsn(lldb_private::AddressRange &func, 44 const lldb_private::ExecutionContext &exe_ctx, 45 lldb_private::Address &first_non_prologue_insn) override; 46 47 static lldb_private::UnwindAssembly * 48 CreateInstance(const lldb_private::ArchSpec &arch); 49 50 // PluginInterface protocol 51 static void Initialize(); 52 53 static void Terminate(); 54 55 static lldb_private::ConstString GetPluginNameStatic(); 56 57 static const char *GetPluginDescriptionStatic(); 58 59 lldb_private::ConstString GetPluginName() override; 60 61 uint32_t GetPluginVersion() override; 62 63 private: 64 // Call CreateInstance to get an instance of this class 65 UnwindAssemblyInstEmulation(const lldb_private::ArchSpec &arch, 66 lldb_private::EmulateInstruction *inst_emulator) 67 : UnwindAssembly(arch), m_inst_emulator_up(inst_emulator), 68 m_range_ptr(nullptr), m_unwind_plan_ptr(nullptr), m_curr_row(), 69 m_cfa_reg_info(), m_fp_is_cfa(false), m_register_values(), 70 m_pushed_regs(), m_curr_row_modified(false), 71 m_forward_branch_offset(0) { 72 if (m_inst_emulator_up.get()) { 73 m_inst_emulator_up->SetBaton(this); 74 m_inst_emulator_up->SetCallbacks(ReadMemory, WriteMemory, ReadRegister, 75 WriteRegister); 76 } 77 } 78 79 static size_t 80 ReadMemory(lldb_private::EmulateInstruction *instruction, void *baton, 81 const lldb_private::EmulateInstruction::Context &context, 82 lldb::addr_t addr, void *dst, size_t length); 83 84 static size_t 85 WriteMemory(lldb_private::EmulateInstruction *instruction, void *baton, 86 const lldb_private::EmulateInstruction::Context &context, 87 lldb::addr_t addr, const void *dst, size_t length); 88 89 static bool ReadRegister(lldb_private::EmulateInstruction *instruction, 90 void *baton, 91 const lldb_private::RegisterInfo *reg_info, 92 lldb_private::RegisterValue ®_value); 93 94 static bool 95 WriteRegister(lldb_private::EmulateInstruction *instruction, void *baton, 96 const lldb_private::EmulateInstruction::Context &context, 97 const lldb_private::RegisterInfo *reg_info, 98 const lldb_private::RegisterValue ®_value); 99 100 // size_t 101 // ReadMemory (lldb_private::EmulateInstruction *instruction, 102 // const lldb_private::EmulateInstruction::Context &context, 103 // lldb::addr_t addr, 104 // void *dst, 105 // size_t length); 106 107 size_t WriteMemory(lldb_private::EmulateInstruction *instruction, 108 const lldb_private::EmulateInstruction::Context &context, 109 lldb::addr_t addr, const void *dst, size_t length); 110 111 bool ReadRegister(lldb_private::EmulateInstruction *instruction, 112 const lldb_private::RegisterInfo *reg_info, 113 lldb_private::RegisterValue ®_value); 114 115 bool WriteRegister(lldb_private::EmulateInstruction *instruction, 116 const lldb_private::EmulateInstruction::Context &context, 117 const lldb_private::RegisterInfo *reg_info, 118 const lldb_private::RegisterValue ®_value); 119 120 static uint64_t 121 MakeRegisterKindValuePair(const lldb_private::RegisterInfo ®_info); 122 123 void SetRegisterValue(const lldb_private::RegisterInfo ®_info, 124 const lldb_private::RegisterValue ®_value); 125 126 bool GetRegisterValue(const lldb_private::RegisterInfo ®_info, 127 lldb_private::RegisterValue ®_value); 128 129 std::unique_ptr<lldb_private::EmulateInstruction> m_inst_emulator_up; 130 lldb_private::AddressRange *m_range_ptr; 131 lldb_private::UnwindPlan *m_unwind_plan_ptr; 132 lldb_private::UnwindPlan::RowSP m_curr_row; 133 typedef std::map<uint64_t, uint64_t> PushedRegisterToAddrMap; 134 uint64_t m_initial_sp; 135 lldb_private::RegisterInfo m_cfa_reg_info; 136 bool m_fp_is_cfa; 137 typedef std::map<uint64_t, lldb_private::RegisterValue> RegisterValueMap; 138 RegisterValueMap m_register_values; 139 PushedRegisterToAddrMap m_pushed_regs; 140 141 // While processing the instruction stream, we need to communicate some state 142 // change 143 // information up to the higher level loop that makes decisions about how to 144 // push 145 // the unwind instructions for the UnwindPlan we're constructing. 146 147 // The instruction we're processing updated the UnwindPlan::Row contents 148 bool m_curr_row_modified; 149 // The instruction is branching forward with the given offset. 0 value means 150 // no branching. 151 uint32_t m_forward_branch_offset; 152 }; 153 154 #endif // LLDB_SOURCE_PLUGINS_UNWINDASSEMBLY_INSTEMULATION_UNWINDASSEMBLYINSTEMULATION_H 155