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