1//===-- RegisterContextUnwind.cpp -----------------------------------------===//
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#include "lldb/Target/RegisterContextUnwind.h"
10#include "lldb/Core/Address.h"
11#include "lldb/Core/AddressRange.h"
12#include "lldb/Core/Module.h"
13#include "lldb/Core/Value.h"
14#include "lldb/Expression/DWARFExpressionList.h"
15#include "lldb/Symbol/ArmUnwindInfo.h"
16#include "lldb/Symbol/CallFrameInfo.h"
17#include "lldb/Symbol/DWARFCallFrameInfo.h"
18#include "lldb/Symbol/FuncUnwinders.h"
19#include "lldb/Symbol/Function.h"
20#include "lldb/Symbol/ObjectFile.h"
21#include "lldb/Symbol/Symbol.h"
22#include "lldb/Symbol/SymbolContext.h"
23#include "lldb/Symbol/SymbolFile.h"
24#include "lldb/Target/ABI.h"
25#include "lldb/Target/DynamicLoader.h"
26#include "lldb/Target/ExecutionContext.h"
27#include "lldb/Target/LanguageRuntime.h"
28#include "lldb/Target/Platform.h"
29#include "lldb/Target/Process.h"
30#include "lldb/Target/SectionLoadList.h"
31#include "lldb/Target/StackFrame.h"
32#include "lldb/Target/Target.h"
33#include "lldb/Target/Thread.h"
34#include "lldb/Utility/DataBufferHeap.h"
35#include "lldb/Utility/LLDBLog.h"
36#include "lldb/Utility/Log.h"
37#include "lldb/Utility/RegisterValue.h"
38#include "lldb/Utility/VASPrintf.h"
39#include "lldb/lldb-private.h"
40
41#include <cassert>
42#include <memory>
43
44using namespace lldb;
45using namespace lldb_private;
46
47static ConstString GetSymbolOrFunctionName(const SymbolContext &sym_ctx) {
48 if (sym_ctx.symbol)
49 return sym_ctx.symbol->GetName();
50 else if (sym_ctx.function)
51 return sym_ctx.function->GetName();
52 return ConstString();
53}
54
55RegisterContextUnwind::RegisterContextUnwind(Thread &thread,
56 const SharedPtr &next_frame,
57 SymbolContext &sym_ctx,
58 uint32_t frame_number,
59 UnwindLLDB &unwind_lldb)
60 : RegisterContext(thread, frame_number), m_thread(thread),
61 m_fast_unwind_plan_sp(), m_full_unwind_plan_sp(),
62 m_fallback_unwind_plan_sp(), m_all_registers_available(false),
63 m_frame_type(-1), m_cfa(LLDB_INVALID_ADDRESS),
64 m_afa(LLDB_INVALID_ADDRESS), m_start_pc(), m_current_pc(),
65 m_current_offset(0), m_current_offset_backed_up_one(0),
66 m_behaves_like_zeroth_frame(false), m_sym_ctx(sym_ctx),
67 m_sym_ctx_valid(false), m_frame_number(frame_number), m_registers(),
68 m_parent_unwind(unwind_lldb) {
69 m_sym_ctx.Clear(clear_target: false);
70 m_sym_ctx_valid = false;
71
72 if (IsFrameZero()) {
73 InitializeZerothFrame();
74 } else {
75 InitializeNonZerothFrame();
76 }
77
78 // This same code exists over in the GetFullUnwindPlanForFrame() but it may
79 // not have been executed yet
80 if (IsFrameZero() || next_frame->m_frame_type == eTrapHandlerFrame ||
81 next_frame->m_frame_type == eDebuggerFrame) {
82 m_all_registers_available = true;
83 }
84}
85
86bool RegisterContextUnwind::IsUnwindPlanValidForCurrentPC(
87 lldb::UnwindPlanSP unwind_plan_sp) {
88 if (!unwind_plan_sp)
89 return false;
90
91 // check if m_current_pc is valid
92 if (unwind_plan_sp->PlanValidAtAddress(addr: m_current_pc)) {
93 // yes - current offset can be used as is
94 return true;
95 }
96
97 // if m_current_offset <= 0, we've got nothing else to try
98 if (m_current_offset <= 0)
99 return false;
100
101 // check pc - 1 to see if it's valid
102 Address pc_minus_one(m_current_pc);
103 pc_minus_one.SetOffset(m_current_pc.GetOffset() - 1);
104 if (unwind_plan_sp->PlanValidAtAddress(addr: pc_minus_one)) {
105 return true;
106 }
107
108 return false;
109}
110
111// Initialize a RegisterContextUnwind which is the first frame of a stack -- the
112// zeroth frame or currently executing frame.
113
114void RegisterContextUnwind::InitializeZerothFrame() {
115 Log *log = GetLog(mask: LLDBLog::Unwind);
116 ExecutionContext exe_ctx(m_thread.shared_from_this());
117 RegisterContextSP reg_ctx_sp = m_thread.GetRegisterContext();
118
119 if (reg_ctx_sp.get() == nullptr) {
120 m_frame_type = eNotAValidFrame;
121 UnwindLogMsg(fmt: "frame does not have a register context");
122 return;
123 }
124
125 addr_t current_pc = reg_ctx_sp->GetPC();
126
127 if (current_pc == LLDB_INVALID_ADDRESS) {
128 m_frame_type = eNotAValidFrame;
129 UnwindLogMsg(fmt: "frame does not have a pc");
130 return;
131 }
132
133 Process *process = exe_ctx.GetProcessPtr();
134
135 // Let ABIs fixup code addresses to make sure they are valid. In ARM ABIs
136 // this will strip bit zero in case we read a PC from memory or from the LR.
137 // (which would be a no-op in frame 0 where we get it from the register set,
138 // but still a good idea to make the call here for other ABIs that may
139 // exist.)
140 if (ABISP abi_sp = process->GetABI())
141 current_pc = abi_sp->FixCodeAddress(pc: current_pc);
142
143 UnwindPlanSP lang_runtime_plan_sp = LanguageRuntime::GetRuntimeUnwindPlan(
144 thread&: m_thread, regctx: this, behaves_like_zeroth_frame&: m_behaves_like_zeroth_frame);
145 if (lang_runtime_plan_sp.get()) {
146 UnwindLogMsg(fmt: "This is an async frame");
147 }
148
149 // Initialize m_current_pc, an Address object, based on current_pc, an
150 // addr_t.
151 m_current_pc.SetLoadAddress(load_addr: current_pc, target: &process->GetTarget());
152
153 // If we don't have a Module for some reason, we're not going to find
154 // symbol/function information - just stick in some reasonable defaults and
155 // hope we can unwind past this frame.
156 ModuleSP pc_module_sp(m_current_pc.GetModule());
157 if (!m_current_pc.IsValid() || !pc_module_sp) {
158 UnwindLogMsg(fmt: "using architectural default unwind method");
159 }
160
161 AddressRange addr_range;
162 m_sym_ctx_valid = m_current_pc.ResolveFunctionScope(sym_ctx&: m_sym_ctx, addr_range_ptr: &addr_range);
163
164 if (m_sym_ctx.symbol) {
165 UnwindLogMsg(fmt: "with pc value of 0x%" PRIx64 ", symbol name is '%s'",
166 current_pc, GetSymbolOrFunctionName(sym_ctx: m_sym_ctx).AsCString(value_if_empty: ""));
167 } else if (m_sym_ctx.function) {
168 UnwindLogMsg(fmt: "with pc value of 0x%" PRIx64 ", function name is '%s'",
169 current_pc, GetSymbolOrFunctionName(sym_ctx: m_sym_ctx).AsCString(value_if_empty: ""));
170 } else {
171 UnwindLogMsg(fmt: "with pc value of 0x%" PRIx64
172 ", no symbol/function name is known.",
173 current_pc);
174 }
175
176 if (IsTrapHandlerSymbol(process, m_sym_ctx)) {
177 m_frame_type = eTrapHandlerFrame;
178 } else {
179 // FIXME: Detect eDebuggerFrame here.
180 m_frame_type = eNormalFrame;
181 }
182
183 // If we were able to find a symbol/function, set addr_range to the bounds of
184 // that symbol/function. else treat the current pc value as the start_pc and
185 // record no offset.
186 if (addr_range.GetBaseAddress().IsValid()) {
187 m_start_pc = addr_range.GetBaseAddress();
188 if (m_current_pc.GetSection() == m_start_pc.GetSection()) {
189 m_current_offset = m_current_pc.GetOffset() - m_start_pc.GetOffset();
190 } else if (m_current_pc.GetModule() == m_start_pc.GetModule()) {
191 // This means that whatever symbol we kicked up isn't really correct ---
192 // we should not cross section boundaries ... We really should NULL out
193 // the function/symbol in this case unless there is a bad assumption here
194 // due to inlined functions?
195 m_current_offset =
196 m_current_pc.GetFileAddress() - m_start_pc.GetFileAddress();
197 }
198 m_current_offset_backed_up_one = m_current_offset;
199 } else {
200 m_start_pc = m_current_pc;
201 m_current_offset = -1;
202 m_current_offset_backed_up_one = -1;
203 }
204
205 // We've set m_frame_type and m_sym_ctx before these calls.
206
207 m_fast_unwind_plan_sp = GetFastUnwindPlanForFrame();
208 m_full_unwind_plan_sp = GetFullUnwindPlanForFrame();
209
210 UnwindPlan::RowSP active_row;
211 lldb::RegisterKind row_register_kind = eRegisterKindGeneric;
212
213 // If we have LanguageRuntime UnwindPlan for this unwind, use those
214 // rules to find the caller frame instead of the function's normal
215 // UnwindPlans. The full unwind plan for this frame will be
216 // the LanguageRuntime-provided unwind plan, and there will not be a
217 // fast unwind plan.
218 if (lang_runtime_plan_sp.get()) {
219 active_row =
220 lang_runtime_plan_sp->GetRowForFunctionOffset(offset: m_current_offset);
221 row_register_kind = lang_runtime_plan_sp->GetRegisterKind();
222 if (!ReadFrameAddress(register_kind: row_register_kind, fa&: active_row->GetCFAValue(),
223 address&: m_cfa)) {
224 UnwindLogMsg(fmt: "Cannot set cfa");
225 } else {
226 m_full_unwind_plan_sp = lang_runtime_plan_sp;
227 if (log) {
228 StreamString active_row_strm;
229 active_row->Dump(s&: active_row_strm, unwind_plan: lang_runtime_plan_sp.get(), thread: &m_thread,
230 base_addr: m_start_pc.GetLoadAddress(target: exe_ctx.GetTargetPtr()));
231 UnwindLogMsg(fmt: "async active row: %s", active_row_strm.GetData());
232 }
233 UnwindLogMsg(fmt: "m_cfa = 0x%" PRIx64 " m_afa = 0x%" PRIx64, m_cfa, m_afa);
234 UnwindLogMsg(
235 fmt: "initialized async frame current pc is 0x%" PRIx64
236 " cfa is 0x%" PRIx64 " afa is 0x%" PRIx64,
237 (uint64_t)m_current_pc.GetLoadAddress(target: exe_ctx.GetTargetPtr()),
238 (uint64_t)m_cfa, (uint64_t)m_afa);
239
240 return;
241 }
242 }
243
244 if (m_full_unwind_plan_sp &&
245 m_full_unwind_plan_sp->PlanValidAtAddress(addr: m_current_pc)) {
246 active_row =
247 m_full_unwind_plan_sp->GetRowForFunctionOffset(offset: m_current_offset);
248 row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
249 if (active_row.get() && log) {
250 StreamString active_row_strm;
251 active_row->Dump(s&: active_row_strm, unwind_plan: m_full_unwind_plan_sp.get(), thread: &m_thread,
252 base_addr: m_start_pc.GetLoadAddress(target: exe_ctx.GetTargetPtr()));
253 UnwindLogMsg(fmt: "%s", active_row_strm.GetData());
254 }
255 }
256
257 if (!active_row.get()) {
258 UnwindLogMsg(fmt: "could not find an unwindplan row for this frame's pc");
259 m_frame_type = eNotAValidFrame;
260 return;
261 }
262
263 if (!ReadFrameAddress(register_kind: row_register_kind, fa&: active_row->GetCFAValue(), address&: m_cfa)) {
264 // Try the fall back unwind plan since the
265 // full unwind plan failed.
266 FuncUnwindersSP func_unwinders_sp;
267 UnwindPlanSP call_site_unwind_plan;
268 bool cfa_status = false;
269
270 if (m_sym_ctx_valid) {
271 func_unwinders_sp =
272 pc_module_sp->GetUnwindTable().GetFuncUnwindersContainingAddress(
273 addr: m_current_pc, sc&: m_sym_ctx);
274 }
275
276 if (func_unwinders_sp.get() != nullptr)
277 call_site_unwind_plan = func_unwinders_sp->GetUnwindPlanAtCallSite(
278 target&: process->GetTarget(), thread&: m_thread);
279
280 if (call_site_unwind_plan.get() != nullptr) {
281 m_fallback_unwind_plan_sp = call_site_unwind_plan;
282 if (TryFallbackUnwindPlan())
283 cfa_status = true;
284 }
285 if (!cfa_status) {
286 UnwindLogMsg(fmt: "could not read CFA value for first frame.");
287 m_frame_type = eNotAValidFrame;
288 return;
289 }
290 } else
291 ReadFrameAddress(register_kind: row_register_kind, fa&: active_row->GetAFAValue(), address&: m_afa);
292
293 if (m_cfa == LLDB_INVALID_ADDRESS && m_afa == LLDB_INVALID_ADDRESS) {
294 UnwindLogMsg(
295 fmt: "could not read CFA or AFA values for first frame, not valid.");
296 m_frame_type = eNotAValidFrame;
297 return;
298 }
299
300 UnwindLogMsg(fmt: "initialized frame current pc is 0x%" PRIx64 " cfa is 0x%" PRIx64
301 " afa is 0x%" PRIx64 " using %s UnwindPlan",
302 (uint64_t)m_current_pc.GetLoadAddress(target: exe_ctx.GetTargetPtr()),
303 (uint64_t)m_cfa,
304 (uint64_t)m_afa,
305 m_full_unwind_plan_sp->GetSourceName().GetCString());
306}
307
308// Initialize a RegisterContextUnwind for the non-zeroth frame -- rely on the
309// RegisterContextUnwind "below" it to provide things like its current pc value.
310
311void RegisterContextUnwind::InitializeNonZerothFrame() {
312 Log *log = GetLog(mask: LLDBLog::Unwind);
313 if (IsFrameZero()) {
314 m_frame_type = eNotAValidFrame;
315 UnwindLogMsg(fmt: "non-zeroth frame tests positive for IsFrameZero -- that "
316 "shouldn't happen.");
317 return;
318 }
319
320 if (!GetNextFrame().get() || !GetNextFrame()->IsValid()) {
321 m_frame_type = eNotAValidFrame;
322 UnwindLogMsg(fmt: "Could not get next frame, marking this frame as invalid.");
323 return;
324 }
325 if (!m_thread.GetRegisterContext()) {
326 m_frame_type = eNotAValidFrame;
327 UnwindLogMsg(fmt: "Could not get register context for this thread, marking this "
328 "frame as invalid.");
329 return;
330 }
331
332 ExecutionContext exe_ctx(m_thread.shared_from_this());
333 Process *process = exe_ctx.GetProcessPtr();
334
335 // Some languages may have a logical parent stack frame which is
336 // not a real stack frame, but the programmer would consider it to
337 // be the caller of the frame, e.g. Swift asynchronous frames.
338 //
339 // A LanguageRuntime may provide an UnwindPlan that is used in this
340 // stack trace base on the RegisterContext contents, intsead
341 // of the normal UnwindPlans we would use for the return-pc.
342 UnwindPlanSP lang_runtime_plan_sp = LanguageRuntime::GetRuntimeUnwindPlan(
343 thread&: m_thread, regctx: this, behaves_like_zeroth_frame&: m_behaves_like_zeroth_frame);
344 if (lang_runtime_plan_sp.get()) {
345 UnwindLogMsg(fmt: "This is an async frame");
346 }
347
348 addr_t pc;
349 if (!ReadGPRValue(register_kind: eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, value&: pc)) {
350 UnwindLogMsg(fmt: "could not get pc value");
351 m_frame_type = eNotAValidFrame;
352 return;
353 }
354
355 // Let ABIs fixup code addresses to make sure they are valid. In ARM ABIs
356 // this will strip bit zero in case we read a PC from memory or from the LR.
357 ABISP abi_sp = process->GetABI();
358 if (abi_sp)
359 pc = abi_sp->FixCodeAddress(pc);
360
361 if (log) {
362 UnwindLogMsg(fmt: "pc = 0x%" PRIx64, pc);
363 addr_t reg_val;
364 if (ReadGPRValue(register_kind: eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FP, value&: reg_val)) {
365 if (abi_sp)
366 reg_val = abi_sp->FixDataAddress(pc: reg_val);
367 UnwindLogMsg(fmt: "fp = 0x%" PRIx64, reg_val);
368 }
369 if (ReadGPRValue(register_kind: eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP, value&: reg_val)) {
370 if (abi_sp)
371 reg_val = abi_sp->FixDataAddress(pc: reg_val);
372 UnwindLogMsg(fmt: "sp = 0x%" PRIx64, reg_val);
373 }
374 }
375
376 // A pc of 0x0 means it's the end of the stack crawl unless we're above a trap
377 // handler function
378 bool above_trap_handler = false;
379 if (GetNextFrame().get() && GetNextFrame()->IsValid() &&
380 GetNextFrame()->IsTrapHandlerFrame())
381 above_trap_handler = true;
382
383 if (pc == 0 || pc == 0x1) {
384 if (!above_trap_handler) {
385 m_frame_type = eNotAValidFrame;
386 UnwindLogMsg(fmt: "this frame has a pc of 0x0");
387 return;
388 }
389 }
390
391 const bool allow_section_end = true;
392 m_current_pc.SetLoadAddress(load_addr: pc, target: &process->GetTarget(), allow_section_end);
393
394 // If we don't have a Module for some reason, we're not going to find
395 // symbol/function information - just stick in some reasonable defaults and
396 // hope we can unwind past this frame. If we're above a trap handler,
397 // we may be at a bogus address because we jumped through a bogus function
398 // pointer and trapped, so don't force the arch default unwind plan in that
399 // case.
400 ModuleSP pc_module_sp(m_current_pc.GetModule());
401 if ((!m_current_pc.IsValid() || !pc_module_sp) &&
402 above_trap_handler == false) {
403 UnwindLogMsg(fmt: "using architectural default unwind method");
404
405 // Test the pc value to see if we know it's in an unmapped/non-executable
406 // region of memory.
407 uint32_t permissions;
408 if (process->GetLoadAddressPermissions(load_addr: pc, permissions) &&
409 (permissions & ePermissionsExecutable) == 0) {
410 // If this is the second frame off the stack, we may have unwound the
411 // first frame incorrectly. But using the architecture default unwind
412 // plan may get us back on track -- albeit possibly skipping a real
413 // frame. Give this frame a clearly-invalid pc and see if we can get any
414 // further.
415 if (GetNextFrame().get() && GetNextFrame()->IsValid() &&
416 GetNextFrame()->IsFrameZero()) {
417 UnwindLogMsg(fmt: "had a pc of 0x%" PRIx64 " which is not in executable "
418 "memory but on frame 1 -- "
419 "allowing it once.",
420 (uint64_t)pc);
421 m_frame_type = eSkipFrame;
422 } else {
423 // anywhere other than the second frame, a non-executable pc means
424 // we're off in the weeds -- stop now.
425 m_frame_type = eNotAValidFrame;
426 UnwindLogMsg(fmt: "pc is in a non-executable section of memory and this "
427 "isn't the 2nd frame in the stack walk.");
428 return;
429 }
430 }
431
432 if (abi_sp) {
433 m_fast_unwind_plan_sp.reset();
434 m_full_unwind_plan_sp =
435 std::make_shared<UnwindPlan>(args: lldb::eRegisterKindGeneric);
436 abi_sp->CreateDefaultUnwindPlan(unwind_plan&: *m_full_unwind_plan_sp);
437 if (m_frame_type != eSkipFrame) // don't override eSkipFrame
438 {
439 m_frame_type = eNormalFrame;
440 }
441 m_all_registers_available = false;
442 m_current_offset = -1;
443 m_current_offset_backed_up_one = -1;
444 RegisterKind row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
445 UnwindPlan::RowSP row = m_full_unwind_plan_sp->GetRowForFunctionOffset(offset: 0);
446 if (row.get()) {
447 if (!ReadFrameAddress(register_kind: row_register_kind, fa&: row->GetCFAValue(), address&: m_cfa)) {
448 UnwindLogMsg(fmt: "failed to get cfa value");
449 if (m_frame_type != eSkipFrame) // don't override eSkipFrame
450 {
451 m_frame_type = eNotAValidFrame;
452 }
453 return;
454 }
455
456 ReadFrameAddress(register_kind: row_register_kind, fa&: row->GetAFAValue(), address&: m_afa);
457
458 // A couple of sanity checks..
459 if (m_cfa == LLDB_INVALID_ADDRESS || m_cfa == 0 || m_cfa == 1) {
460 UnwindLogMsg(fmt: "could not find a valid cfa address");
461 m_frame_type = eNotAValidFrame;
462 return;
463 }
464
465 // m_cfa should point into the stack memory; if we can query memory
466 // region permissions, see if the memory is allocated & readable.
467 if (process->GetLoadAddressPermissions(load_addr: m_cfa, permissions) &&
468 (permissions & ePermissionsReadable) == 0) {
469 m_frame_type = eNotAValidFrame;
470 UnwindLogMsg(
471 fmt: "the CFA points to a region of memory that is not readable");
472 return;
473 }
474 } else {
475 UnwindLogMsg(fmt: "could not find a row for function offset zero");
476 m_frame_type = eNotAValidFrame;
477 return;
478 }
479
480 if (CheckIfLoopingStack()) {
481 TryFallbackUnwindPlan();
482 if (CheckIfLoopingStack()) {
483 UnwindLogMsg(fmt: "same CFA address as next frame, assuming the unwind is "
484 "looping - stopping");
485 m_frame_type = eNotAValidFrame;
486 return;
487 }
488 }
489
490 UnwindLogMsg(fmt: "initialized frame cfa is 0x%" PRIx64 " afa is 0x%" PRIx64,
491 (uint64_t)m_cfa, (uint64_t)m_afa);
492 return;
493 }
494 m_frame_type = eNotAValidFrame;
495 UnwindLogMsg(fmt: "could not find any symbol for this pc, or a default unwind "
496 "plan, to continue unwind.");
497 return;
498 }
499
500 AddressRange addr_range;
501 m_sym_ctx_valid = m_current_pc.ResolveFunctionScope(sym_ctx&: m_sym_ctx, addr_range_ptr: &addr_range);
502
503 if (m_sym_ctx.symbol) {
504 UnwindLogMsg(fmt: "with pc value of 0x%" PRIx64 ", symbol name is '%s'", pc,
505 GetSymbolOrFunctionName(sym_ctx: m_sym_ctx).AsCString(value_if_empty: ""));
506 } else if (m_sym_ctx.function) {
507 UnwindLogMsg(fmt: "with pc value of 0x%" PRIx64 ", function name is '%s'", pc,
508 GetSymbolOrFunctionName(sym_ctx: m_sym_ctx).AsCString(value_if_empty: ""));
509 } else {
510 UnwindLogMsg(fmt: "with pc value of 0x%" PRIx64
511 ", no symbol/function name is known.",
512 pc);
513 }
514
515 bool decr_pc_and_recompute_addr_range;
516
517 if (!m_sym_ctx_valid) {
518 // Always decrement and recompute if the symbol lookup failed
519 decr_pc_and_recompute_addr_range = true;
520 } else if (GetNextFrame()->m_frame_type == eTrapHandlerFrame ||
521 GetNextFrame()->m_frame_type == eDebuggerFrame) {
522 // Don't decrement if we're "above" an asynchronous event like
523 // sigtramp.
524 decr_pc_and_recompute_addr_range = false;
525 } else if (!addr_range.GetBaseAddress().IsValid() ||
526 addr_range.GetBaseAddress().GetSection() != m_current_pc.GetSection() ||
527 addr_range.GetBaseAddress().GetOffset() != m_current_pc.GetOffset()) {
528 // If our "current" pc isn't the start of a function, decrement the pc
529 // if we're up the stack.
530 if (m_behaves_like_zeroth_frame)
531 decr_pc_and_recompute_addr_range = false;
532 else
533 decr_pc_and_recompute_addr_range = true;
534 } else if (IsTrapHandlerSymbol(process, m_sym_ctx)) {
535 // Signal dispatch may set the return address of the handler it calls to
536 // point to the first byte of a return trampoline (like __kernel_rt_sigreturn),
537 // so do not decrement and recompute if the symbol we already found is a trap
538 // handler.
539 decr_pc_and_recompute_addr_range = false;
540 } else if (m_behaves_like_zeroth_frame) {
541 decr_pc_and_recompute_addr_range = false;
542 } else {
543 // Decrement to find the function containing the call.
544 decr_pc_and_recompute_addr_range = true;
545 }
546
547 // We need to back up the pc by 1 byte and re-search for the Symbol to handle
548 // the case where the "saved pc" value is pointing to the next function, e.g.
549 // if a function ends with a CALL instruction.
550 // FIXME this may need to be an architectural-dependent behavior; if so we'll
551 // need to add a member function
552 // to the ABI plugin and consult that.
553 if (decr_pc_and_recompute_addr_range) {
554 UnwindLogMsg(fmt: "Backing up the pc value of 0x%" PRIx64
555 " by 1 and re-doing symbol lookup; old symbol was %s",
556 pc, GetSymbolOrFunctionName(sym_ctx: m_sym_ctx).AsCString(value_if_empty: ""));
557 Address temporary_pc;
558 temporary_pc.SetLoadAddress(load_addr: pc - 1, target: &process->GetTarget());
559 m_sym_ctx.Clear(clear_target: false);
560 m_sym_ctx_valid = temporary_pc.ResolveFunctionScope(sym_ctx&: m_sym_ctx, addr_range_ptr: &addr_range);
561
562 UnwindLogMsg(fmt: "Symbol is now %s",
563 GetSymbolOrFunctionName(sym_ctx: m_sym_ctx).AsCString(value_if_empty: ""));
564 }
565
566 // If we were able to find a symbol/function, set addr_range_ptr to the
567 // bounds of that symbol/function. else treat the current pc value as the
568 // start_pc and record no offset.
569 if (addr_range.GetBaseAddress().IsValid()) {
570 m_start_pc = addr_range.GetBaseAddress();
571 m_current_offset = pc - m_start_pc.GetLoadAddress(target: &process->GetTarget());
572 m_current_offset_backed_up_one = m_current_offset;
573 if (decr_pc_and_recompute_addr_range &&
574 m_current_offset_backed_up_one > 0) {
575 m_current_offset_backed_up_one--;
576 if (m_sym_ctx_valid) {
577 m_current_pc.SetLoadAddress(load_addr: pc - 1, target: &process->GetTarget());
578 }
579 }
580 } else {
581 m_start_pc = m_current_pc;
582 m_current_offset = -1;
583 m_current_offset_backed_up_one = -1;
584 }
585
586 if (IsTrapHandlerSymbol(process, m_sym_ctx)) {
587 m_frame_type = eTrapHandlerFrame;
588 } else {
589 // FIXME: Detect eDebuggerFrame here.
590 if (m_frame_type != eSkipFrame) // don't override eSkipFrame
591 {
592 m_frame_type = eNormalFrame;
593 }
594 }
595
596 UnwindPlan::RowSP active_row;
597 RegisterKind row_register_kind = eRegisterKindGeneric;
598
599 // If we have LanguageRuntime UnwindPlan for this unwind, use those
600 // rules to find the caller frame instead of the function's normal
601 // UnwindPlans. The full unwind plan for this frame will be
602 // the LanguageRuntime-provided unwind plan, and there will not be a
603 // fast unwind plan.
604 if (lang_runtime_plan_sp.get()) {
605 active_row =
606 lang_runtime_plan_sp->GetRowForFunctionOffset(offset: m_current_offset);
607 row_register_kind = lang_runtime_plan_sp->GetRegisterKind();
608 if (!ReadFrameAddress(register_kind: row_register_kind, fa&: active_row->GetCFAValue(),
609 address&: m_cfa)) {
610 UnwindLogMsg(fmt: "Cannot set cfa");
611 } else {
612 m_full_unwind_plan_sp = lang_runtime_plan_sp;
613 if (log) {
614 StreamString active_row_strm;
615 active_row->Dump(s&: active_row_strm, unwind_plan: lang_runtime_plan_sp.get(), thread: &m_thread,
616 base_addr: m_start_pc.GetLoadAddress(target: exe_ctx.GetTargetPtr()));
617 UnwindLogMsg(fmt: "async active row: %s", active_row_strm.GetData());
618 }
619 UnwindLogMsg(fmt: "m_cfa = 0x%" PRIx64 " m_afa = 0x%" PRIx64, m_cfa, m_afa);
620 UnwindLogMsg(
621 fmt: "initialized async frame current pc is 0x%" PRIx64
622 " cfa is 0x%" PRIx64 " afa is 0x%" PRIx64,
623 (uint64_t)m_current_pc.GetLoadAddress(target: exe_ctx.GetTargetPtr()),
624 (uint64_t)m_cfa, (uint64_t)m_afa);
625
626 return;
627 }
628 }
629
630 // We've set m_frame_type and m_sym_ctx before this call.
631 m_fast_unwind_plan_sp = GetFastUnwindPlanForFrame();
632
633 // Try to get by with just the fast UnwindPlan if possible - the full
634 // UnwindPlan may be expensive to get (e.g. if we have to parse the entire
635 // eh_frame section of an ObjectFile for the first time.)
636
637 if (m_fast_unwind_plan_sp &&
638 m_fast_unwind_plan_sp->PlanValidAtAddress(addr: m_current_pc)) {
639 active_row =
640 m_fast_unwind_plan_sp->GetRowForFunctionOffset(offset: m_current_offset);
641 row_register_kind = m_fast_unwind_plan_sp->GetRegisterKind();
642 PropagateTrapHandlerFlagFromUnwindPlan(unwind_plan: m_fast_unwind_plan_sp);
643 if (active_row.get() && log) {
644 StreamString active_row_strm;
645 active_row->Dump(s&: active_row_strm, unwind_plan: m_fast_unwind_plan_sp.get(), thread: &m_thread,
646 base_addr: m_start_pc.GetLoadAddress(target: exe_ctx.GetTargetPtr()));
647 UnwindLogMsg(fmt: "Using fast unwind plan '%s'",
648 m_fast_unwind_plan_sp->GetSourceName().AsCString());
649 UnwindLogMsg(fmt: "active row: %s", active_row_strm.GetData());
650 }
651 } else {
652 m_full_unwind_plan_sp = GetFullUnwindPlanForFrame();
653 if (IsUnwindPlanValidForCurrentPC(unwind_plan_sp: m_full_unwind_plan_sp)) {
654 active_row = m_full_unwind_plan_sp->GetRowForFunctionOffset(
655 offset: m_current_offset_backed_up_one);
656 row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
657 PropagateTrapHandlerFlagFromUnwindPlan(unwind_plan: m_full_unwind_plan_sp);
658 if (active_row.get() && log) {
659 StreamString active_row_strm;
660 active_row->Dump(s&: active_row_strm, unwind_plan: m_full_unwind_plan_sp.get(),
661 thread: &m_thread,
662 base_addr: m_start_pc.GetLoadAddress(target: exe_ctx.GetTargetPtr()));
663 UnwindLogMsg(fmt: "Using full unwind plan '%s'",
664 m_full_unwind_plan_sp->GetSourceName().AsCString());
665 UnwindLogMsg(fmt: "active row: %s", active_row_strm.GetData());
666 }
667 }
668 }
669
670 if (!active_row.get()) {
671 m_frame_type = eNotAValidFrame;
672 UnwindLogMsg(fmt: "could not find unwind row for this pc");
673 return;
674 }
675
676 if (!ReadFrameAddress(register_kind: row_register_kind, fa&: active_row->GetCFAValue(), address&: m_cfa)) {
677 UnwindLogMsg(fmt: "failed to get cfa");
678 m_frame_type = eNotAValidFrame;
679 return;
680 }
681
682 ReadFrameAddress(register_kind: row_register_kind, fa&: active_row->GetAFAValue(), address&: m_afa);
683
684 UnwindLogMsg(fmt: "m_cfa = 0x%" PRIx64 " m_afa = 0x%" PRIx64, m_cfa, m_afa);
685
686 if (CheckIfLoopingStack()) {
687 TryFallbackUnwindPlan();
688 if (CheckIfLoopingStack()) {
689 UnwindLogMsg(fmt: "same CFA address as next frame, assuming the unwind is "
690 "looping - stopping");
691 m_frame_type = eNotAValidFrame;
692 return;
693 }
694 }
695
696 UnwindLogMsg(fmt: "initialized frame current pc is 0x%" PRIx64
697 " cfa is 0x%" PRIx64 " afa is 0x%" PRIx64,
698 (uint64_t)m_current_pc.GetLoadAddress(target: exe_ctx.GetTargetPtr()),
699 (uint64_t)m_cfa,
700 (uint64_t)m_afa);
701}
702
703bool RegisterContextUnwind::CheckIfLoopingStack() {
704 // If we have a bad stack setup, we can get the same CFA value multiple times
705 // -- or even more devious, we can actually oscillate between two CFA values.
706 // Detect that here and break out to avoid a possible infinite loop in lldb
707 // trying to unwind the stack. To detect when we have the same CFA value
708 // multiple times, we compare the
709 // CFA of the current
710 // frame with the 2nd next frame because in some specail case (e.g. signal
711 // hanlders, hand written assembly without ABI compliance) we can have 2
712 // frames with the same
713 // CFA (in theory we
714 // can have arbitrary number of frames with the same CFA, but more then 2 is
715 // very unlikely)
716
717 RegisterContextUnwind::SharedPtr next_frame = GetNextFrame();
718 if (next_frame) {
719 RegisterContextUnwind::SharedPtr next_next_frame =
720 next_frame->GetNextFrame();
721 addr_t next_next_frame_cfa = LLDB_INVALID_ADDRESS;
722 if (next_next_frame && next_next_frame->GetCFA(cfa&: next_next_frame_cfa)) {
723 if (next_next_frame_cfa == m_cfa) {
724 // We have a loop in the stack unwind
725 return true;
726 }
727 }
728 }
729 return false;
730}
731
732bool RegisterContextUnwind::IsFrameZero() const { return m_frame_number == 0; }
733
734bool RegisterContextUnwind::BehavesLikeZerothFrame() const {
735 if (m_frame_number == 0)
736 return true;
737 if (m_behaves_like_zeroth_frame)
738 return true;
739 return false;
740}
741
742// Find a fast unwind plan for this frame, if possible.
743//
744// On entry to this method,
745//
746// 1. m_frame_type should already be set to eTrapHandlerFrame/eDebuggerFrame
747// if either of those are correct,
748// 2. m_sym_ctx should already be filled in, and
749// 3. m_current_pc should have the current pc value for this frame
750// 4. m_current_offset_backed_up_one should have the current byte offset into
751// the function, maybe backed up by 1, -1 if unknown
752
753UnwindPlanSP RegisterContextUnwind::GetFastUnwindPlanForFrame() {
754 UnwindPlanSP unwind_plan_sp;
755 ModuleSP pc_module_sp(m_current_pc.GetModule());
756
757 if (!m_current_pc.IsValid() || !pc_module_sp ||
758 pc_module_sp->GetObjectFile() == nullptr)
759 return unwind_plan_sp;
760
761 if (IsFrameZero())
762 return unwind_plan_sp;
763
764 FuncUnwindersSP func_unwinders_sp(
765 pc_module_sp->GetUnwindTable().GetFuncUnwindersContainingAddress(
766 addr: m_current_pc, sc&: m_sym_ctx));
767 if (!func_unwinders_sp)
768 return unwind_plan_sp;
769
770 // If we're in _sigtramp(), unwinding past this frame requires special
771 // knowledge.
772 if (m_frame_type == eTrapHandlerFrame || m_frame_type == eDebuggerFrame)
773 return unwind_plan_sp;
774
775 unwind_plan_sp = func_unwinders_sp->GetUnwindPlanFastUnwind(
776 target&: *m_thread.CalculateTarget(), thread&: m_thread);
777 if (unwind_plan_sp) {
778 if (unwind_plan_sp->PlanValidAtAddress(addr: m_current_pc)) {
779 m_frame_type = eNormalFrame;
780 return unwind_plan_sp;
781 } else {
782 unwind_plan_sp.reset();
783 }
784 }
785 return unwind_plan_sp;
786}
787
788// On entry to this method,
789//
790// 1. m_frame_type should already be set to eTrapHandlerFrame/eDebuggerFrame
791// if either of those are correct,
792// 2. m_sym_ctx should already be filled in, and
793// 3. m_current_pc should have the current pc value for this frame
794// 4. m_current_offset_backed_up_one should have the current byte offset into
795// the function, maybe backed up by 1, -1 if unknown
796
797UnwindPlanSP RegisterContextUnwind::GetFullUnwindPlanForFrame() {
798 UnwindPlanSP unwind_plan_sp;
799 UnwindPlanSP arch_default_unwind_plan_sp;
800 ExecutionContext exe_ctx(m_thread.shared_from_this());
801 Process *process = exe_ctx.GetProcessPtr();
802 ABI *abi = process ? process->GetABI().get() : nullptr;
803 if (abi) {
804 arch_default_unwind_plan_sp =
805 std::make_shared<UnwindPlan>(args: lldb::eRegisterKindGeneric);
806 abi->CreateDefaultUnwindPlan(unwind_plan&: *arch_default_unwind_plan_sp);
807 } else {
808 UnwindLogMsg(
809 fmt: "unable to get architectural default UnwindPlan from ABI plugin");
810 }
811
812 if (IsFrameZero() || GetNextFrame()->m_frame_type == eTrapHandlerFrame ||
813 GetNextFrame()->m_frame_type == eDebuggerFrame) {
814 m_behaves_like_zeroth_frame = true;
815 // If this frame behaves like a 0th frame (currently executing or
816 // interrupted asynchronously), all registers can be retrieved.
817 m_all_registers_available = true;
818 }
819
820 // If we've done a jmp 0x0 / bl 0x0 (called through a null function pointer)
821 // so the pc is 0x0 in the zeroth frame, we need to use the "unwind at first
822 // instruction" arch default UnwindPlan Also, if this Process can report on
823 // memory region attributes, any non-executable region means we jumped
824 // through a bad function pointer - handle the same way as 0x0. Note, if we
825 // have a symbol context & a symbol, we don't want to follow this code path.
826 // This is for jumping to memory regions without any information available.
827
828 if ((!m_sym_ctx_valid ||
829 (m_sym_ctx.function == nullptr && m_sym_ctx.symbol == nullptr)) &&
830 m_behaves_like_zeroth_frame && m_current_pc.IsValid()) {
831 uint32_t permissions;
832 addr_t current_pc_addr =
833 m_current_pc.GetLoadAddress(target: exe_ctx.GetTargetPtr());
834 if (current_pc_addr == 0 ||
835 (process &&
836 process->GetLoadAddressPermissions(load_addr: current_pc_addr, permissions) &&
837 (permissions & ePermissionsExecutable) == 0)) {
838 if (abi) {
839 unwind_plan_sp =
840 std::make_shared<UnwindPlan>(args: lldb::eRegisterKindGeneric);
841 abi->CreateFunctionEntryUnwindPlan(unwind_plan&: *unwind_plan_sp);
842 m_frame_type = eNormalFrame;
843 return unwind_plan_sp;
844 }
845 }
846 }
847
848 // No Module for the current pc, try using the architecture default unwind.
849 ModuleSP pc_module_sp(m_current_pc.GetModule());
850 if (!m_current_pc.IsValid() || !pc_module_sp ||
851 pc_module_sp->GetObjectFile() == nullptr) {
852 m_frame_type = eNormalFrame;
853 return arch_default_unwind_plan_sp;
854 }
855
856 FuncUnwindersSP func_unwinders_sp;
857 if (m_sym_ctx_valid) {
858 func_unwinders_sp =
859 pc_module_sp->GetUnwindTable().GetFuncUnwindersContainingAddress(
860 addr: m_current_pc, sc&: m_sym_ctx);
861 }
862
863 // No FuncUnwinders available for this pc (stripped function symbols, lldb
864 // could not augment its function table with another source, like
865 // LC_FUNCTION_STARTS or eh_frame in ObjectFileMachO). See if eh_frame or the
866 // .ARM.exidx tables have unwind information for this address, else fall back
867 // to the architectural default unwind.
868 if (!func_unwinders_sp) {
869 m_frame_type = eNormalFrame;
870
871 if (!pc_module_sp || !pc_module_sp->GetObjectFile() ||
872 !m_current_pc.IsValid())
873 return arch_default_unwind_plan_sp;
874
875 // Even with -fomit-frame-pointer, we can try eh_frame to get back on
876 // track.
877 DWARFCallFrameInfo *eh_frame =
878 pc_module_sp->GetUnwindTable().GetEHFrameInfo();
879 if (eh_frame) {
880 unwind_plan_sp = std::make_shared<UnwindPlan>(args: lldb::eRegisterKindGeneric);
881 if (eh_frame->GetUnwindPlan(addr: m_current_pc, unwind_plan&: *unwind_plan_sp))
882 return unwind_plan_sp;
883 else
884 unwind_plan_sp.reset();
885 }
886
887 ArmUnwindInfo *arm_exidx =
888 pc_module_sp->GetUnwindTable().GetArmUnwindInfo();
889 if (arm_exidx) {
890 unwind_plan_sp = std::make_shared<UnwindPlan>(args: lldb::eRegisterKindGeneric);
891 if (arm_exidx->GetUnwindPlan(target&: exe_ctx.GetTargetRef(), addr: m_current_pc,
892 unwind_plan&: *unwind_plan_sp))
893 return unwind_plan_sp;
894 else
895 unwind_plan_sp.reset();
896 }
897
898 CallFrameInfo *object_file_unwind =
899 pc_module_sp->GetUnwindTable().GetObjectFileUnwindInfo();
900 if (object_file_unwind) {
901 unwind_plan_sp = std::make_shared<UnwindPlan>(args: lldb::eRegisterKindGeneric);
902 if (object_file_unwind->GetUnwindPlan(addr: m_current_pc, unwind_plan&: *unwind_plan_sp))
903 return unwind_plan_sp;
904 else
905 unwind_plan_sp.reset();
906 }
907
908 return arch_default_unwind_plan_sp;
909 }
910
911 if (m_frame_type == eTrapHandlerFrame && process) {
912 m_fast_unwind_plan_sp.reset();
913
914 // On some platforms the unwind information for signal handlers is not
915 // present or correct. Give the platform plugins a chance to provide
916 // substitute plan. Otherwise, use eh_frame.
917 if (m_sym_ctx_valid) {
918 lldb::PlatformSP platform = process->GetTarget().GetPlatform();
919 unwind_plan_sp = platform->GetTrapHandlerUnwindPlan(
920 triple: process->GetTarget().GetArchitecture().GetTriple(),
921 name: GetSymbolOrFunctionName(sym_ctx: m_sym_ctx));
922
923 if (unwind_plan_sp)
924 return unwind_plan_sp;
925 }
926
927 unwind_plan_sp =
928 func_unwinders_sp->GetEHFrameUnwindPlan(target&: process->GetTarget());
929 if (!unwind_plan_sp)
930 unwind_plan_sp =
931 func_unwinders_sp->GetObjectFileUnwindPlan(target&: process->GetTarget());
932 if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(addr: m_current_pc) &&
933 unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolYes) {
934 return unwind_plan_sp;
935 }
936 }
937
938 // Ask the DynamicLoader if the eh_frame CFI should be trusted in this frame
939 // even when it's frame zero This comes up if we have hand-written functions
940 // in a Module and hand-written eh_frame. The assembly instruction
941 // inspection may fail and the eh_frame CFI were probably written with some
942 // care to do the right thing. It'd be nice if there was a way to ask the
943 // eh_frame directly if it is asynchronous (can be trusted at every
944 // instruction point) or synchronous (the normal case - only at call sites).
945 // But there is not.
946 if (process && process->GetDynamicLoader() &&
947 process->GetDynamicLoader()->AlwaysRelyOnEHUnwindInfo(sym_ctx&: m_sym_ctx)) {
948 // We must specifically call the GetEHFrameUnwindPlan() method here --
949 // normally we would call GetUnwindPlanAtCallSite() -- because CallSite may
950 // return an unwind plan sourced from either eh_frame (that's what we
951 // intend) or compact unwind (this won't work)
952 unwind_plan_sp =
953 func_unwinders_sp->GetEHFrameUnwindPlan(target&: process->GetTarget());
954 if (!unwind_plan_sp)
955 unwind_plan_sp =
956 func_unwinders_sp->GetObjectFileUnwindPlan(target&: process->GetTarget());
957 if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(addr: m_current_pc)) {
958 UnwindLogMsgVerbose(fmt: "frame uses %s for full UnwindPlan because the "
959 "DynamicLoader suggested we prefer it",
960 unwind_plan_sp->GetSourceName().GetCString());
961 return unwind_plan_sp;
962 }
963 }
964
965 // Typically the NonCallSite UnwindPlan is the unwind created by inspecting
966 // the assembly language instructions
967 if (m_behaves_like_zeroth_frame && process) {
968 unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite(
969 target&: process->GetTarget(), thread&: m_thread);
970 if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(addr: m_current_pc)) {
971 if (unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolNo) {
972 // We probably have an UnwindPlan created by inspecting assembly
973 // instructions. The assembly profilers work really well with compiler-
974 // generated functions but hand- written assembly can be problematic.
975 // We set the eh_frame based unwind plan as our fallback unwind plan if
976 // instruction emulation doesn't work out even for non call sites if it
977 // is available and use the architecture default unwind plan if it is
978 // not available. The eh_frame unwind plan is more reliable even on non
979 // call sites then the architecture default plan and for hand written
980 // assembly code it is often written in a way that it valid at all
981 // location what helps in the most common cases when the instruction
982 // emulation fails.
983 UnwindPlanSP call_site_unwind_plan =
984 func_unwinders_sp->GetUnwindPlanAtCallSite(target&: process->GetTarget(),
985 thread&: m_thread);
986 if (call_site_unwind_plan &&
987 call_site_unwind_plan.get() != unwind_plan_sp.get() &&
988 call_site_unwind_plan->GetSourceName() !=
989 unwind_plan_sp->GetSourceName()) {
990 m_fallback_unwind_plan_sp = call_site_unwind_plan;
991 } else {
992 m_fallback_unwind_plan_sp = arch_default_unwind_plan_sp;
993 }
994 }
995 UnwindLogMsgVerbose(fmt: "frame uses %s for full UnwindPlan because this "
996 "is the non-call site unwind plan and this is a "
997 "zeroth frame",
998 unwind_plan_sp->GetSourceName().GetCString());
999 return unwind_plan_sp;
1000 }
1001
1002 // If we're on the first instruction of a function, and we have an
1003 // architectural default UnwindPlan for the initial instruction of a
1004 // function, use that.
1005 if (m_current_offset == 0) {
1006 unwind_plan_sp =
1007 func_unwinders_sp->GetUnwindPlanArchitectureDefaultAtFunctionEntry(
1008 thread&: m_thread);
1009 if (unwind_plan_sp) {
1010 UnwindLogMsgVerbose(fmt: "frame uses %s for full UnwindPlan because we are at "
1011 "the first instruction of a function",
1012 unwind_plan_sp->GetSourceName().GetCString());
1013 return unwind_plan_sp;
1014 }
1015 }
1016 }
1017
1018 // Typically this is unwind info from an eh_frame section intended for
1019 // exception handling; only valid at call sites
1020 if (process) {
1021 unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtCallSite(
1022 target&: process->GetTarget(), thread&: m_thread);
1023 }
1024 if (IsUnwindPlanValidForCurrentPC(unwind_plan_sp)) {
1025 UnwindLogMsgVerbose(fmt: "frame uses %s for full UnwindPlan because this "
1026 "is the call-site unwind plan",
1027 unwind_plan_sp->GetSourceName().GetCString());
1028 return unwind_plan_sp;
1029 }
1030
1031 // We'd prefer to use an UnwindPlan intended for call sites when we're at a
1032 // call site but if we've struck out on that, fall back to using the non-
1033 // call-site assembly inspection UnwindPlan if possible.
1034 if (process) {
1035 unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite(
1036 target&: process->GetTarget(), thread&: m_thread);
1037 }
1038 if (unwind_plan_sp &&
1039 unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolNo) {
1040 // We probably have an UnwindPlan created by inspecting assembly
1041 // instructions. The assembly profilers work really well with compiler-
1042 // generated functions but hand- written assembly can be problematic. We
1043 // set the eh_frame based unwind plan as our fallback unwind plan if
1044 // instruction emulation doesn't work out even for non call sites if it is
1045 // available and use the architecture default unwind plan if it is not
1046 // available. The eh_frame unwind plan is more reliable even on non call
1047 // sites then the architecture default plan and for hand written assembly
1048 // code it is often written in a way that it valid at all location what
1049 // helps in the most common cases when the instruction emulation fails.
1050 UnwindPlanSP call_site_unwind_plan =
1051 func_unwinders_sp->GetUnwindPlanAtCallSite(target&: process->GetTarget(),
1052 thread&: m_thread);
1053 if (call_site_unwind_plan &&
1054 call_site_unwind_plan.get() != unwind_plan_sp.get() &&
1055 call_site_unwind_plan->GetSourceName() !=
1056 unwind_plan_sp->GetSourceName()) {
1057 m_fallback_unwind_plan_sp = call_site_unwind_plan;
1058 } else {
1059 m_fallback_unwind_plan_sp = arch_default_unwind_plan_sp;
1060 }
1061 }
1062
1063 if (IsUnwindPlanValidForCurrentPC(unwind_plan_sp)) {
1064 UnwindLogMsgVerbose(fmt: "frame uses %s for full UnwindPlan because we "
1065 "failed to find a call-site unwind plan that would work",
1066 unwind_plan_sp->GetSourceName().GetCString());
1067 return unwind_plan_sp;
1068 }
1069
1070 // If nothing else, use the architectural default UnwindPlan and hope that
1071 // does the job.
1072 if (arch_default_unwind_plan_sp)
1073 UnwindLogMsgVerbose(
1074 fmt: "frame uses %s for full UnwindPlan because we are falling back "
1075 "to the arch default plan",
1076 arch_default_unwind_plan_sp->GetSourceName().GetCString());
1077 else
1078 UnwindLogMsg(
1079 fmt: "Unable to find any UnwindPlan for full unwind of this frame.");
1080
1081 return arch_default_unwind_plan_sp;
1082}
1083
1084void RegisterContextUnwind::InvalidateAllRegisters() {
1085 m_frame_type = eNotAValidFrame;
1086}
1087
1088size_t RegisterContextUnwind::GetRegisterCount() {
1089 return m_thread.GetRegisterContext()->GetRegisterCount();
1090}
1091
1092const RegisterInfo *RegisterContextUnwind::GetRegisterInfoAtIndex(size_t reg) {
1093 return m_thread.GetRegisterContext()->GetRegisterInfoAtIndex(reg);
1094}
1095
1096size_t RegisterContextUnwind::GetRegisterSetCount() {
1097 return m_thread.GetRegisterContext()->GetRegisterSetCount();
1098}
1099
1100const RegisterSet *RegisterContextUnwind::GetRegisterSet(size_t reg_set) {
1101 return m_thread.GetRegisterContext()->GetRegisterSet(reg_set);
1102}
1103
1104uint32_t RegisterContextUnwind::ConvertRegisterKindToRegisterNumber(
1105 lldb::RegisterKind kind, uint32_t num) {
1106 return m_thread.GetRegisterContext()->ConvertRegisterKindToRegisterNumber(
1107 kind, num);
1108}
1109
1110bool RegisterContextUnwind::ReadRegisterValueFromRegisterLocation(
1111 lldb_private::UnwindLLDB::RegisterLocation regloc,
1112 const RegisterInfo *reg_info, RegisterValue &value) {
1113 if (!IsValid())
1114 return false;
1115 bool success = false;
1116
1117 switch (regloc.type) {
1118 case UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext: {
1119 const RegisterInfo *other_reg_info =
1120 GetRegisterInfoAtIndex(reg: regloc.location.register_number);
1121
1122 if (!other_reg_info)
1123 return false;
1124
1125 success =
1126 m_thread.GetRegisterContext()->ReadRegister(reg_info: other_reg_info, reg_value&: value);
1127 } break;
1128 case UnwindLLDB::RegisterLocation::eRegisterInRegister: {
1129 const RegisterInfo *other_reg_info =
1130 GetRegisterInfoAtIndex(reg: regloc.location.register_number);
1131
1132 if (!other_reg_info)
1133 return false;
1134
1135 if (IsFrameZero()) {
1136 success =
1137 m_thread.GetRegisterContext()->ReadRegister(reg_info: other_reg_info, reg_value&: value);
1138 } else {
1139 success = GetNextFrame()->ReadRegister(reg_info: other_reg_info, value);
1140 }
1141 } break;
1142 case UnwindLLDB::RegisterLocation::eRegisterValueInferred:
1143 success =
1144 value.SetUInt(uint: regloc.location.inferred_value, byte_size: reg_info->byte_size);
1145 break;
1146
1147 case UnwindLLDB::RegisterLocation::eRegisterNotSaved:
1148 break;
1149 case UnwindLLDB::RegisterLocation::eRegisterSavedAtHostMemoryLocation:
1150 llvm_unreachable("FIXME debugger inferior function call unwind");
1151 case UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation: {
1152 Status error(ReadRegisterValueFromMemory(
1153 reg_info, src_addr: regloc.location.target_memory_location, src_len: reg_info->byte_size,
1154 reg_value&: value));
1155 success = error.Success();
1156 } break;
1157 default:
1158 llvm_unreachable("Unknown RegisterLocation type.");
1159 }
1160 return success;
1161}
1162
1163bool RegisterContextUnwind::WriteRegisterValueToRegisterLocation(
1164 lldb_private::UnwindLLDB::RegisterLocation regloc,
1165 const RegisterInfo *reg_info, const RegisterValue &value) {
1166 if (!IsValid())
1167 return false;
1168
1169 bool success = false;
1170
1171 switch (regloc.type) {
1172 case UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext: {
1173 const RegisterInfo *other_reg_info =
1174 GetRegisterInfoAtIndex(reg: regloc.location.register_number);
1175 success =
1176 m_thread.GetRegisterContext()->WriteRegister(reg_info: other_reg_info, reg_value: value);
1177 } break;
1178 case UnwindLLDB::RegisterLocation::eRegisterInRegister: {
1179 const RegisterInfo *other_reg_info =
1180 GetRegisterInfoAtIndex(reg: regloc.location.register_number);
1181 if (IsFrameZero()) {
1182 success =
1183 m_thread.GetRegisterContext()->WriteRegister(reg_info: other_reg_info, reg_value: value);
1184 } else {
1185 success = GetNextFrame()->WriteRegister(reg_info: other_reg_info, value);
1186 }
1187 } break;
1188 case UnwindLLDB::RegisterLocation::eRegisterValueInferred:
1189 case UnwindLLDB::RegisterLocation::eRegisterNotSaved:
1190 break;
1191 case UnwindLLDB::RegisterLocation::eRegisterSavedAtHostMemoryLocation:
1192 llvm_unreachable("FIXME debugger inferior function call unwind");
1193 case UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation: {
1194 Status error(WriteRegisterValueToMemory(
1195 reg_info, dst_addr: regloc.location.target_memory_location, dst_len: reg_info->byte_size,
1196 reg_value: value));
1197 success = error.Success();
1198 } break;
1199 default:
1200 llvm_unreachable("Unknown RegisterLocation type.");
1201 }
1202 return success;
1203}
1204
1205bool RegisterContextUnwind::IsValid() const {
1206 return m_frame_type != eNotAValidFrame;
1207}
1208
1209// After the final stack frame in a stack walk we'll get one invalid
1210// (eNotAValidFrame) stack frame -- one past the end of the stack walk. But
1211// higher-level code will need to tell the difference between "the unwind plan
1212// below this frame failed" versus "we successfully completed the stack walk"
1213// so this method helps to disambiguate that.
1214
1215bool RegisterContextUnwind::IsTrapHandlerFrame() const {
1216 return m_frame_type == eTrapHandlerFrame;
1217}
1218
1219// A skip frame is a bogus frame on the stack -- but one where we're likely to
1220// find a real frame farther
1221// up the stack if we keep looking. It's always the second frame in an unwind
1222// (i.e. the first frame after frame zero) where unwinding can be the
1223// trickiest. Ideally we'll mark up this frame in some way so the user knows
1224// we're displaying bad data and we may have skipped one frame of their real
1225// program in the process of getting back on track.
1226
1227bool RegisterContextUnwind::IsSkipFrame() const {
1228 return m_frame_type == eSkipFrame;
1229}
1230
1231bool RegisterContextUnwind::IsTrapHandlerSymbol(
1232 lldb_private::Process *process,
1233 const lldb_private::SymbolContext &m_sym_ctx) const {
1234 PlatformSP platform_sp(process->GetTarget().GetPlatform());
1235 if (platform_sp) {
1236 const std::vector<ConstString> trap_handler_names(
1237 platform_sp->GetTrapHandlerSymbolNames());
1238 for (ConstString name : trap_handler_names) {
1239 if ((m_sym_ctx.function && m_sym_ctx.function->GetName() == name) ||
1240 (m_sym_ctx.symbol && m_sym_ctx.symbol->GetName() == name)) {
1241 return true;
1242 }
1243 }
1244 }
1245 const std::vector<ConstString> user_specified_trap_handler_names(
1246 m_parent_unwind.GetUserSpecifiedTrapHandlerFunctionNames());
1247 for (ConstString name : user_specified_trap_handler_names) {
1248 if ((m_sym_ctx.function && m_sym_ctx.function->GetName() == name) ||
1249 (m_sym_ctx.symbol && m_sym_ctx.symbol->GetName() == name)) {
1250 return true;
1251 }
1252 }
1253
1254 return false;
1255}
1256
1257// Answer the question: Where did THIS frame save the CALLER frame ("previous"
1258// frame)'s register value?
1259
1260enum UnwindLLDB::RegisterSearchResult
1261RegisterContextUnwind::SavedLocationForRegister(
1262 uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation &regloc) {
1263 RegisterNumber regnum(m_thread, eRegisterKindLLDB, lldb_regnum);
1264 Log *log = GetLog(mask: LLDBLog::Unwind);
1265
1266 // Have we already found this register location?
1267 if (!m_registers.empty()) {
1268 std::map<uint32_t,
1269 lldb_private::UnwindLLDB::RegisterLocation>::const_iterator
1270 iterator;
1271 iterator = m_registers.find(x: regnum.GetAsKind(kind: eRegisterKindLLDB));
1272 if (iterator != m_registers.end()) {
1273 regloc = iterator->second;
1274 UnwindLogMsg(fmt: "supplying caller's saved %s (%d)'s location, cached",
1275 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB));
1276 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1277 }
1278 }
1279
1280 // Look through the available UnwindPlans for the register location.
1281
1282 UnwindPlan::Row::RegisterLocation unwindplan_regloc;
1283 bool have_unwindplan_regloc = false;
1284 RegisterKind unwindplan_registerkind = kNumRegisterKinds;
1285
1286 if (m_fast_unwind_plan_sp) {
1287 UnwindPlan::RowSP active_row =
1288 m_fast_unwind_plan_sp->GetRowForFunctionOffset(offset: m_current_offset);
1289 unwindplan_registerkind = m_fast_unwind_plan_sp->GetRegisterKind();
1290 if (regnum.GetAsKind(kind: unwindplan_registerkind) == LLDB_INVALID_REGNUM) {
1291 UnwindLogMsg(fmt: "could not convert lldb regnum %s (%d) into %d RegisterKind "
1292 "reg numbering scheme",
1293 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB),
1294 (int)unwindplan_registerkind);
1295 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1296 }
1297 // The architecture default unwind plan marks unknown registers as
1298 // Undefined so that we don't forward them up the stack when a
1299 // jitted stack frame may have overwritten them. But when the
1300 // arch default unwind plan is used as the Fast Unwind Plan, we
1301 // need to recognize this & switch over to the Full Unwind Plan
1302 // to see what unwind rule that (more knoweldgeable, probably)
1303 // UnwindPlan has. If the full UnwindPlan says the register
1304 // location is Undefined, then it really is.
1305 if (active_row->GetRegisterInfo(reg_num: regnum.GetAsKind(kind: unwindplan_registerkind),
1306 register_location&: unwindplan_regloc) &&
1307 !unwindplan_regloc.IsUndefined()) {
1308 UnwindLogMsg(
1309 fmt: "supplying caller's saved %s (%d)'s location using FastUnwindPlan",
1310 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB));
1311 have_unwindplan_regloc = true;
1312 }
1313 }
1314
1315 if (!have_unwindplan_regloc) {
1316 // m_full_unwind_plan_sp being NULL means that we haven't tried to find a
1317 // full UnwindPlan yet
1318 bool got_new_full_unwindplan = false;
1319 if (!m_full_unwind_plan_sp) {
1320 m_full_unwind_plan_sp = GetFullUnwindPlanForFrame();
1321 got_new_full_unwindplan = true;
1322 }
1323
1324 if (m_full_unwind_plan_sp) {
1325 RegisterNumber pc_regnum(m_thread, eRegisterKindGeneric,
1326 LLDB_REGNUM_GENERIC_PC);
1327
1328 UnwindPlan::RowSP active_row =
1329 m_full_unwind_plan_sp->GetRowForFunctionOffset(
1330 offset: m_current_offset_backed_up_one);
1331 unwindplan_registerkind = m_full_unwind_plan_sp->GetRegisterKind();
1332
1333 if (got_new_full_unwindplan && active_row.get() && log) {
1334 StreamString active_row_strm;
1335 ExecutionContext exe_ctx(m_thread.shared_from_this());
1336 active_row->Dump(s&: active_row_strm, unwind_plan: m_full_unwind_plan_sp.get(),
1337 thread: &m_thread,
1338 base_addr: m_start_pc.GetLoadAddress(target: exe_ctx.GetTargetPtr()));
1339 UnwindLogMsg(fmt: "Using full unwind plan '%s'",
1340 m_full_unwind_plan_sp->GetSourceName().AsCString());
1341 UnwindLogMsg(fmt: "active row: %s", active_row_strm.GetData());
1342 }
1343 RegisterNumber return_address_reg;
1344
1345 // If we're fetching the saved pc and this UnwindPlan defines a
1346 // ReturnAddress register (e.g. lr on arm), look for the return address
1347 // register number in the UnwindPlan's row.
1348 if (pc_regnum.IsValid() && pc_regnum == regnum &&
1349 m_full_unwind_plan_sp->GetReturnAddressRegister() !=
1350 LLDB_INVALID_REGNUM) {
1351 // If this is a trap handler frame, we should have access to
1352 // the complete register context when the interrupt/async
1353 // signal was received, we should fetch the actual saved $pc
1354 // value instead of the Return Address register.
1355 // If $pc is not available, fall back to the RA reg.
1356 UnwindPlan::Row::RegisterLocation scratch;
1357 if (m_frame_type == eTrapHandlerFrame &&
1358 active_row->GetRegisterInfo
1359 (reg_num: pc_regnum.GetAsKind (kind: unwindplan_registerkind), register_location&: scratch)) {
1360 UnwindLogMsg(fmt: "Providing pc register instead of rewriting to "
1361 "RA reg because this is a trap handler and there is "
1362 "a location for the saved pc register value.");
1363 } else {
1364 return_address_reg.init(
1365 thread&: m_thread, kind: m_full_unwind_plan_sp->GetRegisterKind(),
1366 num: m_full_unwind_plan_sp->GetReturnAddressRegister());
1367 regnum = return_address_reg;
1368 UnwindLogMsg(fmt: "requested caller's saved PC but this UnwindPlan uses a "
1369 "RA reg; getting %s (%d) instead",
1370 return_address_reg.GetName(),
1371 return_address_reg.GetAsKind(kind: eRegisterKindLLDB));
1372 }
1373 } else {
1374 if (regnum.GetAsKind(kind: unwindplan_registerkind) == LLDB_INVALID_REGNUM) {
1375 if (unwindplan_registerkind == eRegisterKindGeneric) {
1376 UnwindLogMsg(fmt: "could not convert lldb regnum %s (%d) into "
1377 "eRegisterKindGeneric reg numbering scheme",
1378 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB));
1379 } else {
1380 UnwindLogMsg(fmt: "could not convert lldb regnum %s (%d) into %d "
1381 "RegisterKind reg numbering scheme",
1382 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB),
1383 (int)unwindplan_registerkind);
1384 }
1385 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1386 }
1387 }
1388
1389 if (regnum.IsValid() &&
1390 active_row->GetRegisterInfo(reg_num: regnum.GetAsKind(kind: unwindplan_registerkind),
1391 register_location&: unwindplan_regloc)) {
1392 have_unwindplan_regloc = true;
1393 UnwindLogMsg(
1394 fmt: "supplying caller's saved %s (%d)'s location using %s UnwindPlan",
1395 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB),
1396 m_full_unwind_plan_sp->GetSourceName().GetCString());
1397 }
1398
1399 // This is frame 0 and we're retrieving the PC and it's saved in a Return
1400 // Address register and it hasn't been saved anywhere yet -- that is,
1401 // it's still live in the actual register. Handle this specially.
1402
1403 if (!have_unwindplan_regloc && return_address_reg.IsValid() &&
1404 IsFrameZero()) {
1405 if (return_address_reg.GetAsKind(kind: eRegisterKindLLDB) !=
1406 LLDB_INVALID_REGNUM) {
1407 lldb_private::UnwindLLDB::RegisterLocation new_regloc;
1408 new_regloc.type =
1409 UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext;
1410 new_regloc.location.register_number =
1411 return_address_reg.GetAsKind(kind: eRegisterKindLLDB);
1412 m_registers[regnum.GetAsKind(kind: eRegisterKindLLDB)] = new_regloc;
1413 regloc = new_regloc;
1414 UnwindLogMsg(fmt: "supplying caller's register %s (%d) from the live "
1415 "RegisterContext at frame 0, saved in %d",
1416 return_address_reg.GetName(),
1417 return_address_reg.GetAsKind(kind: eRegisterKindLLDB),
1418 return_address_reg.GetAsKind(kind: eRegisterKindLLDB));
1419 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1420 }
1421 }
1422
1423 // If this architecture stores the return address in a register (it
1424 // defines a Return Address register) and we're on a non-zero stack frame
1425 // and the Full UnwindPlan says that the pc is stored in the
1426 // RA registers (e.g. lr on arm), then we know that the full unwindplan is
1427 // not trustworthy -- this
1428 // is an impossible situation and the instruction emulation code has
1429 // likely been misled. If this stack frame meets those criteria, we need
1430 // to throw away the Full UnwindPlan that the instruction emulation came
1431 // up with and fall back to the architecture's Default UnwindPlan so the
1432 // stack walk can get past this point.
1433
1434 // Special note: If the Full UnwindPlan was generated from the compiler,
1435 // don't second-guess it when we're at a call site location.
1436
1437 // arch_default_ra_regnum is the return address register # in the Full
1438 // UnwindPlan register numbering
1439 RegisterNumber arch_default_ra_regnum(m_thread, eRegisterKindGeneric,
1440 LLDB_REGNUM_GENERIC_RA);
1441
1442 if (arch_default_ra_regnum.GetAsKind(kind: unwindplan_registerkind) !=
1443 LLDB_INVALID_REGNUM &&
1444 pc_regnum == regnum && unwindplan_regloc.IsInOtherRegister() &&
1445 unwindplan_regloc.GetRegisterNumber() ==
1446 arch_default_ra_regnum.GetAsKind(kind: unwindplan_registerkind) &&
1447 m_full_unwind_plan_sp->GetSourcedFromCompiler() != eLazyBoolYes &&
1448 !m_all_registers_available) {
1449 UnwindLogMsg(fmt: "%s UnwindPlan tried to restore the pc from the link "
1450 "register but this is a non-zero frame",
1451 m_full_unwind_plan_sp->GetSourceName().GetCString());
1452
1453 // Throw away the full unwindplan; install the arch default unwindplan
1454 if (ForceSwitchToFallbackUnwindPlan()) {
1455 // Update for the possibly new unwind plan
1456 unwindplan_registerkind = m_full_unwind_plan_sp->GetRegisterKind();
1457 UnwindPlan::RowSP active_row =
1458 m_full_unwind_plan_sp->GetRowForFunctionOffset(offset: m_current_offset);
1459
1460 // Sanity check: Verify that we can fetch a pc value and CFA value
1461 // with this unwind plan
1462
1463 RegisterNumber arch_default_pc_reg(m_thread, eRegisterKindGeneric,
1464 LLDB_REGNUM_GENERIC_PC);
1465 bool can_fetch_pc_value = false;
1466 bool can_fetch_cfa = false;
1467 addr_t cfa_value;
1468 if (active_row) {
1469 if (arch_default_pc_reg.GetAsKind(kind: unwindplan_registerkind) !=
1470 LLDB_INVALID_REGNUM &&
1471 active_row->GetRegisterInfo(
1472 reg_num: arch_default_pc_reg.GetAsKind(kind: unwindplan_registerkind),
1473 register_location&: unwindplan_regloc)) {
1474 can_fetch_pc_value = true;
1475 }
1476 if (ReadFrameAddress(register_kind: unwindplan_registerkind,
1477 fa&: active_row->GetCFAValue(), address&: cfa_value)) {
1478 can_fetch_cfa = true;
1479 }
1480 }
1481
1482 have_unwindplan_regloc = can_fetch_pc_value && can_fetch_cfa;
1483 } else {
1484 // We were unable to fall back to another unwind plan
1485 have_unwindplan_regloc = false;
1486 }
1487 }
1488 }
1489 }
1490
1491 ExecutionContext exe_ctx(m_thread.shared_from_this());
1492 Process *process = exe_ctx.GetProcessPtr();
1493 if (!have_unwindplan_regloc) {
1494 // If the UnwindPlan failed to give us an unwind location for this
1495 // register, we may be able to fall back to some ABI-defined default. For
1496 // example, some ABIs allow to determine the caller's SP via the CFA. Also,
1497 // the ABI may set volatile registers to the undefined state.
1498 ABI *abi = process ? process->GetABI().get() : nullptr;
1499 if (abi) {
1500 const RegisterInfo *reg_info =
1501 GetRegisterInfoAtIndex(reg: regnum.GetAsKind(kind: eRegisterKindLLDB));
1502 if (reg_info &&
1503 abi->GetFallbackRegisterLocation(reg_info, unwind_regloc&: unwindplan_regloc)) {
1504 UnwindLogMsg(
1505 fmt: "supplying caller's saved %s (%d)'s location using ABI default",
1506 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB));
1507 have_unwindplan_regloc = true;
1508 }
1509 }
1510 }
1511
1512 if (!have_unwindplan_regloc) {
1513 if (IsFrameZero()) {
1514 // This is frame 0 - we should return the actual live register context
1515 // value
1516 lldb_private::UnwindLLDB::RegisterLocation new_regloc;
1517 new_regloc.type =
1518 UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext;
1519 new_regloc.location.register_number = regnum.GetAsKind(kind: eRegisterKindLLDB);
1520 m_registers[regnum.GetAsKind(kind: eRegisterKindLLDB)] = new_regloc;
1521 regloc = new_regloc;
1522 UnwindLogMsg(fmt: "supplying caller's register %s (%d) from the live "
1523 "RegisterContext at frame 0",
1524 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB));
1525 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1526 } else {
1527 std::string unwindplan_name;
1528 if (m_full_unwind_plan_sp) {
1529 unwindplan_name += "via '";
1530 unwindplan_name += m_full_unwind_plan_sp->GetSourceName().AsCString();
1531 unwindplan_name += "'";
1532 }
1533 UnwindLogMsg(fmt: "no save location for %s (%d) %s", regnum.GetName(),
1534 regnum.GetAsKind(kind: eRegisterKindLLDB),
1535 unwindplan_name.c_str());
1536 }
1537 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1538 }
1539
1540 // unwindplan_regloc has valid contents about where to retrieve the register
1541 if (unwindplan_regloc.IsUnspecified()) {
1542 lldb_private::UnwindLLDB::RegisterLocation new_regloc = {};
1543 new_regloc.type = UnwindLLDB::RegisterLocation::eRegisterNotSaved;
1544 m_registers[regnum.GetAsKind(kind: eRegisterKindLLDB)] = new_regloc;
1545 UnwindLogMsg(fmt: "save location for %s (%d) is unspecified, continue searching",
1546 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB));
1547 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1548 }
1549
1550 if (unwindplan_regloc.IsUndefined()) {
1551 UnwindLogMsg(
1552 fmt: "did not supply reg location for %s (%d) because it is volatile",
1553 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB));
1554 return UnwindLLDB::RegisterSearchResult::eRegisterIsVolatile;
1555 }
1556
1557 if (unwindplan_regloc.IsSame()) {
1558 if (!IsFrameZero() &&
1559 (regnum.GetAsKind(kind: eRegisterKindGeneric) == LLDB_REGNUM_GENERIC_PC ||
1560 regnum.GetAsKind(kind: eRegisterKindGeneric) == LLDB_REGNUM_GENERIC_RA)) {
1561 UnwindLogMsg(fmt: "register %s (%d) is marked as 'IsSame' - it is a pc or "
1562 "return address reg on a non-zero frame -- treat as if we "
1563 "have no information",
1564 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB));
1565 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1566 } else {
1567 regloc.type = UnwindLLDB::RegisterLocation::eRegisterInRegister;
1568 regloc.location.register_number = regnum.GetAsKind(kind: eRegisterKindLLDB);
1569 m_registers[regnum.GetAsKind(kind: eRegisterKindLLDB)] = regloc;
1570 UnwindLogMsg(
1571 fmt: "supplying caller's register %s (%d), saved in register %s (%d)",
1572 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB),
1573 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB));
1574 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1575 }
1576 }
1577
1578 if (unwindplan_regloc.IsCFAPlusOffset()) {
1579 int offset = unwindplan_regloc.GetOffset();
1580 regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
1581 regloc.location.inferred_value = m_cfa + offset;
1582 m_registers[regnum.GetAsKind(kind: eRegisterKindLLDB)] = regloc;
1583 UnwindLogMsg(fmt: "supplying caller's register %s (%d), value is CFA plus "
1584 "offset %d [value is 0x%" PRIx64 "]",
1585 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB), offset,
1586 regloc.location.inferred_value);
1587 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1588 }
1589
1590 if (unwindplan_regloc.IsAtCFAPlusOffset()) {
1591 int offset = unwindplan_regloc.GetOffset();
1592 regloc.type = UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation;
1593 regloc.location.target_memory_location = m_cfa + offset;
1594 m_registers[regnum.GetAsKind(kind: eRegisterKindLLDB)] = regloc;
1595 UnwindLogMsg(fmt: "supplying caller's register %s (%d) from the stack, saved at "
1596 "CFA plus offset %d [saved at 0x%" PRIx64 "]",
1597 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB), offset,
1598 regloc.location.target_memory_location);
1599 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1600 }
1601
1602 if (unwindplan_regloc.IsAFAPlusOffset()) {
1603 if (m_afa == LLDB_INVALID_ADDRESS)
1604 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1605
1606 int offset = unwindplan_regloc.GetOffset();
1607 regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
1608 regloc.location.inferred_value = m_afa + offset;
1609 m_registers[regnum.GetAsKind(kind: eRegisterKindLLDB)] = regloc;
1610 UnwindLogMsg(fmt: "supplying caller's register %s (%d), value is AFA plus "
1611 "offset %d [value is 0x%" PRIx64 "]",
1612 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB), offset,
1613 regloc.location.inferred_value);
1614 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1615 }
1616
1617 if (unwindplan_regloc.IsAtAFAPlusOffset()) {
1618 if (m_afa == LLDB_INVALID_ADDRESS)
1619 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1620
1621 int offset = unwindplan_regloc.GetOffset();
1622 regloc.type = UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation;
1623 regloc.location.target_memory_location = m_afa + offset;
1624 m_registers[regnum.GetAsKind(kind: eRegisterKindLLDB)] = regloc;
1625 UnwindLogMsg(fmt: "supplying caller's register %s (%d) from the stack, saved at "
1626 "AFA plus offset %d [saved at 0x%" PRIx64 "]",
1627 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB), offset,
1628 regloc.location.target_memory_location);
1629 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1630 }
1631
1632 if (unwindplan_regloc.IsInOtherRegister()) {
1633 uint32_t unwindplan_regnum = unwindplan_regloc.GetRegisterNumber();
1634 RegisterNumber row_regnum(m_thread, unwindplan_registerkind,
1635 unwindplan_regnum);
1636 if (row_regnum.GetAsKind(kind: eRegisterKindLLDB) == LLDB_INVALID_REGNUM) {
1637 UnwindLogMsg(fmt: "could not supply caller's %s (%d) location - was saved in "
1638 "another reg but couldn't convert that regnum",
1639 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB));
1640 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1641 }
1642 regloc.type = UnwindLLDB::RegisterLocation::eRegisterInRegister;
1643 regloc.location.register_number = row_regnum.GetAsKind(kind: eRegisterKindLLDB);
1644 m_registers[regnum.GetAsKind(kind: eRegisterKindLLDB)] = regloc;
1645 UnwindLogMsg(
1646 fmt: "supplying caller's register %s (%d), saved in register %s (%d)",
1647 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB),
1648 row_regnum.GetName(), row_regnum.GetAsKind(kind: eRegisterKindLLDB));
1649 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1650 }
1651
1652 if (unwindplan_regloc.IsDWARFExpression() ||
1653 unwindplan_regloc.IsAtDWARFExpression()) {
1654 DataExtractor dwarfdata(unwindplan_regloc.GetDWARFExpressionBytes(),
1655 unwindplan_regloc.GetDWARFExpressionLength(),
1656 process->GetByteOrder(),
1657 process->GetAddressByteSize());
1658 ModuleSP opcode_ctx;
1659 DWARFExpressionList dwarfexpr(opcode_ctx, dwarfdata, nullptr);
1660 dwarfexpr.GetMutableExpressionAtAddress()->SetRegisterKind(
1661 unwindplan_registerkind);
1662 Value cfa_val = Scalar(m_cfa);
1663 cfa_val.SetValueType(Value::ValueType::LoadAddress);
1664 Value result;
1665 Status error;
1666 if (dwarfexpr.Evaluate(exe_ctx: &exe_ctx, reg_ctx: this, func_load_addr: 0, initial_value_ptr: &cfa_val, object_address_ptr: nullptr, result,
1667 error_ptr: &error)) {
1668 addr_t val;
1669 val = result.GetScalar().ULongLong();
1670 if (unwindplan_regloc.IsDWARFExpression()) {
1671 regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
1672 regloc.location.inferred_value = val;
1673 m_registers[regnum.GetAsKind(kind: eRegisterKindLLDB)] = regloc;
1674 UnwindLogMsg(fmt: "supplying caller's register %s (%d) via DWARF expression "
1675 "(IsDWARFExpression)",
1676 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB));
1677 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1678 } else {
1679 regloc.type =
1680 UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation;
1681 regloc.location.target_memory_location = val;
1682 m_registers[regnum.GetAsKind(kind: eRegisterKindLLDB)] = regloc;
1683 UnwindLogMsg(fmt: "supplying caller's register %s (%d) via DWARF expression "
1684 "(IsAtDWARFExpression)",
1685 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB));
1686 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
1687 }
1688 }
1689 UnwindLogMsg(fmt: "tried to use IsDWARFExpression or IsAtDWARFExpression for %s "
1690 "(%d) but failed",
1691 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB));
1692 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1693 }
1694
1695 UnwindLogMsg(fmt: "no save location for %s (%d) in this stack frame",
1696 regnum.GetName(), regnum.GetAsKind(kind: eRegisterKindLLDB));
1697
1698 // FIXME UnwindPlan::Row types atDWARFExpression and isDWARFExpression are
1699 // unsupported.
1700
1701 return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
1702}
1703
1704// TryFallbackUnwindPlan() -- this method is a little tricky.
1705//
1706// When this is called, the frame above -- the caller frame, the "previous"
1707// frame -- is invalid or bad.
1708//
1709// Instead of stopping the stack walk here, we'll try a different UnwindPlan
1710// and see if we can get a valid frame above us.
1711//
1712// This most often happens when an unwind plan based on assembly instruction
1713// inspection is not correct -- mostly with hand-written assembly functions or
1714// functions where the stack frame is set up "out of band", e.g. the kernel
1715// saved the register context and then called an asynchronous trap handler like
1716// _sigtramp.
1717//
1718// Often in these cases, if we just do a dumb stack walk we'll get past this
1719// tricky frame and our usual techniques can continue to be used.
1720
1721bool RegisterContextUnwind::TryFallbackUnwindPlan() {
1722 if (m_fallback_unwind_plan_sp.get() == nullptr)
1723 return false;
1724
1725 if (m_full_unwind_plan_sp.get() == nullptr)
1726 return false;
1727
1728 if (m_full_unwind_plan_sp.get() == m_fallback_unwind_plan_sp.get() ||
1729 m_full_unwind_plan_sp->GetSourceName() ==
1730 m_fallback_unwind_plan_sp->GetSourceName()) {
1731 return false;
1732 }
1733
1734 // If a compiler generated unwind plan failed, trying the arch default
1735 // unwindplan isn't going to do any better.
1736 if (m_full_unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolYes)
1737 return false;
1738
1739 // Get the caller's pc value and our own CFA value. Swap in the fallback
1740 // unwind plan, re-fetch the caller's pc value and CFA value. If they're the
1741 // same, then the fallback unwind plan provides no benefit.
1742
1743 RegisterNumber pc_regnum(m_thread, eRegisterKindGeneric,
1744 LLDB_REGNUM_GENERIC_PC);
1745
1746 addr_t old_caller_pc_value = LLDB_INVALID_ADDRESS;
1747 addr_t new_caller_pc_value = LLDB_INVALID_ADDRESS;
1748 UnwindLLDB::RegisterLocation regloc = {};
1749 if (SavedLocationForRegister(lldb_regnum: pc_regnum.GetAsKind(kind: eRegisterKindLLDB),
1750 regloc) ==
1751 UnwindLLDB::RegisterSearchResult::eRegisterFound) {
1752 const RegisterInfo *reg_info =
1753 GetRegisterInfoAtIndex(reg: pc_regnum.GetAsKind(kind: eRegisterKindLLDB));
1754 if (reg_info) {
1755 RegisterValue reg_value;
1756 if (ReadRegisterValueFromRegisterLocation(regloc, reg_info, value&: reg_value)) {
1757 old_caller_pc_value = reg_value.GetAsUInt64();
1758 if (ProcessSP process_sp = m_thread.GetProcess()) {
1759 if (ABISP abi_sp = process_sp->GetABI())
1760 old_caller_pc_value = abi_sp->FixCodeAddress(pc: old_caller_pc_value);
1761 }
1762 }
1763 }
1764 }
1765
1766 // This is a tricky wrinkle! If SavedLocationForRegister() detects a really
1767 // impossible register location for the full unwind plan, it may call
1768 // ForceSwitchToFallbackUnwindPlan() which in turn replaces the full
1769 // unwindplan with the fallback... in short, we're done, we're using the
1770 // fallback UnwindPlan. We checked if m_fallback_unwind_plan_sp was nullptr
1771 // at the top -- the only way it became nullptr since then is via
1772 // SavedLocationForRegister().
1773 if (m_fallback_unwind_plan_sp.get() == nullptr)
1774 return true;
1775
1776 // Switch the full UnwindPlan to be the fallback UnwindPlan. If we decide
1777 // this isn't working, we need to restore. We'll also need to save & restore
1778 // the value of the m_cfa ivar. Save is down below a bit in 'old_cfa'.
1779 UnwindPlanSP original_full_unwind_plan_sp = m_full_unwind_plan_sp;
1780 addr_t old_cfa = m_cfa;
1781 addr_t old_afa = m_afa;
1782
1783 m_registers.clear();
1784
1785 m_full_unwind_plan_sp = m_fallback_unwind_plan_sp;
1786
1787 UnwindPlan::RowSP active_row =
1788 m_fallback_unwind_plan_sp->GetRowForFunctionOffset(
1789 offset: m_current_offset_backed_up_one);
1790
1791 if (active_row &&
1792 active_row->GetCFAValue().GetValueType() !=
1793 UnwindPlan::Row::FAValue::unspecified) {
1794 addr_t new_cfa;
1795 if (!ReadFrameAddress(register_kind: m_fallback_unwind_plan_sp->GetRegisterKind(),
1796 fa&: active_row->GetCFAValue(), address&: new_cfa) ||
1797 new_cfa == 0 || new_cfa == 1 || new_cfa == LLDB_INVALID_ADDRESS) {
1798 UnwindLogMsg(fmt: "failed to get cfa with fallback unwindplan");
1799 m_fallback_unwind_plan_sp.reset();
1800 m_full_unwind_plan_sp = original_full_unwind_plan_sp;
1801 return false;
1802 }
1803 m_cfa = new_cfa;
1804
1805 ReadFrameAddress(register_kind: m_fallback_unwind_plan_sp->GetRegisterKind(),
1806 fa&: active_row->GetAFAValue(), address&: m_afa);
1807
1808 if (SavedLocationForRegister(lldb_regnum: pc_regnum.GetAsKind(kind: eRegisterKindLLDB),
1809 regloc) ==
1810 UnwindLLDB::RegisterSearchResult::eRegisterFound) {
1811 const RegisterInfo *reg_info =
1812 GetRegisterInfoAtIndex(reg: pc_regnum.GetAsKind(kind: eRegisterKindLLDB));
1813 if (reg_info) {
1814 RegisterValue reg_value;
1815 if (ReadRegisterValueFromRegisterLocation(regloc, reg_info,
1816 value&: reg_value)) {
1817 new_caller_pc_value = reg_value.GetAsUInt64();
1818 if (ProcessSP process_sp = m_thread.GetProcess()) {
1819 if (ABISP abi_sp = process_sp->GetABI())
1820 new_caller_pc_value = abi_sp->FixCodeAddress(pc: new_caller_pc_value);
1821 }
1822 }
1823 }
1824 }
1825
1826 if (new_caller_pc_value == LLDB_INVALID_ADDRESS) {
1827 UnwindLogMsg(fmt: "failed to get a pc value for the caller frame with the "
1828 "fallback unwind plan");
1829 m_fallback_unwind_plan_sp.reset();
1830 m_full_unwind_plan_sp = original_full_unwind_plan_sp;
1831 m_cfa = old_cfa;
1832 m_afa = old_afa;
1833 return false;
1834 }
1835
1836 if (old_caller_pc_value == new_caller_pc_value &&
1837 m_cfa == old_cfa &&
1838 m_afa == old_afa) {
1839 UnwindLogMsg(fmt: "fallback unwind plan got the same values for this frame "
1840 "CFA and caller frame pc, not using");
1841 m_fallback_unwind_plan_sp.reset();
1842 m_full_unwind_plan_sp = original_full_unwind_plan_sp;
1843 return false;
1844 }
1845
1846 UnwindLogMsg(fmt: "trying to unwind from this function with the UnwindPlan '%s' "
1847 "because UnwindPlan '%s' failed.",
1848 m_fallback_unwind_plan_sp->GetSourceName().GetCString(),
1849 original_full_unwind_plan_sp->GetSourceName().GetCString());
1850
1851 // We've copied the fallback unwind plan into the full - now clear the
1852 // fallback.
1853 m_fallback_unwind_plan_sp.reset();
1854 PropagateTrapHandlerFlagFromUnwindPlan(unwind_plan: m_full_unwind_plan_sp);
1855 }
1856
1857 return true;
1858}
1859
1860bool RegisterContextUnwind::ForceSwitchToFallbackUnwindPlan() {
1861 if (m_fallback_unwind_plan_sp.get() == nullptr)
1862 return false;
1863
1864 if (m_full_unwind_plan_sp.get() == nullptr)
1865 return false;
1866
1867 if (m_full_unwind_plan_sp.get() == m_fallback_unwind_plan_sp.get() ||
1868 m_full_unwind_plan_sp->GetSourceName() ==
1869 m_fallback_unwind_plan_sp->GetSourceName()) {
1870 return false;
1871 }
1872
1873 UnwindPlan::RowSP active_row =
1874 m_fallback_unwind_plan_sp->GetRowForFunctionOffset(offset: m_current_offset);
1875
1876 if (active_row &&
1877 active_row->GetCFAValue().GetValueType() !=
1878 UnwindPlan::Row::FAValue::unspecified) {
1879 addr_t new_cfa;
1880 if (!ReadFrameAddress(register_kind: m_fallback_unwind_plan_sp->GetRegisterKind(),
1881 fa&: active_row->GetCFAValue(), address&: new_cfa) ||
1882 new_cfa == 0 || new_cfa == 1 || new_cfa == LLDB_INVALID_ADDRESS) {
1883 UnwindLogMsg(fmt: "failed to get cfa with fallback unwindplan");
1884 m_fallback_unwind_plan_sp.reset();
1885 return false;
1886 }
1887
1888 ReadFrameAddress(register_kind: m_fallback_unwind_plan_sp->GetRegisterKind(),
1889 fa&: active_row->GetAFAValue(), address&: m_afa);
1890
1891 m_full_unwind_plan_sp = m_fallback_unwind_plan_sp;
1892 m_fallback_unwind_plan_sp.reset();
1893
1894 m_registers.clear();
1895
1896 m_cfa = new_cfa;
1897
1898 PropagateTrapHandlerFlagFromUnwindPlan(unwind_plan: m_full_unwind_plan_sp);
1899
1900 UnwindLogMsg(fmt: "switched unconditionally to the fallback unwindplan %s",
1901 m_full_unwind_plan_sp->GetSourceName().GetCString());
1902 return true;
1903 }
1904 return false;
1905}
1906
1907void RegisterContextUnwind::PropagateTrapHandlerFlagFromUnwindPlan(
1908 lldb::UnwindPlanSP unwind_plan) {
1909 if (unwind_plan->GetUnwindPlanForSignalTrap() != eLazyBoolYes) {
1910 // Unwind plan does not indicate trap handler. Do nothing. We may
1911 // already be flagged as trap handler flag due to the symbol being
1912 // in the trap handler symbol list, and that should take precedence.
1913 return;
1914 } else if (m_frame_type != eNormalFrame) {
1915 // If this is already a trap handler frame, nothing to do.
1916 // If this is a skip or debug or invalid frame, don't override that.
1917 return;
1918 }
1919
1920 m_frame_type = eTrapHandlerFrame;
1921
1922 if (m_current_offset_backed_up_one != m_current_offset) {
1923 // We backed up the pc by 1 to compute the symbol context, but
1924 // now need to undo that because the pc of the trap handler
1925 // frame may in fact be the first instruction of a signal return
1926 // trampoline, rather than the instruction after a call. This
1927 // happens on systems where the signal handler dispatch code, rather
1928 // than calling the handler and being returned to, jumps to the
1929 // handler after pushing the address of a return trampoline on the
1930 // stack -- on these systems, when the handler returns, control will
1931 // be transferred to the return trampoline, so that's the best
1932 // symbol we can present in the callstack.
1933 UnwindLogMsg(fmt: "Resetting current offset and re-doing symbol lookup; "
1934 "old symbol was %s",
1935 GetSymbolOrFunctionName(sym_ctx: m_sym_ctx).AsCString(value_if_empty: ""));
1936 m_current_offset_backed_up_one = m_current_offset;
1937
1938 AddressRange addr_range;
1939 m_sym_ctx_valid = m_current_pc.ResolveFunctionScope(sym_ctx&: m_sym_ctx, addr_range_ptr: &addr_range);
1940
1941 UnwindLogMsg(fmt: "Symbol is now %s",
1942 GetSymbolOrFunctionName(sym_ctx: m_sym_ctx).AsCString(value_if_empty: ""));
1943
1944 ExecutionContext exe_ctx(m_thread.shared_from_this());
1945 Process *process = exe_ctx.GetProcessPtr();
1946 Target *target = &process->GetTarget();
1947
1948 m_start_pc = addr_range.GetBaseAddress();
1949 m_current_offset =
1950 m_current_pc.GetLoadAddress(target) - m_start_pc.GetLoadAddress(target);
1951 }
1952}
1953
1954bool RegisterContextUnwind::ReadFrameAddress(
1955 lldb::RegisterKind row_register_kind, UnwindPlan::Row::FAValue &fa,
1956 addr_t &address) {
1957 RegisterValue reg_value;
1958
1959 address = LLDB_INVALID_ADDRESS;
1960 addr_t cfa_reg_contents;
1961 ABISP abi_sp = m_thread.GetProcess()->GetABI();
1962
1963 switch (fa.GetValueType()) {
1964 case UnwindPlan::Row::FAValue::isRegisterDereferenced: {
1965 RegisterNumber cfa_reg(m_thread, row_register_kind,
1966 fa.GetRegisterNumber());
1967 if (ReadGPRValue(reg_num: cfa_reg, value&: cfa_reg_contents)) {
1968 const RegisterInfo *reg_info =
1969 GetRegisterInfoAtIndex(reg: cfa_reg.GetAsKind(kind: eRegisterKindLLDB));
1970 RegisterValue reg_value;
1971 if (reg_info) {
1972 if (abi_sp)
1973 cfa_reg_contents = abi_sp->FixDataAddress(pc: cfa_reg_contents);
1974 Status error = ReadRegisterValueFromMemory(
1975 reg_info, src_addr: cfa_reg_contents, src_len: reg_info->byte_size, reg_value);
1976 if (error.Success()) {
1977 address = reg_value.GetAsUInt64();
1978 if (abi_sp)
1979 address = abi_sp->FixCodeAddress(pc: address);
1980 UnwindLogMsg(
1981 fmt: "CFA value via dereferencing reg %s (%d): reg has val 0x%" PRIx64
1982 ", CFA value is 0x%" PRIx64,
1983 cfa_reg.GetName(), cfa_reg.GetAsKind(kind: eRegisterKindLLDB),
1984 cfa_reg_contents, address);
1985 return true;
1986 } else {
1987 UnwindLogMsg(fmt: "Tried to deref reg %s (%d) [0x%" PRIx64
1988 "] but memory read failed.",
1989 cfa_reg.GetName(), cfa_reg.GetAsKind(kind: eRegisterKindLLDB),
1990 cfa_reg_contents);
1991 }
1992 }
1993 }
1994 break;
1995 }
1996 case UnwindPlan::Row::FAValue::isRegisterPlusOffset: {
1997 RegisterNumber cfa_reg(m_thread, row_register_kind,
1998 fa.GetRegisterNumber());
1999 if (ReadGPRValue(reg_num: cfa_reg, value&: cfa_reg_contents)) {
2000 if (abi_sp)
2001 cfa_reg_contents = abi_sp->FixDataAddress(pc: cfa_reg_contents);
2002 if (cfa_reg_contents == LLDB_INVALID_ADDRESS || cfa_reg_contents == 0 ||
2003 cfa_reg_contents == 1) {
2004 UnwindLogMsg(
2005 fmt: "Got an invalid CFA register value - reg %s (%d), value 0x%" PRIx64,
2006 cfa_reg.GetName(), cfa_reg.GetAsKind(kind: eRegisterKindLLDB),
2007 cfa_reg_contents);
2008 cfa_reg_contents = LLDB_INVALID_ADDRESS;
2009 return false;
2010 }
2011 address = cfa_reg_contents + fa.GetOffset();
2012 UnwindLogMsg(
2013 fmt: "CFA is 0x%" PRIx64 ": Register %s (%d) contents are 0x%" PRIx64
2014 ", offset is %d",
2015 address, cfa_reg.GetName(), cfa_reg.GetAsKind(kind: eRegisterKindLLDB),
2016 cfa_reg_contents, fa.GetOffset());
2017 return true;
2018 }
2019 break;
2020 }
2021 case UnwindPlan::Row::FAValue::isDWARFExpression: {
2022 ExecutionContext exe_ctx(m_thread.shared_from_this());
2023 Process *process = exe_ctx.GetProcessPtr();
2024 DataExtractor dwarfdata(fa.GetDWARFExpressionBytes(),
2025 fa.GetDWARFExpressionLength(),
2026 process->GetByteOrder(),
2027 process->GetAddressByteSize());
2028 ModuleSP opcode_ctx;
2029 DWARFExpressionList dwarfexpr(opcode_ctx, dwarfdata, nullptr);
2030 dwarfexpr.GetMutableExpressionAtAddress()->SetRegisterKind(
2031 row_register_kind);
2032 Value result;
2033 Status error;
2034 if (dwarfexpr.Evaluate(exe_ctx: &exe_ctx, reg_ctx: this, func_load_addr: 0, initial_value_ptr: nullptr, object_address_ptr: nullptr, result,
2035 error_ptr: &error)) {
2036 address = result.GetScalar().ULongLong();
2037 if (ABISP abi_sp = m_thread.GetProcess()->GetABI())
2038 address = abi_sp->FixCodeAddress(pc: address);
2039
2040 UnwindLogMsg(fmt: "CFA value set by DWARF expression is 0x%" PRIx64,
2041 address);
2042 return true;
2043 }
2044 UnwindLogMsg(fmt: "Failed to set CFA value via DWARF expression: %s",
2045 error.AsCString());
2046 break;
2047 }
2048 case UnwindPlan::Row::FAValue::isRaSearch: {
2049 Process &process = *m_thread.GetProcess();
2050 lldb::addr_t return_address_hint = GetReturnAddressHint(plan_offset: fa.GetOffset());
2051 if (return_address_hint == LLDB_INVALID_ADDRESS)
2052 return false;
2053 const unsigned max_iterations = 256;
2054 for (unsigned i = 0; i < max_iterations; ++i) {
2055 Status st;
2056 lldb::addr_t candidate_addr =
2057 return_address_hint + i * process.GetAddressByteSize();
2058 lldb::addr_t candidate =
2059 process.ReadPointerFromMemory(vm_addr: candidate_addr, error&: st);
2060 if (st.Fail()) {
2061 UnwindLogMsg(fmt: "Cannot read memory at 0x%" PRIx64 ": %s", candidate_addr,
2062 st.AsCString());
2063 return false;
2064 }
2065 Address addr;
2066 uint32_t permissions;
2067 if (process.GetLoadAddressPermissions(load_addr: candidate, permissions) &&
2068 permissions & lldb::ePermissionsExecutable) {
2069 address = candidate_addr;
2070 UnwindLogMsg(fmt: "Heuristically found CFA: 0x%" PRIx64, address);
2071 return true;
2072 }
2073 }
2074 UnwindLogMsg(fmt: "No suitable CFA found");
2075 break;
2076 }
2077 default:
2078 return false;
2079 }
2080 return false;
2081}
2082
2083lldb::addr_t RegisterContextUnwind::GetReturnAddressHint(int32_t plan_offset) {
2084 addr_t hint;
2085 if (!ReadGPRValue(register_kind: eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP, value&: hint))
2086 return LLDB_INVALID_ADDRESS;
2087 if (!m_sym_ctx.module_sp || !m_sym_ctx.symbol)
2088 return LLDB_INVALID_ADDRESS;
2089 if (ABISP abi_sp = m_thread.GetProcess()->GetABI())
2090 hint = abi_sp->FixCodeAddress(pc: hint);
2091
2092 hint += plan_offset;
2093
2094 if (auto next = GetNextFrame()) {
2095 if (!next->m_sym_ctx.module_sp || !next->m_sym_ctx.symbol)
2096 return LLDB_INVALID_ADDRESS;
2097 if (auto expected_size =
2098 next->m_sym_ctx.module_sp->GetSymbolFile()->GetParameterStackSize(
2099 symbol&: *next->m_sym_ctx.symbol))
2100 hint += *expected_size;
2101 else {
2102 UnwindLogMsgVerbose(fmt: "Could not retrieve parameter size: %s",
2103 llvm::toString(E: expected_size.takeError()).c_str());
2104 return LLDB_INVALID_ADDRESS;
2105 }
2106 }
2107 return hint;
2108}
2109
2110// Retrieve a general purpose register value for THIS frame, as saved by the
2111// NEXT frame, i.e. the frame that
2112// this frame called. e.g.
2113//
2114// foo () { }
2115// bar () { foo (); }
2116// main () { bar (); }
2117//
2118// stopped in foo() so
2119// frame 0 - foo
2120// frame 1 - bar
2121// frame 2 - main
2122// and this RegisterContext is for frame 1 (bar) - if we want to get the pc
2123// value for frame 1, we need to ask
2124// where frame 0 (the "next" frame) saved that and retrieve the value.
2125
2126bool RegisterContextUnwind::ReadGPRValue(lldb::RegisterKind register_kind,
2127 uint32_t regnum, addr_t &value) {
2128 if (!IsValid())
2129 return false;
2130
2131 uint32_t lldb_regnum;
2132 if (register_kind == eRegisterKindLLDB) {
2133 lldb_regnum = regnum;
2134 } else if (!m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds(
2135 source_rk: register_kind, source_regnum: regnum, target_rk: eRegisterKindLLDB, target_regnum&: lldb_regnum)) {
2136 return false;
2137 }
2138
2139 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg: lldb_regnum);
2140 assert(reg_info);
2141 if (!reg_info) {
2142 UnwindLogMsg(
2143 fmt: "Could not find RegisterInfo definition for lldb register number %d",
2144 lldb_regnum);
2145 return false;
2146 }
2147
2148 uint32_t generic_regnum = LLDB_INVALID_REGNUM;
2149 if (register_kind == eRegisterKindGeneric)
2150 generic_regnum = regnum;
2151 else
2152 m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds(
2153 source_rk: register_kind, source_regnum: regnum, target_rk: eRegisterKindGeneric, target_regnum&: generic_regnum);
2154 ABISP abi_sp = m_thread.GetProcess()->GetABI();
2155
2156 RegisterValue reg_value;
2157 // if this is frame 0 (currently executing frame), get the requested reg
2158 // contents from the actual thread registers
2159 if (IsFrameZero()) {
2160 if (m_thread.GetRegisterContext()->ReadRegister(reg_info, reg_value)) {
2161 value = reg_value.GetAsUInt64();
2162 if (abi_sp && generic_regnum != LLDB_INVALID_REGNUM) {
2163 if (generic_regnum == LLDB_REGNUM_GENERIC_PC ||
2164 generic_regnum == LLDB_REGNUM_GENERIC_RA)
2165 value = abi_sp->FixCodeAddress(pc: value);
2166 if (generic_regnum == LLDB_REGNUM_GENERIC_SP ||
2167 generic_regnum == LLDB_REGNUM_GENERIC_FP)
2168 value = abi_sp->FixDataAddress(pc: value);
2169 }
2170 return true;
2171 }
2172 return false;
2173 }
2174
2175 bool pc_register = false;
2176 if (generic_regnum != LLDB_INVALID_REGNUM &&
2177 (generic_regnum == LLDB_REGNUM_GENERIC_PC ||
2178 generic_regnum == LLDB_REGNUM_GENERIC_RA))
2179 pc_register = true;
2180
2181 lldb_private::UnwindLLDB::RegisterLocation regloc;
2182 if (!m_parent_unwind.SearchForSavedLocationForRegister(
2183 lldb_regnum, regloc, starting_frame_num: m_frame_number - 1, pc_register)) {
2184 return false;
2185 }
2186 if (ReadRegisterValueFromRegisterLocation(regloc, reg_info, value&: reg_value)) {
2187 value = reg_value.GetAsUInt64();
2188 if (pc_register) {
2189 if (ABISP abi_sp = m_thread.GetProcess()->GetABI()) {
2190 value = abi_sp->FixCodeAddress(pc: value);
2191 }
2192 }
2193 return true;
2194 }
2195 return false;
2196}
2197
2198bool RegisterContextUnwind::ReadGPRValue(const RegisterNumber &regnum,
2199 addr_t &value) {
2200 return ReadGPRValue(register_kind: regnum.GetRegisterKind(), regnum: regnum.GetRegisterNumber(),
2201 value);
2202}
2203
2204// Find the value of a register in THIS frame
2205
2206bool RegisterContextUnwind::ReadRegister(const RegisterInfo *reg_info,
2207 RegisterValue &value) {
2208 if (!IsValid())
2209 return false;
2210
2211 const uint32_t lldb_regnum = reg_info->kinds[eRegisterKindLLDB];
2212 UnwindLogMsgVerbose(fmt: "looking for register saved location for reg %d",
2213 lldb_regnum);
2214
2215 // If this is the 0th frame, hand this over to the live register context
2216 if (IsFrameZero()) {
2217 UnwindLogMsgVerbose(fmt: "passing along to the live register context for reg %d",
2218 lldb_regnum);
2219 return m_thread.GetRegisterContext()->ReadRegister(reg_info, reg_value&: value);
2220 }
2221
2222 bool is_pc_regnum = false;
2223 if (reg_info->kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_PC ||
2224 reg_info->kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_RA) {
2225 is_pc_regnum = true;
2226 }
2227
2228 lldb_private::UnwindLLDB::RegisterLocation regloc;
2229 // Find out where the NEXT frame saved THIS frame's register contents
2230 if (!m_parent_unwind.SearchForSavedLocationForRegister(
2231 lldb_regnum, regloc, starting_frame_num: m_frame_number - 1, pc_register: is_pc_regnum))
2232 return false;
2233
2234 bool result = ReadRegisterValueFromRegisterLocation(regloc, reg_info, value);
2235 if (result) {
2236 if (is_pc_regnum && value.GetType() == RegisterValue::eTypeUInt64) {
2237 addr_t reg_value = value.GetAsUInt64(LLDB_INVALID_ADDRESS);
2238 if (reg_value != LLDB_INVALID_ADDRESS) {
2239 if (ABISP abi_sp = m_thread.GetProcess()->GetABI())
2240 value = abi_sp->FixCodeAddress(pc: reg_value);
2241 }
2242 }
2243 }
2244 return result;
2245}
2246
2247bool RegisterContextUnwind::WriteRegister(const RegisterInfo *reg_info,
2248 const RegisterValue &value) {
2249 if (!IsValid())
2250 return false;
2251
2252 const uint32_t lldb_regnum = reg_info->kinds[eRegisterKindLLDB];
2253 UnwindLogMsgVerbose(fmt: "looking for register saved location for reg %d",
2254 lldb_regnum);
2255
2256 // If this is the 0th frame, hand this over to the live register context
2257 if (IsFrameZero()) {
2258 UnwindLogMsgVerbose(fmt: "passing along to the live register context for reg %d",
2259 lldb_regnum);
2260 return m_thread.GetRegisterContext()->WriteRegister(reg_info, reg_value: value);
2261 }
2262
2263 lldb_private::UnwindLLDB::RegisterLocation regloc;
2264 // Find out where the NEXT frame saved THIS frame's register contents
2265 if (!m_parent_unwind.SearchForSavedLocationForRegister(
2266 lldb_regnum, regloc, starting_frame_num: m_frame_number - 1, pc_register: false))
2267 return false;
2268
2269 return WriteRegisterValueToRegisterLocation(regloc, reg_info, value);
2270}
2271
2272// Don't need to implement this one
2273bool RegisterContextUnwind::ReadAllRegisterValues(
2274 lldb::WritableDataBufferSP &data_sp) {
2275 return false;
2276}
2277
2278// Don't need to implement this one
2279bool RegisterContextUnwind::WriteAllRegisterValues(
2280 const lldb::DataBufferSP &data_sp) {
2281 return false;
2282}
2283
2284// Retrieve the pc value for THIS from
2285
2286bool RegisterContextUnwind::GetCFA(addr_t &cfa) {
2287 if (!IsValid()) {
2288 return false;
2289 }
2290 if (m_cfa == LLDB_INVALID_ADDRESS) {
2291 return false;
2292 }
2293 cfa = m_cfa;
2294 return true;
2295}
2296
2297RegisterContextUnwind::SharedPtr RegisterContextUnwind::GetNextFrame() const {
2298 RegisterContextUnwind::SharedPtr regctx;
2299 if (m_frame_number == 0)
2300 return regctx;
2301 return m_parent_unwind.GetRegisterContextForFrameNum(frame_num: m_frame_number - 1);
2302}
2303
2304RegisterContextUnwind::SharedPtr RegisterContextUnwind::GetPrevFrame() const {
2305 RegisterContextUnwind::SharedPtr regctx;
2306 return m_parent_unwind.GetRegisterContextForFrameNum(frame_num: m_frame_number + 1);
2307}
2308
2309// Retrieve the address of the start of the function of THIS frame
2310
2311bool RegisterContextUnwind::GetStartPC(addr_t &start_pc) {
2312 if (!IsValid())
2313 return false;
2314
2315 if (!m_start_pc.IsValid()) {
2316 bool read_successfully = ReadPC (start_pc);
2317 if (read_successfully)
2318 {
2319 ProcessSP process_sp (m_thread.GetProcess());
2320 if (process_sp)
2321 {
2322 if (ABISP abi_sp = process_sp->GetABI())
2323 start_pc = abi_sp->FixCodeAddress(pc: start_pc);
2324 }
2325 }
2326 return read_successfully;
2327 }
2328 start_pc = m_start_pc.GetLoadAddress(target: CalculateTarget().get());
2329 return true;
2330}
2331
2332// Retrieve the current pc value for THIS frame, as saved by the NEXT frame.
2333
2334bool RegisterContextUnwind::ReadPC(addr_t &pc) {
2335 if (!IsValid())
2336 return false;
2337
2338 bool above_trap_handler = false;
2339 if (GetNextFrame().get() && GetNextFrame()->IsValid() &&
2340 GetNextFrame()->IsTrapHandlerFrame())
2341 above_trap_handler = true;
2342
2343 if (ReadGPRValue(register_kind: eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, value&: pc)) {
2344 // A pc value of 0 or 1 is impossible in the middle of the stack -- it
2345 // indicates the end of a stack walk.
2346 // On the currently executing frame (or such a frame interrupted
2347 // asynchronously by sigtramp et al) this may occur if code has jumped
2348 // through a NULL pointer -- we want to be able to unwind past that frame
2349 // to help find the bug.
2350
2351 if (ABISP abi_sp = m_thread.GetProcess()->GetABI())
2352 pc = abi_sp->FixCodeAddress(pc);
2353
2354 return !(m_all_registers_available == false &&
2355 above_trap_handler == false && (pc == 0 || pc == 1));
2356 } else {
2357 return false;
2358 }
2359}
2360
2361void RegisterContextUnwind::UnwindLogMsg(const char *fmt, ...) {
2362 Log *log = GetLog(mask: LLDBLog::Unwind);
2363 if (!log)
2364 return;
2365
2366 va_list args;
2367 va_start(args, fmt);
2368
2369 llvm::SmallString<0> logmsg;
2370 if (VASprintf(buf&: logmsg, fmt, args)) {
2371 LLDB_LOGF(log, "%*sth%d/fr%u %s",
2372 m_frame_number < 100 ? m_frame_number : 100, "",
2373 m_thread.GetIndexID(), m_frame_number, logmsg.c_str());
2374 }
2375 va_end(args);
2376}
2377
2378void RegisterContextUnwind::UnwindLogMsgVerbose(const char *fmt, ...) {
2379 Log *log = GetLog(mask: LLDBLog::Unwind);
2380 if (!log || !log->GetVerbose())
2381 return;
2382
2383 va_list args;
2384 va_start(args, fmt);
2385
2386 llvm::SmallString<0> logmsg;
2387 if (VASprintf(buf&: logmsg, fmt, args)) {
2388 LLDB_LOGF(log, "%*sth%d/fr%u %s",
2389 m_frame_number < 100 ? m_frame_number : 100, "",
2390 m_thread.GetIndexID(), m_frame_number, logmsg.c_str());
2391 }
2392 va_end(args);
2393}
2394

source code of lldb/source/Target/RegisterContextUnwind.cpp