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 RegisterLocations 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 RegisterLocation type may be set to eRegisterNotAvailable -- this will 139 // happen for a volatile register 140 // being queried mid-stack. Instead of floating frame 0's contents of that 141 // register up the stack (which may 142 // or may not be the value of that reg when the function was executing), we 143 // won't return any value. 144 // 145 // If a non-volatile register (a "preserved" register) is requested mid-stack 146 // and no frames "below" the requested 147 // stack have saved the register anywhere, it is safe to assume that frame 0's 148 // register values are still the same 149 // as the requesting frame's. 150 lldb_private::UnwindLLDB::RegisterSearchResult 151 SavedLocationForRegister(uint32_t lldb_regnum, 152 lldb_private::UnwindLLDB::RegisterLocation ®loc); 153 154 bool ReadRegisterValueFromRegisterLocation( 155 lldb_private::UnwindLLDB::RegisterLocation regloc, 156 const lldb_private::RegisterInfo *reg_info, 157 lldb_private::RegisterValue &value); 158 159 bool WriteRegisterValueToRegisterLocation( 160 lldb_private::UnwindLLDB::RegisterLocation regloc, 161 const lldb_private::RegisterInfo *reg_info, 162 const lldb_private::RegisterValue &value); 163 164 /// If the unwind has to the caller frame has failed, try something else 165 /// 166 /// If lldb is using an assembly language based UnwindPlan for a frame and 167 /// the unwind to the caller frame fails, try falling back to a generic 168 /// UnwindPlan (architecture default unwindplan) to see if that might work 169 /// better. This is mostly helping to work around problems where the 170 /// assembly language inspection fails on hand-written assembly code. 171 /// 172 /// \return 173 /// Returns true if a fallback unwindplan was found & was installed. 174 bool TryFallbackUnwindPlan(); 175 176 /// Switch to the fallback unwind plan unconditionally without any safety 177 /// checks that it is providing better results than the normal unwind plan. 178 /// 179 /// The only time it is valid to call this method is if the full unwindplan is 180 /// found to be fundamentally incorrect/impossible. 181 /// 182 /// Returns true if it was able to install the fallback unwind plan. 183 bool ForceSwitchToFallbackUnwindPlan(); 184 185 // Get the contents of a general purpose (address-size) register for this 186 // frame 187 // (usually retrieved from the next frame) 188 bool ReadGPRValue(lldb::RegisterKind register_kind, uint32_t regnum, 189 lldb::addr_t &value); 190 191 bool ReadGPRValue(const RegisterNumber ®_num, lldb::addr_t &value); 192 193 // Get the Frame Address register for a given frame. 194 bool ReadFrameAddress(lldb::RegisterKind register_kind, 195 UnwindPlan::Row::FAValue &fa, lldb::addr_t &address); 196 197 lldb::UnwindPlanSP GetFastUnwindPlanForFrame(); 198 199 lldb::UnwindPlanSP GetFullUnwindPlanForFrame(); 200 201 void UnwindLogMsg(const char *fmt, ...) __attribute__((format(printf, 2, 3))); 202 203 void UnwindLogMsgVerbose(const char *fmt, ...) 204 __attribute__((format(printf, 2, 3))); 205 206 bool IsUnwindPlanValidForCurrentPC(lldb::UnwindPlanSP unwind_plan_sp); 207 208 lldb::addr_t GetReturnAddressHint(int32_t plan_offset); 209 210 lldb_private::Thread &m_thread; 211 212 /// 213 // The following tell us how to retrieve the CALLER's register values (ie the 214 // "previous" frame, aka the frame above) 215 // i.e. where THIS frame saved them 216 /// 217 218 lldb::UnwindPlanSP m_fast_unwind_plan_sp; // may be NULL 219 lldb::UnwindPlanSP m_full_unwind_plan_sp; 220 lldb::UnwindPlanSP m_fallback_unwind_plan_sp; // may be NULL 221 222 bool m_all_registers_available; // Can we retrieve all regs or just 223 // nonvolatile regs? 224 int m_frame_type; // enum FrameType 225 226 lldb::addr_t m_cfa; 227 lldb::addr_t m_afa; 228 lldb_private::Address m_start_pc; 229 lldb_private::Address m_current_pc; 230 231 int m_current_offset; // how far into the function we've executed; -1 if 232 // unknown 233 // 0 if no instructions have been executed yet. 234 235 // 0 if no instructions have been executed yet. 236 // On architectures where the return address on the stack points 237 // to the instruction after the CALL, this value will have 1 238 // subtracted from it. Else a function that ends in a CALL will 239 // have an offset pointing into the next function's address range. 240 // m_current_pc has the actual address of the "current" pc. 241 int m_current_offset_backed_up_one; // how far into the function we've 242 // executed; -1 if unknown 243 244 bool m_behaves_like_zeroth_frame; // this frame behaves like frame zero 245 246 lldb_private::SymbolContext &m_sym_ctx; 247 bool m_sym_ctx_valid; // if ResolveSymbolContextForAddress fails, don't try to 248 // use m_sym_ctx 249 250 uint32_t m_frame_number; // What stack frame this RegisterContext is 251 252 std::map<uint32_t, lldb_private::UnwindLLDB::RegisterLocation> 253 m_registers; // where to find reg values for this frame 254 255 lldb_private::UnwindLLDB &m_parent_unwind; // The UnwindLLDB that is creating 256 // this RegisterContextUnwind 257 258 RegisterContextUnwind(const RegisterContextUnwind &) = delete; 259 const RegisterContextUnwind & 260 operator=(const RegisterContextUnwind &) = delete; 261 }; 262 263 } // namespace lldb_private 264 265 #endif // LLDB_TARGET_REGISTERCONTEXTUNWIND_H 266