LLDB  mainline
RegisterContextUnwind.h
Go to the documentation of this file.
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 
15 #include "lldb/Symbol/UnwindPlan.h"
18 #include "lldb/Target/UnwindLLDB.h"
19 #include "lldb/lldb-private.h"
20 
21 namespace lldb_private {
22 
23 class UnwindLLDB;
24 
26 public:
27  typedef std::shared_ptr<RegisterContextUnwind> SharedPtr;
28 
30  const SharedPtr &next_frame,
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 
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 {
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 
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.
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.
148 
151  const lldb_private::RegisterInfo *reg_info,
153 
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.
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 &reg_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 
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
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 
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 
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 
253  const RegisterContextUnwind &
254  operator=(const RegisterContextUnwind &) = delete;
255 };
256 
257 } // namespace lldb_private
258 
259 #endif // LLDB_TARGET_REGISTERCONTEXTUNWIND_H
uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, uint32_t num) override
Convert from a given register numbering scheme to the lldb register numbering scheme.
void void UnwindLogMsgVerbose(const char *fmt,...) __attribute__((format(printf
A class that represents a running process on the host machine.
lldb_private::UnwindLLDB::RegisterSearchResult SavedLocationForRegister(uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation &regloc)
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:33
RegisterContextUnwind(lldb_private::Thread &thread, const SharedPtr &next_frame, lldb_private::SymbolContext &sym_ctx, uint32_t frame_number, lldb_private::UnwindLLDB &unwind_lldb)
void PropagateTrapHandlerFlagFromUnwindPlan(lldb::UnwindPlanSP unwind_plan)
Check if the given unwind plan indicates a signal trap handler, and update frame type and symbol cont...
lldb_private::UnwindLLDB & m_parent_unwind
lldb::addr_t GetReturnAddressHint(int32_t plan_offset)
bool ReadRegister(const lldb_private::RegisterInfo *reg_info, lldb_private::RegisterValue &value) override
~RegisterContextUnwind() override=default
bool WriteRegisterValueToRegisterLocation(lldb_private::UnwindLLDB::RegisterLocation regloc, const lldb_private::RegisterInfo *reg_info, const lldb_private::RegisterValue &value)
std::shared_ptr< RegisterContextUnwind > SharedPtr
RegisterKind
Register numbering types.
lldb_private::SymbolContext & m_sym_ctx
void UnwindLogMsg(const char *fmt,...) __attribute__((format(printf
bool TryFallbackUnwindPlan()
If the unwind has to the caller frame has failed, try something else.
bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override
A plug-in interface definition class for debugging a process.
Definition: Process.h:362
void void bool IsUnwindPlanValidForCurrentPC(lldb::UnwindPlanSP unwind_plan_sp, int &valid_pc_offset)
A section + offset based address class.
Definition: Address.h:59
bool ReadFrameAddress(lldb::RegisterKind register_kind, UnwindPlan::Row::FAValue &fa, lldb::addr_t &address)
const lldb_private::RegisterInfo * GetRegisterInfoAtIndex(size_t reg) override
uint64_t addr_t
Definition: lldb-types.h:83
std::map< uint32_t, lldb_private::UnwindLLDB::RegisterLocation > m_registers
bool IsTrapHandlerSymbol(lldb_private::Process *process, const lldb_private::SymbolContext &m_sym_ctx) const
Determines if a SymbolContext is a trap handler or not.
Definition: SBAddress.h:15
A class to represent register numbers, and able to convert between different register numbering schem...
const lldb_private::RegisterSet * GetRegisterSet(size_t reg_set) override
bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override
bool ReadGPRValue(lldb::RegisterKind register_kind, uint32_t regnum, lldb::addr_t &value)
bool ReadRegisterValueFromRegisterLocation(lldb_private::UnwindLLDB::RegisterLocation regloc, const lldb_private::RegisterInfo *reg_info, lldb_private::RegisterValue &value)
bool WriteRegister(const lldb_private::RegisterInfo *reg_info, const lldb_private::RegisterValue &value) override
bool ForceSwitchToFallbackUnwindPlan()
Switch to the fallback unwind plan unconditionally without any safety checks that it is providing bet...