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