1 //===-- RegisterContextUnwind.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_TARGET_REGISTERCONTEXTUNWIND_H 10 #define LLDB_TARGET_REGISTERCONTEXTUNWIND_H 11 12 #include <vector> 13 14 #include "lldb/Symbol/SymbolContext.h" 15 #include "lldb/Symbol/UnwindPlan.h" 16 #include "lldb/Target/RegisterContext.h" 17 #include "lldb/Target/RegisterNumber.h" 18 #include "lldb/Target/UnwindLLDB.h" 19 #include "lldb/lldb-private.h" 20 21 namespace lldb_private { 22 23 class UnwindLLDB; 24 25 class RegisterContextUnwind : public lldb_private::RegisterContext { 26 public: 27 typedef std::shared_ptr<RegisterContextUnwind> SharedPtr; 28 29 RegisterContextUnwind(lldb_private::Thread &thread, 30 const SharedPtr &next_frame, 31 lldb_private::SymbolContext &sym_ctx, 32 uint32_t frame_number, 33 lldb_private::UnwindLLDB &unwind_lldb); 34 35 ~RegisterContextUnwind() override = default; 36 37 void InvalidateAllRegisters() override; 38 39 size_t GetRegisterCount() override; 40 41 const lldb_private::RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override; 42 43 size_t GetRegisterSetCount() override; 44 45 const lldb_private::RegisterSet *GetRegisterSet(size_t reg_set) override; 46 47 bool ReadRegister(const lldb_private::RegisterInfo *reg_info, 48 lldb_private::RegisterValue &value) override; 49 50 bool WriteRegister(const lldb_private::RegisterInfo *reg_info, 51 const lldb_private::RegisterValue &value) override; 52 53 bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override; 54 55 bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override; 56 57 uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, 58 uint32_t num) override; 59 60 bool IsValid() const; 61 62 bool IsTrapHandlerFrame() const; 63 64 bool GetCFA(lldb::addr_t &cfa); 65 66 bool GetStartPC(lldb::addr_t &start_pc); 67 68 bool ReadPC(lldb::addr_t &start_pc); 69 70 private: 71 enum FrameType { 72 eNormalFrame, 73 eTrapHandlerFrame, 74 eDebuggerFrame, // a debugger inferior function call frame; we get caller's 75 // registers from debugger 76 eSkipFrame, // The unwind resulted in a bogus frame but may get back on 77 // track so we don't want to give up yet 78 eNotAValidFrame // this frame is invalid for some reason - most likely it is 79 // past the top (end) of the stack 80 }; 81 82 // UnwindLLDB needs to pass around references to RegisterLocations 83 friend class UnwindLLDB; 84 85 // Returns true if we have an unwind loop -- the same stack frame unwinding 86 // multiple times. 87 bool CheckIfLoopingStack(); 88 89 // Indicates whether this frame is frame zero -- the currently 90 // executing frame -- or not. 91 bool IsFrameZero() const; 92 93 void InitializeZerothFrame(); 94 95 void InitializeNonZerothFrame(); 96 97 SharedPtr GetNextFrame() const; 98 99 SharedPtr GetPrevFrame() const; 100 101 // A SkipFrame occurs when the unwind out of frame 0 didn't go right -- we've 102 // got one bogus frame at frame #1. 103 // There is a good chance we'll get back on track if we follow the frame 104 // pointer chain (or whatever is appropriate 105 // on this ABI) so we allow one invalid frame to be in the stack. Ideally 106 // we'll mark this frame specially at some 107 // point and indicate to the user that the unwinder had a hiccup. Often when 108 // this happens we will miss a frame of 109 // the program's actual stack in the unwind and we want to flag that for the 110 // user somehow. 111 bool IsSkipFrame() const; 112 113 /// Determines if a SymbolContext is a trap handler or not 114 /// 115 /// Given a SymbolContext, determines if this is a trap handler function 116 /// aka asynchronous signal handler. 117 /// 118 /// \return 119 /// Returns true if the SymbolContext is a trap handler. 120 bool IsTrapHandlerSymbol(lldb_private::Process *process, 121 const lldb_private::SymbolContext &m_sym_ctx) const; 122 123 /// Check if the given unwind plan indicates a signal trap handler, and 124 /// update frame type and symbol context if so. 125 void PropagateTrapHandlerFlagFromUnwindPlan(lldb::UnwindPlanSP unwind_plan); 126 127 // Provide a location for where THIS function saved the CALLER's register 128 // value 129 // Or a frame "below" this one saved it, i.e. a function called by this one, 130 // preserved a register that this 131 // function didn't modify/use. 132 // 133 // The RegisterLocation type may be set to eRegisterNotAvailable -- this will 134 // happen for a volatile register 135 // being queried mid-stack. Instead of floating frame 0's contents of that 136 // register up the stack (which may 137 // or may not be the value of that reg when the function was executing), we 138 // won't return any value. 139 // 140 // If a non-volatile register (a "preserved" register) is requested mid-stack 141 // and no frames "below" the requested 142 // stack have saved the register anywhere, it is safe to assume that frame 0's 143 // register values are still the same 144 // as the requesting frame's. 145 lldb_private::UnwindLLDB::RegisterSearchResult 146 SavedLocationForRegister(uint32_t lldb_regnum, 147 lldb_private::UnwindLLDB::RegisterLocation ®loc); 148 149 bool ReadRegisterValueFromRegisterLocation( 150 lldb_private::UnwindLLDB::RegisterLocation regloc, 151 const lldb_private::RegisterInfo *reg_info, 152 lldb_private::RegisterValue &value); 153 154 bool WriteRegisterValueToRegisterLocation( 155 lldb_private::UnwindLLDB::RegisterLocation regloc, 156 const lldb_private::RegisterInfo *reg_info, 157 const lldb_private::RegisterValue &value); 158 159 /// If the unwind has to the caller frame has failed, try something else 160 /// 161 /// If lldb is using an assembly language based UnwindPlan for a frame and 162 /// the unwind to the caller frame fails, try falling back to a generic 163 /// UnwindPlan (architecture default unwindplan) to see if that might work 164 /// better. This is mostly helping to work around problems where the 165 /// assembly language inspection fails on hand-written assembly code. 166 /// 167 /// \return 168 /// Returns true if a fallback unwindplan was found & was installed. 169 bool TryFallbackUnwindPlan(); 170 171 /// Switch to the fallback unwind plan unconditionally without any safety 172 /// checks that it is providing better results than the normal unwind plan. 173 /// 174 /// The only time it is valid to call this method is if the full unwindplan is 175 /// found to be fundamentally incorrect/impossible. 176 /// 177 /// Returns true if it was able to install the fallback unwind plan. 178 bool ForceSwitchToFallbackUnwindPlan(); 179 180 // Get the contents of a general purpose (address-size) register for this 181 // frame 182 // (usually retrieved from the next frame) 183 bool ReadGPRValue(lldb::RegisterKind register_kind, uint32_t regnum, 184 lldb::addr_t &value); 185 186 bool ReadGPRValue(const RegisterNumber ®_num, lldb::addr_t &value); 187 188 // Get the Frame Address register for a given frame. 189 bool ReadFrameAddress(lldb::RegisterKind register_kind, 190 UnwindPlan::Row::FAValue &fa, lldb::addr_t &address); 191 192 lldb::UnwindPlanSP GetFastUnwindPlanForFrame(); 193 194 lldb::UnwindPlanSP GetFullUnwindPlanForFrame(); 195 196 void UnwindLogMsg(const char *fmt, ...) __attribute__((format(printf, 2, 3))); 197 198 void UnwindLogMsgVerbose(const char *fmt, ...) 199 __attribute__((format(printf, 2, 3))); 200 201 bool IsUnwindPlanValidForCurrentPC(lldb::UnwindPlanSP unwind_plan_sp, 202 int &valid_pc_offset); 203 204 lldb::addr_t GetReturnAddressHint(int32_t plan_offset); 205 206 lldb_private::Thread &m_thread; 207 208 /// 209 // The following tell us how to retrieve the CALLER's register values (ie the 210 // "previous" frame, aka the frame above) 211 // i.e. where THIS frame saved them 212 /// 213 214 lldb::UnwindPlanSP m_fast_unwind_plan_sp; // may be NULL 215 lldb::UnwindPlanSP m_full_unwind_plan_sp; 216 lldb::UnwindPlanSP m_fallback_unwind_plan_sp; // may be NULL 217 218 bool m_all_registers_available; // Can we retrieve all regs or just 219 // nonvolatile regs? 220 int m_frame_type; // enum FrameType 221 222 lldb::addr_t m_cfa; 223 lldb::addr_t m_afa; 224 lldb_private::Address m_start_pc; 225 lldb_private::Address m_current_pc; 226 227 int m_current_offset; // how far into the function we've executed; -1 if 228 // unknown 229 // 0 if no instructions have been executed yet. 230 231 int m_current_offset_backed_up_one; // how far into the function we've 232 // executed; -1 if unknown 233 // 0 if no instructions have been executed yet. 234 // On architectures where the return address on the stack points 235 // to the instruction after the CALL, this value will have 1 236 // subtracted from it. Else a function that ends in a CALL will 237 // have an offset pointing into the next function's address range. 238 // m_current_pc has the actual address of the "current" pc. 239 240 lldb_private::SymbolContext &m_sym_ctx; 241 bool m_sym_ctx_valid; // if ResolveSymbolContextForAddress fails, don't try to 242 // use m_sym_ctx 243 244 uint32_t m_frame_number; // What stack frame this RegisterContext is 245 246 std::map<uint32_t, lldb_private::UnwindLLDB::RegisterLocation> 247 m_registers; // where to find reg values for this frame 248 249 lldb_private::UnwindLLDB &m_parent_unwind; // The UnwindLLDB that is creating 250 // this RegisterContextUnwind 251 252 RegisterContextUnwind(const RegisterContextUnwind &) = delete; 253 const RegisterContextUnwind & 254 operator=(const RegisterContextUnwind &) = delete; 255 }; 256 257 } // namespace lldb_private 258 259 #endif // LLDB_TARGET_REGISTERCONTEXTUNWIND_H 260