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
21namespace lldb_private {
22
23class UnwindLLDB;
24
25class RegisterContextUnwind : public lldb_private::RegisterContext {
26public:
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
75private:
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 &regloc);
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 &reg_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

source code of lldb/include/lldb/Target/RegisterContextUnwind.h