LLDB mainline
RegisterContextUnwind.cpp
Go to the documentation of this file.
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
10#include "lldb/Core/Address.h"
12#include "lldb/Core/Module.h"
13#include "lldb/Core/Value.h"
21#include "lldb/Symbol/Symbol.h"
24#include "lldb/Target/ABI.h"
29#include "lldb/Target/Process.h"
32#include "lldb/Target/Target.h"
33#include "lldb/Target/Thread.h"
36#include "lldb/Utility/Log.h"
39#include "lldb/lldb-private.h"
40
41#include <cassert>
42#include <memory>
43
44using namespace lldb;
45using namespace lldb_private;
46
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
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(false);
70 m_sym_ctx_valid = false;
71
72 if (IsFrameZero()) {
74 } else {
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) {
83 }
84}
85
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(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(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
115 Log *log = GetLog(LLDBLog::Unwind);
116 ExecutionContext exe_ctx(m_thread.shared_from_this());
118
119 if (reg_ctx_sp.get() == nullptr) {
121 UnwindLogMsg("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) {
129 UnwindLogMsg("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(current_pc);
142
145 if (lang_runtime_plan_sp.get()) {
146 UnwindLogMsg("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(current_pc, &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("using architectural default unwind method");
159 }
160
161 AddressRange addr_range;
163
164 if (m_sym_ctx.symbol) {
165 UnwindLogMsg("with pc value of 0x%" PRIx64 ", symbol name is '%s'",
166 current_pc, GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
167 } else if (m_sym_ctx.function) {
168 UnwindLogMsg("with pc value of 0x%" PRIx64 ", function name is '%s'",
169 current_pc, GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
170 } else {
171 UnwindLogMsg("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)) {
178 } else {
179 // FIXME: Detect eDebuggerFrame here.
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();
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?
197 }
199 } else {
201 m_current_offset = -1;
203 }
204
205 // We've set m_frame_type and m_sym_ctx before these calls.
206
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(m_current_offset);
221 row_register_kind = lang_runtime_plan_sp->GetRegisterKind();
222 if (!ReadFrameAddress(row_register_kind, active_row->GetCFAValue(),
223 m_cfa)) {
224 UnwindLogMsg("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(active_row_strm, lang_runtime_plan_sp.get(), &m_thread,
231 UnwindLogMsg("async active row: %s", active_row_strm.GetData());
232 }
233 UnwindLogMsg("m_cfa = 0x%" PRIx64 " m_afa = 0x%" PRIx64, m_cfa, m_afa);
235 "initialized async frame current pc is 0x%" PRIx64
236 " cfa is 0x%" PRIx64 " afa is 0x%" PRIx64,
237 (uint64_t)m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr()),
238 (uint64_t)m_cfa, (uint64_t)m_afa);
239
240 return;
241 }
242 }
243
245 m_full_unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
246 active_row =
247 m_full_unwind_plan_sp->GetRowForFunctionOffset(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(active_row_strm, m_full_unwind_plan_sp.get(), &m_thread,
253 UnwindLogMsg("%s", active_row_strm.GetData());
254 }
255 }
256
257 if (!active_row.get()) {
258 UnwindLogMsg("could not find an unwindplan row for this frame's pc");
260 return;
261 }
262
263 if (!ReadFrameAddress(row_register_kind, active_row->GetCFAValue(), 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(
274 }
275
276 if (func_unwinders_sp.get() != nullptr)
277 call_site_unwind_plan = func_unwinders_sp->GetUnwindPlanAtCallSite(
278 process->GetTarget(), m_thread);
279
280 if (call_site_unwind_plan.get() != nullptr) {
281 m_fallback_unwind_plan_sp = call_site_unwind_plan;
283 cfa_status = true;
284 }
285 if (!cfa_status) {
286 UnwindLogMsg("could not read CFA value for first frame.");
288 return;
289 }
290 } else
291 ReadFrameAddress(row_register_kind, active_row->GetAFAValue(), m_afa);
292
295 "could not read CFA or AFA values for first frame, not valid.");
297 return;
298 }
299
300 UnwindLogMsg("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(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
312 Log *log = GetLog(LLDBLog::Unwind);
313 if (IsFrameZero()) {
315 UnwindLogMsg("non-zeroth frame tests positive for IsFrameZero -- that "
316 "shouldn't happen.");
317 return;
318 }
319
320 if (!GetNextFrame().get() || !GetNextFrame()->IsValid()) {
322 UnwindLogMsg("Could not get next frame, marking this frame as invalid.");
323 return;
324 }
327 UnwindLogMsg("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.
344 if (lang_runtime_plan_sp.get()) {
345 UnwindLogMsg("This is an async frame");
346 }
347
348 addr_t pc;
350 UnwindLogMsg("could not get pc value");
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("pc = 0x%" PRIx64, pc);
363 addr_t reg_val;
365 if (abi_sp)
366 reg_val = abi_sp->FixDataAddress(reg_val);
367 UnwindLogMsg("fp = 0x%" PRIx64, reg_val);
368 }
370 if (abi_sp)
371 reg_val = abi_sp->FixDataAddress(reg_val);
372 UnwindLogMsg("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() &&
381 above_trap_handler = true;
382
383 if (pc == 0 || pc == 0x1) {
384 if (!above_trap_handler) {
386 UnwindLogMsg("this frame has a pc of 0x0");
387 return;
388 }
389 }
390
391 const bool allow_section_end = true;
392 m_current_pc.SetLoadAddress(pc, &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("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(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() &&
417 UnwindLogMsg("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);
422 } else {
423 // anywhere other than the second frame, a non-executable pc means
424 // we're off in the weeds -- stop now.
426 UnwindLogMsg("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();
435 std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
436 abi_sp->CreateDefaultUnwindPlan(*m_full_unwind_plan_sp);
437 if (m_frame_type != eSkipFrame) // don't override eSkipFrame
438 {
440 }
442 m_current_offset = -1;
444 RegisterKind row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
445 UnwindPlan::RowSP row = m_full_unwind_plan_sp->GetRowForFunctionOffset(0);
446 if (row.get()) {
447 if (!ReadFrameAddress(row_register_kind, row->GetCFAValue(), m_cfa)) {
448 UnwindLogMsg("failed to get cfa value");
449 if (m_frame_type != eSkipFrame) // don't override eSkipFrame
450 {
452 }
453 return;
454 }
455
456 ReadFrameAddress(row_register_kind, row->GetAFAValue(), m_afa);
457
458 // A couple of sanity checks..
459 if (m_cfa == LLDB_INVALID_ADDRESS || m_cfa == 0 || m_cfa == 1) {
460 UnwindLogMsg("could not find a valid cfa address");
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(m_cfa, permissions) &&
468 (permissions & ePermissionsReadable) == 0) {
471 "the CFA points to a region of memory that is not readable");
472 return;
473 }
474 } else {
475 UnwindLogMsg("could not find a row for function offset zero");
477 return;
478 }
479
480 if (CheckIfLoopingStack()) {
482 if (CheckIfLoopingStack()) {
483 UnwindLogMsg("same CFA address as next frame, assuming the unwind is "
484 "looping - stopping");
486 return;
487 }
488 }
489
490 UnwindLogMsg("initialized frame cfa is 0x%" PRIx64 " afa is 0x%" PRIx64,
491 (uint64_t)m_cfa, (uint64_t)m_afa);
492 return;
493 }
495 UnwindLogMsg("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;
502
503 if (m_sym_ctx.symbol) {
504 UnwindLogMsg("with pc value of 0x%" PRIx64 ", symbol name is '%s'", pc,
505 GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
506 } else if (m_sym_ctx.function) {
507 UnwindLogMsg("with pc value of 0x%" PRIx64 ", function name is '%s'", pc,
508 GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
509 } else {
510 UnwindLogMsg("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;
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.
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("Backing up the pc value of 0x%" PRIx64
555 " by 1 and re-doing symbol lookup; old symbol was %s",
556 pc, GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
557 Address temporary_pc;
558 temporary_pc.SetLoadAddress(pc - 1, &process->GetTarget());
559 m_sym_ctx.Clear(false);
560 m_sym_ctx_valid = temporary_pc.ResolveFunctionScope(m_sym_ctx, &addr_range);
561
562 UnwindLogMsg("Symbol is now %s",
563 GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
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();
573 if (decr_pc_and_recompute_addr_range &&
576 if (m_sym_ctx_valid) {
577 m_current_pc.SetLoadAddress(pc - 1, &process->GetTarget());
578 }
579 }
580 } else {
582 m_current_offset = -1;
584 }
585
586 if (IsTrapHandlerSymbol(process, m_sym_ctx)) {
588 } else {
589 // FIXME: Detect eDebuggerFrame here.
590 if (m_frame_type != eSkipFrame) // don't override eSkipFrame
591 {
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(m_current_offset);
607 row_register_kind = lang_runtime_plan_sp->GetRegisterKind();
608 if (!ReadFrameAddress(row_register_kind, active_row->GetCFAValue(),
609 m_cfa)) {
610 UnwindLogMsg("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(active_row_strm, lang_runtime_plan_sp.get(), &m_thread,
617 UnwindLogMsg("async active row: %s", active_row_strm.GetData());
618 }
619 UnwindLogMsg("m_cfa = 0x%" PRIx64 " m_afa = 0x%" PRIx64, m_cfa, m_afa);
621 "initialized async frame current pc is 0x%" PRIx64
622 " cfa is 0x%" PRIx64 " afa is 0x%" PRIx64,
623 (uint64_t)m_current_pc.GetLoadAddress(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.
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
638 m_fast_unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
639 active_row =
640 m_fast_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
641 row_register_kind = m_fast_unwind_plan_sp->GetRegisterKind();
643 if (active_row.get() && log) {
644 StreamString active_row_strm;
645 active_row->Dump(active_row_strm, m_fast_unwind_plan_sp.get(), &m_thread,
647 UnwindLogMsg("Using fast unwind plan '%s'",
648 m_fast_unwind_plan_sp->GetSourceName().AsCString());
649 UnwindLogMsg("active row: %s", active_row_strm.GetData());
650 }
651 } else {
654 active_row = m_full_unwind_plan_sp->GetRowForFunctionOffset(
656 row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
658 if (active_row.get() && log) {
659 StreamString active_row_strm;
660 active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(),
661 &m_thread,
663 UnwindLogMsg("Using full unwind plan '%s'",
664 m_full_unwind_plan_sp->GetSourceName().AsCString());
665 UnwindLogMsg("active row: %s", active_row_strm.GetData());
666 }
667 }
668 }
669
670 if (!active_row.get()) {
672 UnwindLogMsg("could not find unwind row for this pc");
673 return;
674 }
675
676 if (!ReadFrameAddress(row_register_kind, active_row->GetCFAValue(), m_cfa)) {
677 UnwindLogMsg("failed to get cfa");
679 return;
680 }
681
682 ReadFrameAddress(row_register_kind, active_row->GetAFAValue(), m_afa);
683
684 UnwindLogMsg("m_cfa = 0x%" PRIx64 " m_afa = 0x%" PRIx64, m_cfa, m_afa);
685
686 if (CheckIfLoopingStack()) {
688 if (CheckIfLoopingStack()) {
689 UnwindLogMsg("same CFA address as next frame, assuming the unwind is "
690 "looping - stopping");
692 return;
693 }
694 }
695
696 UnwindLogMsg("initialized frame current pc is 0x%" PRIx64
697 " cfa is 0x%" PRIx64 " afa is 0x%" PRIx64,
698 (uint64_t)m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr()),
699 (uint64_t)m_cfa,
700 (uint64_t)m_afa);
701}
702
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
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(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
733
735 if (m_frame_number == 0)
736 return true;
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
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(
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.
773 return unwind_plan_sp;
774
775 unwind_plan_sp = func_unwinders_sp->GetUnwindPlanFastUnwind(
777 if (unwind_plan_sp) {
778 if (unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
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
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>(lldb::eRegisterKindGeneric);
806 abi->CreateDefaultUnwindPlan(*arch_default_unwind_plan_sp);
807 } else {
809 "unable to get architectural default UnwindPlan from ABI plugin");
810 }
811
815 // If this frame behaves like a 0th frame (currently executing or
816 // interrupted asynchronously), all registers can be retrieved.
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)) &&
831 uint32_t permissions;
832 addr_t current_pc_addr =
834 if (current_pc_addr == 0 ||
835 (process &&
836 process->GetLoadAddressPermissions(current_pc_addr, permissions) &&
837 (permissions & ePermissionsExecutable) == 0)) {
838 if (abi) {
839 unwind_plan_sp =
840 std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
841 abi->CreateFunctionEntryUnwindPlan(*unwind_plan_sp);
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) {
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(
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) {
870
871 if (!pc_module_sp || !pc_module_sp->GetObjectFile() ||
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>(lldb::eRegisterKindGeneric);
881 if (eh_frame->GetUnwindPlan(m_current_pc, *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>(lldb::eRegisterKindGeneric);
891 if (arm_exidx->GetUnwindPlan(exe_ctx.GetTargetRef(), m_current_pc,
892 *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>(lldb::eRegisterKindGeneric);
902 if (object_file_unwind->GetUnwindPlan(m_current_pc, *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 process->GetTarget().GetArchitecture().GetTriple(),
922
923 if (unwind_plan_sp)
924 return unwind_plan_sp;
925 }
926
927 unwind_plan_sp =
928 func_unwinders_sp->GetEHFrameUnwindPlan(process->GetTarget());
929 if (!unwind_plan_sp)
930 unwind_plan_sp =
931 func_unwinders_sp->GetObjectFileUnwindPlan(process->GetTarget());
932 if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(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() &&
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(process->GetTarget());
954 if (!unwind_plan_sp)
955 unwind_plan_sp =
956 func_unwinders_sp->GetObjectFileUnwindPlan(process->GetTarget());
957 if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
958 UnwindLogMsgVerbose("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 process->GetTarget(), m_thread);
970 if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(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(process->GetTarget(),
985 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("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 m_thread);
1009 if (unwind_plan_sp) {
1010 UnwindLogMsgVerbose("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 process->GetTarget(), m_thread);
1023 }
1024 if (IsUnwindPlanValidForCurrentPC(unwind_plan_sp)) {
1025 UnwindLogMsgVerbose("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 process->GetTarget(), 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(process->GetTarget(),
1052 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("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)
1074 "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
1079 "Unable to find any UnwindPlan for full unwind of this frame.");
1080
1081 return arch_default_unwind_plan_sp;
1082}
1083
1086}
1087
1089 return m_thread.GetRegisterContext()->GetRegisterCount();
1090}
1091
1093 return m_thread.GetRegisterContext()->GetRegisterInfoAtIndex(reg);
1094}
1095
1097 return m_thread.GetRegisterContext()->GetRegisterSetCount();
1098}
1099
1101 return m_thread.GetRegisterContext()->GetRegisterSet(reg_set);
1102}
1103
1105 lldb::RegisterKind kind, uint32_t num) {
1106 return m_thread.GetRegisterContext()->ConvertRegisterKindToRegisterNumber(
1107 kind, num);
1108}
1109
1112 const RegisterInfo *reg_info, RegisterValue &value) {
1113 if (!IsValid())
1114 return false;
1115 bool success = false;
1116
1117 switch (regloc.type) {
1119 const RegisterInfo *other_reg_info =
1121
1122 if (!other_reg_info)
1123 return false;
1124
1125 success =
1126 m_thread.GetRegisterContext()->ReadRegister(other_reg_info, value);
1127 } break;
1129 const RegisterInfo *other_reg_info =
1131
1132 if (!other_reg_info)
1133 return false;
1134
1135 if (IsFrameZero()) {
1136 success =
1137 m_thread.GetRegisterContext()->ReadRegister(other_reg_info, value);
1138 } else {
1139 success = GetNextFrame()->ReadRegister(other_reg_info, value);
1140 }
1141 } break;
1143 success =
1144 value.SetUInt(regloc.location.inferred_value, reg_info->byte_size);
1145 break;
1146
1148 break;
1150 llvm_unreachable("FIXME debugger inferior function call unwind");
1153 reg_info, regloc.location.target_memory_location, reg_info->byte_size,
1154 value));
1155 success = error.Success();
1156 } break;
1157 default:
1158 llvm_unreachable("Unknown ConcreteRegisterLocation type.");
1159 }
1160 return success;
1161}
1162
1165 const RegisterInfo *reg_info, const RegisterValue &value) {
1166 if (!IsValid())
1167 return false;
1168
1169 bool success = false;
1170
1171 switch (regloc.type) {
1173 const RegisterInfo *other_reg_info =
1175 success =
1176 m_thread.GetRegisterContext()->WriteRegister(other_reg_info, value);
1177 } break;
1179 const RegisterInfo *other_reg_info =
1181 if (IsFrameZero()) {
1182 success =
1183 m_thread.GetRegisterContext()->WriteRegister(other_reg_info, value);
1184 } else {
1185 success = GetNextFrame()->WriteRegister(other_reg_info, value);
1186 }
1187 } break;
1190 break;
1192 llvm_unreachable("FIXME debugger inferior function call unwind");
1195 reg_info, regloc.location.target_memory_location, reg_info->byte_size,
1196 value));
1197 success = error.Success();
1198 } break;
1199 default:
1200 llvm_unreachable("Unknown ConcreteRegisterLocation type.");
1201 }
1202 return success;
1203}
1204
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
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
1228 return m_frame_type == eSkipFrame;
1229}
1230
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(
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
1262 uint32_t lldb_regnum,
1264 RegisterNumber regnum(m_thread, eRegisterKindLLDB, lldb_regnum);
1265 Log *log = GetLog(LLDBLog::Unwind);
1266
1267 // Have we already found this register location?
1268 if (!m_registers.empty()) {
1269 std::map<uint32_t,
1271 iterator;
1272 iterator = m_registers.find(regnum.GetAsKind(eRegisterKindLLDB));
1273 if (iterator != m_registers.end()) {
1274 regloc = iterator->second;
1275 UnwindLogMsg("supplying caller's saved %s (%d)'s location, cached",
1276 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1278 }
1279 }
1280
1281 // Look through the available UnwindPlans for the register location.
1282
1284 bool have_unwindplan_regloc = false;
1285 RegisterKind unwindplan_registerkind = kNumRegisterKinds;
1286
1288 UnwindPlan::RowSP active_row =
1289 m_fast_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
1290 unwindplan_registerkind = m_fast_unwind_plan_sp->GetRegisterKind();
1291 if (regnum.GetAsKind(unwindplan_registerkind) == LLDB_INVALID_REGNUM) {
1292 UnwindLogMsg("could not convert lldb regnum %s (%d) into %d RegisterKind "
1293 "reg numbering scheme",
1294 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
1295 (int)unwindplan_registerkind);
1297 }
1298 // The architecture default unwind plan marks unknown registers as
1299 // Undefined so that we don't forward them up the stack when a
1300 // jitted stack frame may have overwritten them. But when the
1301 // arch default unwind plan is used as the Fast Unwind Plan, we
1302 // need to recognize this & switch over to the Full Unwind Plan
1303 // to see what unwind rule that (more knoweldgeable, probably)
1304 // UnwindPlan has. If the full UnwindPlan says the register
1305 // location is Undefined, then it really is.
1306 if (active_row->GetRegisterInfo(regnum.GetAsKind(unwindplan_registerkind),
1307 unwindplan_regloc) &&
1308 !unwindplan_regloc.IsUndefined()) {
1310 "supplying caller's saved %s (%d)'s location using FastUnwindPlan",
1311 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1312 have_unwindplan_regloc = true;
1313 }
1314 }
1315
1316 if (!have_unwindplan_regloc) {
1317 // m_full_unwind_plan_sp being NULL means that we haven't tried to find a
1318 // full UnwindPlan yet
1319 bool got_new_full_unwindplan = false;
1320 if (!m_full_unwind_plan_sp) {
1322 got_new_full_unwindplan = true;
1323 }
1324
1328
1329 UnwindPlan::RowSP active_row =
1330 m_full_unwind_plan_sp->GetRowForFunctionOffset(
1332 unwindplan_registerkind = m_full_unwind_plan_sp->GetRegisterKind();
1333
1334 if (got_new_full_unwindplan && active_row.get() && log) {
1335 StreamString active_row_strm;
1336 ExecutionContext exe_ctx(m_thread.shared_from_this());
1337 active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(),
1338 &m_thread,
1340 UnwindLogMsg("Using full unwind plan '%s'",
1341 m_full_unwind_plan_sp->GetSourceName().AsCString());
1342 UnwindLogMsg("active row: %s", active_row_strm.GetData());
1343 }
1344 RegisterNumber return_address_reg;
1345
1346 // If we're fetching the saved pc and this UnwindPlan defines a
1347 // ReturnAddress register (e.g. lr on arm), look for the return address
1348 // register number in the UnwindPlan's row.
1349 if (pc_regnum.IsValid() && pc_regnum == regnum &&
1350 m_full_unwind_plan_sp->GetReturnAddressRegister() !=
1352 // If this is a trap handler frame, we should have access to
1353 // the complete register context when the interrupt/async
1354 // signal was received, we should fetch the actual saved $pc
1355 // value instead of the Return Address register.
1356 // If $pc is not available, fall back to the RA reg.
1359 active_row->GetRegisterInfo
1360 (pc_regnum.GetAsKind (unwindplan_registerkind), scratch)) {
1361 UnwindLogMsg("Providing pc register instead of rewriting to "
1362 "RA reg because this is a trap handler and there is "
1363 "a location for the saved pc register value.");
1364 } else {
1365 return_address_reg.init(
1366 m_thread, m_full_unwind_plan_sp->GetRegisterKind(),
1367 m_full_unwind_plan_sp->GetReturnAddressRegister());
1368 regnum = return_address_reg;
1369 UnwindLogMsg("requested caller's saved PC but this UnwindPlan uses a "
1370 "RA reg; getting %s (%d) instead",
1371 return_address_reg.GetName(),
1372 return_address_reg.GetAsKind(eRegisterKindLLDB));
1373 }
1374 } else {
1375 if (regnum.GetAsKind(unwindplan_registerkind) == LLDB_INVALID_REGNUM) {
1376 if (unwindplan_registerkind == eRegisterKindGeneric) {
1377 UnwindLogMsg("could not convert lldb regnum %s (%d) into "
1378 "eRegisterKindGeneric reg numbering scheme",
1379 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1380 } else {
1381 UnwindLogMsg("could not convert lldb regnum %s (%d) into %d "
1382 "RegisterKind reg numbering scheme",
1383 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
1384 (int)unwindplan_registerkind);
1385 }
1387 }
1388 }
1389
1390 if (regnum.IsValid() &&
1391 active_row->GetRegisterInfo(regnum.GetAsKind(unwindplan_registerkind),
1392 unwindplan_regloc)) {
1393 have_unwindplan_regloc = true;
1395 "supplying caller's saved %s (%d)'s location using %s UnwindPlan",
1396 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
1397 m_full_unwind_plan_sp->GetSourceName().GetCString());
1398 }
1399
1400 // This is frame 0 and we're retrieving the PC and it's saved in a Return
1401 // Address register and it hasn't been saved anywhere yet -- that is,
1402 // it's still live in the actual register. Handle this specially.
1403
1404 if (!have_unwindplan_regloc && return_address_reg.IsValid() &&
1405 IsFrameZero()) {
1406 if (return_address_reg.GetAsKind(eRegisterKindLLDB) !=
1411 new_regloc.location.register_number =
1412 return_address_reg.GetAsKind(eRegisterKindLLDB);
1413 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = new_regloc;
1414 regloc = new_regloc;
1415 UnwindLogMsg("supplying caller's register %s (%d) from the live "
1416 "RegisterContext at frame 0, saved in %d",
1417 return_address_reg.GetName(),
1418 return_address_reg.GetAsKind(eRegisterKindLLDB),
1419 return_address_reg.GetAsKind(eRegisterKindLLDB));
1421 }
1422 }
1423
1424 // If this architecture stores the return address in a register (it
1425 // defines a Return Address register) and we're on a non-zero stack frame
1426 // and the Full UnwindPlan says that the pc is stored in the
1427 // RA registers (e.g. lr on arm), then we know that the full unwindplan is
1428 // not trustworthy -- this
1429 // is an impossible situation and the instruction emulation code has
1430 // likely been misled. If this stack frame meets those criteria, we need
1431 // to throw away the Full UnwindPlan that the instruction emulation came
1432 // up with and fall back to the architecture's Default UnwindPlan so the
1433 // stack walk can get past this point.
1434
1435 // Special note: If the Full UnwindPlan was generated from the compiler,
1436 // don't second-guess it when we're at a call site location.
1437
1438 // arch_default_ra_regnum is the return address register # in the Full
1439 // UnwindPlan register numbering
1440 RegisterNumber arch_default_ra_regnum(m_thread, eRegisterKindGeneric,
1442
1443 if (arch_default_ra_regnum.GetAsKind(unwindplan_registerkind) !=
1445 pc_regnum == regnum && unwindplan_regloc.IsInOtherRegister() &&
1446 unwindplan_regloc.GetRegisterNumber() ==
1447 arch_default_ra_regnum.GetAsKind(unwindplan_registerkind) &&
1448 m_full_unwind_plan_sp->GetSourcedFromCompiler() != eLazyBoolYes &&
1450 UnwindLogMsg("%s UnwindPlan tried to restore the pc from the link "
1451 "register but this is a non-zero frame",
1452 m_full_unwind_plan_sp->GetSourceName().GetCString());
1453
1454 // Throw away the full unwindplan; install the arch default unwindplan
1456 // Update for the possibly new unwind plan
1457 unwindplan_registerkind = m_full_unwind_plan_sp->GetRegisterKind();
1458 UnwindPlan::RowSP active_row =
1459 m_full_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
1460
1461 // Sanity check: Verify that we can fetch a pc value and CFA value
1462 // with this unwind plan
1463
1464 RegisterNumber arch_default_pc_reg(m_thread, eRegisterKindGeneric,
1466 bool can_fetch_pc_value = false;
1467 bool can_fetch_cfa = false;
1468 addr_t cfa_value;
1469 if (active_row) {
1470 if (arch_default_pc_reg.GetAsKind(unwindplan_registerkind) !=
1472 active_row->GetRegisterInfo(
1473 arch_default_pc_reg.GetAsKind(unwindplan_registerkind),
1474 unwindplan_regloc)) {
1475 can_fetch_pc_value = true;
1476 }
1477 if (ReadFrameAddress(unwindplan_registerkind,
1478 active_row->GetCFAValue(), cfa_value)) {
1479 can_fetch_cfa = true;
1480 }
1481 }
1482
1483 have_unwindplan_regloc = can_fetch_pc_value && can_fetch_cfa;
1484 } else {
1485 // We were unable to fall back to another unwind plan
1486 have_unwindplan_regloc = false;
1487 }
1488 }
1489 }
1490 }
1491
1492 ExecutionContext exe_ctx(m_thread.shared_from_this());
1493 Process *process = exe_ctx.GetProcessPtr();
1494 if (!have_unwindplan_regloc) {
1495 // If the UnwindPlan failed to give us an unwind location for this
1496 // register, we may be able to fall back to some ABI-defined default. For
1497 // example, some ABIs allow to determine the caller's SP via the CFA. Also,
1498 // the ABI may set volatile registers to the undefined state.
1499 ABI *abi = process ? process->GetABI().get() : nullptr;
1500 if (abi) {
1501 const RegisterInfo *reg_info =
1503 if (reg_info &&
1504 abi->GetFallbackRegisterLocation(reg_info, unwindplan_regloc)) {
1506 "supplying caller's saved %s (%d)'s location using ABI default",
1507 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1508 have_unwindplan_regloc = true;
1509 }
1510 }
1511 }
1512
1513 if (!have_unwindplan_regloc) {
1514 if (IsFrameZero()) {
1515 // This is frame 0 - we should return the actual live register context
1516 // value
1518 new_regloc.type =
1521 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = new_regloc;
1522 regloc = new_regloc;
1523 UnwindLogMsg("supplying caller's register %s (%d) from the live "
1524 "RegisterContext at frame 0",
1525 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1527 } else {
1528 std::string unwindplan_name;
1530 unwindplan_name += "via '";
1531 unwindplan_name += m_full_unwind_plan_sp->GetSourceName().AsCString();
1532 unwindplan_name += "'";
1533 }
1534 UnwindLogMsg("no save location for %s (%d) %s", regnum.GetName(),
1536 unwindplan_name.c_str());
1537 }
1539 }
1540
1541 // unwindplan_regloc has valid contents about where to retrieve the register
1542 if (unwindplan_regloc.IsUnspecified()) {
1545 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = new_regloc;
1546 UnwindLogMsg("save location for %s (%d) is unspecified, continue searching",
1547 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1549 }
1550
1551 if (unwindplan_regloc.IsUndefined()) {
1553 "did not supply reg location for %s (%d) because it is volatile",
1554 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1556 }
1557
1558 if (unwindplan_regloc.IsSame()) {
1562 UnwindLogMsg("register %s (%d) is marked as 'IsSame' - it is a pc or "
1563 "return address reg on a frame which does not have all "
1564 "registers available -- treat as if we have no information",
1565 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1567 } else {
1570 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1572 "supplying caller's register %s (%d), saved in register %s (%d)",
1573 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
1574 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1576 }
1577 }
1578
1579 if (unwindplan_regloc.IsCFAPlusOffset()) {
1580 int offset = unwindplan_regloc.GetOffset();
1582 regloc.location.inferred_value = m_cfa + offset;
1583 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1584 UnwindLogMsg("supplying caller's register %s (%d), value is CFA plus "
1585 "offset %d [value is 0x%" PRIx64 "]",
1586 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), offset,
1587 regloc.location.inferred_value);
1589 }
1590
1591 if (unwindplan_regloc.IsAtCFAPlusOffset()) {
1592 int offset = unwindplan_regloc.GetOffset();
1593 regloc.type =
1595 regloc.location.target_memory_location = m_cfa + offset;
1596 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1597 UnwindLogMsg("supplying caller's register %s (%d) from the stack, saved at "
1598 "CFA plus offset %d [saved at 0x%" PRIx64 "]",
1599 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), offset,
1602 }
1603
1604 if (unwindplan_regloc.IsAFAPlusOffset()) {
1607
1608 int offset = unwindplan_regloc.GetOffset();
1610 regloc.location.inferred_value = m_afa + offset;
1611 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1612 UnwindLogMsg("supplying caller's register %s (%d), value is AFA plus "
1613 "offset %d [value is 0x%" PRIx64 "]",
1614 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), offset,
1615 regloc.location.inferred_value);
1617 }
1618
1619 if (unwindplan_regloc.IsAtAFAPlusOffset()) {
1622
1623 int offset = unwindplan_regloc.GetOffset();
1624 regloc.type =
1626 regloc.location.target_memory_location = m_afa + offset;
1627 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1628 UnwindLogMsg("supplying caller's register %s (%d) from the stack, saved at "
1629 "AFA plus offset %d [saved at 0x%" PRIx64 "]",
1630 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), offset,
1633 }
1634
1635 if (unwindplan_regloc.IsInOtherRegister()) {
1636 uint32_t unwindplan_regnum = unwindplan_regloc.GetRegisterNumber();
1637 RegisterNumber row_regnum(m_thread, unwindplan_registerkind,
1638 unwindplan_regnum);
1639 if (row_regnum.GetAsKind(eRegisterKindLLDB) == LLDB_INVALID_REGNUM) {
1640 UnwindLogMsg("could not supply caller's %s (%d) location - was saved in "
1641 "another reg but couldn't convert that regnum",
1642 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1644 }
1647 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1649 "supplying caller's register %s (%d), saved in register %s (%d)",
1650 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
1651 row_regnum.GetName(), row_regnum.GetAsKind(eRegisterKindLLDB));
1653 }
1654
1655 if (unwindplan_regloc.IsDWARFExpression() ||
1656 unwindplan_regloc.IsAtDWARFExpression()) {
1657 DataExtractor dwarfdata(unwindplan_regloc.GetDWARFExpressionBytes(),
1658 unwindplan_regloc.GetDWARFExpressionLength(),
1659 process->GetByteOrder(),
1660 process->GetAddressByteSize());
1661 ModuleSP opcode_ctx;
1662 DWARFExpressionList dwarfexpr(opcode_ctx, dwarfdata, nullptr);
1664 unwindplan_registerkind);
1665 Value cfa_val = Scalar(m_cfa);
1667 llvm::Expected<Value> result =
1668 dwarfexpr.Evaluate(&exe_ctx, this, 0, &cfa_val, nullptr);
1669 if (!result) {
1670 LLDB_LOG_ERROR(log, result.takeError(),
1671 "DWARF expression failed to evaluate: {0}");
1672 } else {
1673 addr_t val;
1674 val = result->GetScalar().ULongLong();
1675 if (unwindplan_regloc.IsDWARFExpression()) {
1676 regloc.type =
1678 regloc.location.inferred_value = val;
1679 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1680 UnwindLogMsg("supplying caller's register %s (%d) via DWARF expression "
1681 "(IsDWARFExpression)",
1682 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1684 } else {
1687 regloc.location.target_memory_location = val;
1688 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1689 UnwindLogMsg("supplying caller's register %s (%d) via DWARF expression "
1690 "(IsAtDWARFExpression)",
1691 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1693 }
1694 }
1695 UnwindLogMsg("tried to use IsDWARFExpression or IsAtDWARFExpression for %s "
1696 "(%d) but failed",
1697 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1699 }
1700
1701 if (unwindplan_regloc.IsConstant()) {
1703 regloc.location.inferred_value = unwindplan_regloc.GetConstant();
1704 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1705 UnwindLogMsg("supplying caller's register %s (%d) via constant value",
1706 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1708 }
1709
1710 UnwindLogMsg("no save location for %s (%d) in this stack frame",
1711 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1712
1713 // FIXME UnwindPlan::Row types atDWARFExpression and isDWARFExpression are
1714 // unsupported.
1715
1717}
1718
1719// TryFallbackUnwindPlan() -- this method is a little tricky.
1720//
1721// When this is called, the frame above -- the caller frame, the "previous"
1722// frame -- is invalid or bad.
1723//
1724// Instead of stopping the stack walk here, we'll try a different UnwindPlan
1725// and see if we can get a valid frame above us.
1726//
1727// This most often happens when an unwind plan based on assembly instruction
1728// inspection is not correct -- mostly with hand-written assembly functions or
1729// functions where the stack frame is set up "out of band", e.g. the kernel
1730// saved the register context and then called an asynchronous trap handler like
1731// _sigtramp.
1732//
1733// Often in these cases, if we just do a dumb stack walk we'll get past this
1734// tricky frame and our usual techniques can continue to be used.
1735
1737 if (m_fallback_unwind_plan_sp.get() == nullptr)
1738 return false;
1739
1740 if (m_full_unwind_plan_sp.get() == nullptr)
1741 return false;
1742
1744 m_full_unwind_plan_sp->GetSourceName() ==
1745 m_fallback_unwind_plan_sp->GetSourceName()) {
1746 return false;
1747 }
1748
1749 // If a compiler generated unwind plan failed, trying the arch default
1750 // unwindplan isn't going to do any better.
1751 if (m_full_unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolYes)
1752 return false;
1753
1754 // Get the caller's pc value and our own CFA value. Swap in the fallback
1755 // unwind plan, re-fetch the caller's pc value and CFA value. If they're the
1756 // same, then the fallback unwind plan provides no benefit.
1757
1760
1761 addr_t old_caller_pc_value = LLDB_INVALID_ADDRESS;
1762 addr_t new_caller_pc_value = LLDB_INVALID_ADDRESS;
1765 regloc) ==
1767 const RegisterInfo *reg_info =
1769 if (reg_info) {
1770 RegisterValue reg_value;
1771 if (ReadRegisterValueFromRegisterLocation(regloc, reg_info, reg_value)) {
1772 old_caller_pc_value = reg_value.GetAsUInt64();
1773 if (ProcessSP process_sp = m_thread.GetProcess()) {
1774 if (ABISP abi_sp = process_sp->GetABI())
1775 old_caller_pc_value = abi_sp->FixCodeAddress(old_caller_pc_value);
1776 }
1777 }
1778 }
1779 }
1780
1781 // This is a tricky wrinkle! If SavedLocationForRegister() detects a really
1782 // impossible register location for the full unwind plan, it may call
1783 // ForceSwitchToFallbackUnwindPlan() which in turn replaces the full
1784 // unwindplan with the fallback... in short, we're done, we're using the
1785 // fallback UnwindPlan. We checked if m_fallback_unwind_plan_sp was nullptr
1786 // at the top -- the only way it became nullptr since then is via
1787 // SavedLocationForRegister().
1788 if (m_fallback_unwind_plan_sp.get() == nullptr)
1789 return true;
1790
1791 // Switch the full UnwindPlan to be the fallback UnwindPlan. If we decide
1792 // this isn't working, we need to restore. We'll also need to save & restore
1793 // the value of the m_cfa ivar. Save is down below a bit in 'old_cfa'.
1794 UnwindPlanSP original_full_unwind_plan_sp = m_full_unwind_plan_sp;
1795 addr_t old_cfa = m_cfa;
1796 addr_t old_afa = m_afa;
1797
1798 m_registers.clear();
1799
1801
1802 UnwindPlan::RowSP active_row =
1803 m_fallback_unwind_plan_sp->GetRowForFunctionOffset(
1805
1806 if (active_row &&
1807 active_row->GetCFAValue().GetValueType() !=
1809 addr_t new_cfa;
1810 if (!ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(),
1811 active_row->GetCFAValue(), new_cfa) ||
1812 new_cfa == 0 || new_cfa == 1 || new_cfa == LLDB_INVALID_ADDRESS) {
1813 UnwindLogMsg("failed to get cfa with fallback unwindplan");
1815 m_full_unwind_plan_sp = original_full_unwind_plan_sp;
1816 return false;
1817 }
1818 m_cfa = new_cfa;
1819
1821 active_row->GetAFAValue(), m_afa);
1822
1824 regloc) ==
1826 const RegisterInfo *reg_info =
1828 if (reg_info) {
1829 RegisterValue reg_value;
1830 if (ReadRegisterValueFromRegisterLocation(regloc, reg_info,
1831 reg_value)) {
1832 new_caller_pc_value = reg_value.GetAsUInt64();
1833 if (ProcessSP process_sp = m_thread.GetProcess()) {
1834 if (ABISP abi_sp = process_sp->GetABI())
1835 new_caller_pc_value = abi_sp->FixCodeAddress(new_caller_pc_value);
1836 }
1837 }
1838 }
1839 }
1840
1841 if (new_caller_pc_value == LLDB_INVALID_ADDRESS) {
1842 UnwindLogMsg("failed to get a pc value for the caller frame with the "
1843 "fallback unwind plan");
1845 m_full_unwind_plan_sp = original_full_unwind_plan_sp;
1846 m_cfa = old_cfa;
1847 m_afa = old_afa;
1848 return false;
1849 }
1850
1851 if (old_caller_pc_value == new_caller_pc_value &&
1852 m_cfa == old_cfa &&
1853 m_afa == old_afa) {
1854 UnwindLogMsg("fallback unwind plan got the same values for this frame "
1855 "CFA and caller frame pc, not using");
1857 m_full_unwind_plan_sp = original_full_unwind_plan_sp;
1858 return false;
1859 }
1860
1861 UnwindLogMsg("trying to unwind from this function with the UnwindPlan '%s' "
1862 "because UnwindPlan '%s' failed.",
1863 m_fallback_unwind_plan_sp->GetSourceName().GetCString(),
1864 original_full_unwind_plan_sp->GetSourceName().GetCString());
1865
1866 // We've copied the fallback unwind plan into the full - now clear the
1867 // fallback.
1870 }
1871
1872 return true;
1873}
1874
1876 if (m_fallback_unwind_plan_sp.get() == nullptr)
1877 return false;
1878
1879 if (m_full_unwind_plan_sp.get() == nullptr)
1880 return false;
1881
1883 m_full_unwind_plan_sp->GetSourceName() ==
1884 m_fallback_unwind_plan_sp->GetSourceName()) {
1885 return false;
1886 }
1887
1888 UnwindPlan::RowSP active_row =
1889 m_fallback_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
1890
1891 if (active_row &&
1892 active_row->GetCFAValue().GetValueType() !=
1894 addr_t new_cfa;
1895 if (!ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(),
1896 active_row->GetCFAValue(), new_cfa) ||
1897 new_cfa == 0 || new_cfa == 1 || new_cfa == LLDB_INVALID_ADDRESS) {
1898 UnwindLogMsg("failed to get cfa with fallback unwindplan");
1900 return false;
1901 }
1902
1904 active_row->GetAFAValue(), m_afa);
1905
1908
1909 m_registers.clear();
1910
1911 m_cfa = new_cfa;
1912
1914
1915 UnwindLogMsg("switched unconditionally to the fallback unwindplan %s",
1916 m_full_unwind_plan_sp->GetSourceName().GetCString());
1917 return true;
1918 }
1919 return false;
1920}
1921
1923 lldb::UnwindPlanSP unwind_plan) {
1924 if (unwind_plan->GetUnwindPlanForSignalTrap() != eLazyBoolYes) {
1925 // Unwind plan does not indicate trap handler. Do nothing. We may
1926 // already be flagged as trap handler flag due to the symbol being
1927 // in the trap handler symbol list, and that should take precedence.
1928 return;
1929 } else if (m_frame_type != eNormalFrame) {
1930 // If this is already a trap handler frame, nothing to do.
1931 // If this is a skip or debug or invalid frame, don't override that.
1932 return;
1933 }
1934
1936
1938 // We backed up the pc by 1 to compute the symbol context, but
1939 // now need to undo that because the pc of the trap handler
1940 // frame may in fact be the first instruction of a signal return
1941 // trampoline, rather than the instruction after a call. This
1942 // happens on systems where the signal handler dispatch code, rather
1943 // than calling the handler and being returned to, jumps to the
1944 // handler after pushing the address of a return trampoline on the
1945 // stack -- on these systems, when the handler returns, control will
1946 // be transferred to the return trampoline, so that's the best
1947 // symbol we can present in the callstack.
1948 UnwindLogMsg("Resetting current offset and re-doing symbol lookup; "
1949 "old symbol was %s",
1950 GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
1952
1953 AddressRange addr_range;
1955
1956 UnwindLogMsg("Symbol is now %s",
1957 GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
1958
1959 ExecutionContext exe_ctx(m_thread.shared_from_this());
1960 Process *process = exe_ctx.GetProcessPtr();
1961 Target *target = &process->GetTarget();
1962
1963 m_start_pc = addr_range.GetBaseAddress();
1966 }
1967}
1968
1970 lldb::RegisterKind row_register_kind, UnwindPlan::Row::FAValue &fa,
1971 addr_t &address) {
1972 RegisterValue reg_value;
1973
1974 address = LLDB_INVALID_ADDRESS;
1975 addr_t cfa_reg_contents;
1976 ABISP abi_sp = m_thread.GetProcess()->GetABI();
1977
1978 switch (fa.GetValueType()) {
1980 RegisterNumber cfa_reg(m_thread, row_register_kind,
1981 fa.GetRegisterNumber());
1982 if (ReadGPRValue(cfa_reg, cfa_reg_contents)) {
1983 const RegisterInfo *reg_info =
1985 RegisterValue reg_value;
1986 if (reg_info) {
1987 if (abi_sp)
1988 cfa_reg_contents = abi_sp->FixDataAddress(cfa_reg_contents);
1990 reg_info, cfa_reg_contents, reg_info->byte_size, reg_value);
1991 if (error.Success()) {
1992 address = reg_value.GetAsUInt64();
1993 if (abi_sp)
1994 address = abi_sp->FixCodeAddress(address);
1996 "CFA value via dereferencing reg %s (%d): reg has val 0x%" PRIx64
1997 ", CFA value is 0x%" PRIx64,
1998 cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB),
1999 cfa_reg_contents, address);
2000 return true;
2001 } else {
2002 UnwindLogMsg("Tried to deref reg %s (%d) [0x%" PRIx64
2003 "] but memory read failed.",
2004 cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB),
2005 cfa_reg_contents);
2006 }
2007 }
2008 }
2009 break;
2010 }
2012 RegisterNumber cfa_reg(m_thread, row_register_kind,
2013 fa.GetRegisterNumber());
2014 if (ReadGPRValue(cfa_reg, cfa_reg_contents)) {
2015 if (abi_sp)
2016 cfa_reg_contents = abi_sp->FixDataAddress(cfa_reg_contents);
2017 if (cfa_reg_contents == LLDB_INVALID_ADDRESS || cfa_reg_contents == 0 ||
2018 cfa_reg_contents == 1) {
2020 "Got an invalid CFA register value - reg %s (%d), value 0x%" PRIx64,
2021 cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB),
2022 cfa_reg_contents);
2023 cfa_reg_contents = LLDB_INVALID_ADDRESS;
2024 return false;
2025 }
2026 address = cfa_reg_contents + fa.GetOffset();
2028 "CFA is 0x%" PRIx64 ": Register %s (%d) contents are 0x%" PRIx64
2029 ", offset is %d",
2030 address, cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB),
2031 cfa_reg_contents, fa.GetOffset());
2032 return true;
2033 }
2034 break;
2035 }
2037 ExecutionContext exe_ctx(m_thread.shared_from_this());
2038 Process *process = exe_ctx.GetProcessPtr();
2041 process->GetByteOrder(),
2042 process->GetAddressByteSize());
2043 ModuleSP opcode_ctx;
2044 DWARFExpressionList dwarfexpr(opcode_ctx, dwarfdata, nullptr);
2046 row_register_kind);
2047 llvm::Expected<Value> result =
2048 dwarfexpr.Evaluate(&exe_ctx, this, 0, nullptr, nullptr);
2049 if (result) {
2050 address = result->GetScalar().ULongLong();
2051 if (ABISP abi_sp = m_thread.GetProcess()->GetABI())
2052 address = abi_sp->FixCodeAddress(address);
2053
2054 UnwindLogMsg("CFA value set by DWARF expression is 0x%" PRIx64,
2055 address);
2056 return true;
2057 }
2058 UnwindLogMsg("Failed to set CFA value via DWARF expression: %s",
2059 llvm::toString(result.takeError()).c_str());
2060 break;
2061 }
2063 Process &process = *m_thread.GetProcess();
2064 lldb::addr_t return_address_hint = GetReturnAddressHint(fa.GetOffset());
2065 if (return_address_hint == LLDB_INVALID_ADDRESS)
2066 return false;
2067 const unsigned max_iterations = 256;
2068 for (unsigned i = 0; i < max_iterations; ++i) {
2069 Status st;
2070 lldb::addr_t candidate_addr =
2071 return_address_hint + i * process.GetAddressByteSize();
2072 lldb::addr_t candidate =
2073 process.ReadPointerFromMemory(candidate_addr, st);
2074 if (st.Fail()) {
2075 UnwindLogMsg("Cannot read memory at 0x%" PRIx64 ": %s", candidate_addr,
2076 st.AsCString());
2077 return false;
2078 }
2079 Address addr;
2080 uint32_t permissions;
2081 if (process.GetLoadAddressPermissions(candidate, permissions) &&
2082 permissions & lldb::ePermissionsExecutable) {
2083 address = candidate_addr;
2084 UnwindLogMsg("Heuristically found CFA: 0x%" PRIx64, address);
2085 return true;
2086 }
2087 }
2088 UnwindLogMsg("No suitable CFA found");
2089 break;
2090 }
2092 address = fa.GetConstant();
2093 address = m_thread.GetProcess()->FixDataAddress(address);
2094 UnwindLogMsg("CFA value set by constant is 0x%" PRIx64, address);
2095 return true;
2096 }
2097 default:
2098 return false;
2099 }
2100 return false;
2101}
2102
2104 addr_t hint;
2106 return LLDB_INVALID_ADDRESS;
2108 return LLDB_INVALID_ADDRESS;
2109 if (ABISP abi_sp = m_thread.GetProcess()->GetABI())
2110 hint = abi_sp->FixCodeAddress(hint);
2111
2112 hint += plan_offset;
2113
2114 if (auto next = GetNextFrame()) {
2115 if (!next->m_sym_ctx.module_sp || !next->m_sym_ctx.symbol)
2116 return LLDB_INVALID_ADDRESS;
2117 if (auto expected_size =
2118 next->m_sym_ctx.module_sp->GetSymbolFile()->GetParameterStackSize(
2119 *next->m_sym_ctx.symbol))
2120 hint += *expected_size;
2121 else {
2122 UnwindLogMsgVerbose("Could not retrieve parameter size: %s",
2123 llvm::toString(expected_size.takeError()).c_str());
2124 return LLDB_INVALID_ADDRESS;
2125 }
2126 }
2127 return hint;
2128}
2129
2130// Retrieve a general purpose register value for THIS frame, as saved by the
2131// NEXT frame, i.e. the frame that
2132// this frame called. e.g.
2133//
2134// foo () { }
2135// bar () { foo (); }
2136// main () { bar (); }
2137//
2138// stopped in foo() so
2139// frame 0 - foo
2140// frame 1 - bar
2141// frame 2 - main
2142// and this RegisterContext is for frame 1 (bar) - if we want to get the pc
2143// value for frame 1, we need to ask
2144// where frame 0 (the "next" frame) saved that and retrieve the value.
2145
2147 uint32_t regnum, addr_t &value) {
2148 if (!IsValid())
2149 return false;
2150
2151 uint32_t lldb_regnum;
2152 if (register_kind == eRegisterKindLLDB) {
2153 lldb_regnum = regnum;
2154 } else if (!m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds(
2155 register_kind, regnum, eRegisterKindLLDB, lldb_regnum)) {
2156 return false;
2157 }
2158
2159 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(lldb_regnum);
2160 assert(reg_info);
2161 if (!reg_info) {
2163 "Could not find RegisterInfo definition for lldb register number %d",
2164 lldb_regnum);
2165 return false;
2166 }
2167
2168 uint32_t generic_regnum = LLDB_INVALID_REGNUM;
2169 if (register_kind == eRegisterKindGeneric)
2170 generic_regnum = regnum;
2171 else
2172 m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds(
2173 register_kind, regnum, eRegisterKindGeneric, generic_regnum);
2174 ABISP abi_sp = m_thread.GetProcess()->GetABI();
2175
2176 RegisterValue reg_value;
2177 // if this is frame 0 (currently executing frame), get the requested reg
2178 // contents from the actual thread registers
2179 if (IsFrameZero()) {
2180 if (m_thread.GetRegisterContext()->ReadRegister(reg_info, reg_value)) {
2181 value = reg_value.GetAsUInt64();
2182 if (abi_sp && generic_regnum != LLDB_INVALID_REGNUM) {
2183 if (generic_regnum == LLDB_REGNUM_GENERIC_PC ||
2184 generic_regnum == LLDB_REGNUM_GENERIC_RA)
2185 value = abi_sp->FixCodeAddress(value);
2186 if (generic_regnum == LLDB_REGNUM_GENERIC_SP ||
2187 generic_regnum == LLDB_REGNUM_GENERIC_FP)
2188 value = abi_sp->FixDataAddress(value);
2189 }
2190 return true;
2191 }
2192 return false;
2193 }
2194
2195 bool pc_register = false;
2196 if (generic_regnum != LLDB_INVALID_REGNUM &&
2197 (generic_regnum == LLDB_REGNUM_GENERIC_PC ||
2198 generic_regnum == LLDB_REGNUM_GENERIC_RA))
2199 pc_register = true;
2200
2203 lldb_regnum, regloc, m_frame_number - 1, pc_register)) {
2204 return false;
2205 }
2206 if (ReadRegisterValueFromRegisterLocation(regloc, reg_info, reg_value)) {
2207 value = reg_value.GetAsUInt64();
2208 if (pc_register) {
2209 if (ABISP abi_sp = m_thread.GetProcess()->GetABI()) {
2210 value = abi_sp->FixCodeAddress(value);
2211 }
2212 }
2213 return true;
2214 }
2215 return false;
2216}
2217
2219 addr_t &value) {
2220 return ReadGPRValue(regnum.GetRegisterKind(), regnum.GetRegisterNumber(),
2221 value);
2222}
2223
2224// Find the value of a register in THIS frame
2225
2227 RegisterValue &value) {
2228 if (!IsValid())
2229 return false;
2230
2231 const uint32_t lldb_regnum = reg_info->kinds[eRegisterKindLLDB];
2232 UnwindLogMsgVerbose("looking for register saved location for reg %d",
2233 lldb_regnum);
2234
2235 // If this is the 0th frame, hand this over to the live register context
2236 if (IsFrameZero()) {
2237 UnwindLogMsgVerbose("passing along to the live register context for reg %d",
2238 lldb_regnum);
2239 return m_thread.GetRegisterContext()->ReadRegister(reg_info, value);
2240 }
2241
2242 bool is_pc_regnum = false;
2245 is_pc_regnum = true;
2246 }
2247
2249 // Find out where the NEXT frame saved THIS frame's register contents
2251 lldb_regnum, regloc, m_frame_number - 1, is_pc_regnum))
2252 return false;
2253
2254 bool result = ReadRegisterValueFromRegisterLocation(regloc, reg_info, value);
2255 if (result) {
2256 if (is_pc_regnum && value.GetType() == RegisterValue::eTypeUInt64) {
2257 addr_t reg_value = value.GetAsUInt64(LLDB_INVALID_ADDRESS);
2258 if (reg_value != LLDB_INVALID_ADDRESS) {
2259 if (ABISP abi_sp = m_thread.GetProcess()->GetABI())
2260 value = abi_sp->FixCodeAddress(reg_value);
2261 }
2262 }
2263 }
2264 return result;
2265}
2266
2268 const RegisterValue &value) {
2269 if (!IsValid())
2270 return false;
2271
2272 const uint32_t lldb_regnum = reg_info->kinds[eRegisterKindLLDB];
2273 UnwindLogMsgVerbose("looking for register saved location for reg %d",
2274 lldb_regnum);
2275
2276 // If this is the 0th frame, hand this over to the live register context
2277 if (IsFrameZero()) {
2278 UnwindLogMsgVerbose("passing along to the live register context for reg %d",
2279 lldb_regnum);
2280 return m_thread.GetRegisterContext()->WriteRegister(reg_info, value);
2281 }
2282
2284 // Find out where the NEXT frame saved THIS frame's register contents
2286 lldb_regnum, regloc, m_frame_number - 1, false))
2287 return false;
2288
2289 return WriteRegisterValueToRegisterLocation(regloc, reg_info, value);
2290}
2291
2292// Don't need to implement this one
2294 lldb::WritableDataBufferSP &data_sp) {
2295 return false;
2296}
2297
2298// Don't need to implement this one
2300 const lldb::DataBufferSP &data_sp) {
2301 return false;
2302}
2303
2304// Retrieve the pc value for THIS from
2305
2307 if (!IsValid()) {
2308 return false;
2309 }
2310 if (m_cfa == LLDB_INVALID_ADDRESS) {
2311 return false;
2312 }
2313 cfa = m_cfa;
2314 return true;
2315}
2316
2319 if (m_frame_number == 0)
2320 return regctx;
2322}
2323
2327}
2328
2329// Retrieve the address of the start of the function of THIS frame
2330
2332 if (!IsValid())
2333 return false;
2334
2335 if (!m_start_pc.IsValid()) {
2336 bool read_successfully = ReadPC (start_pc);
2337 if (read_successfully)
2338 {
2339 ProcessSP process_sp (m_thread.GetProcess());
2340 if (process_sp)
2341 {
2342 if (ABISP abi_sp = process_sp->GetABI())
2343 start_pc = abi_sp->FixCodeAddress(start_pc);
2344 }
2345 }
2346 return read_successfully;
2347 }
2348 start_pc = m_start_pc.GetLoadAddress(CalculateTarget().get());
2349 return true;
2350}
2351
2352// Retrieve the current pc value for THIS frame, as saved by the NEXT frame.
2353
2355 if (!IsValid())
2356 return false;
2357
2358 bool above_trap_handler = false;
2359 if (GetNextFrame().get() && GetNextFrame()->IsValid() &&
2361 above_trap_handler = true;
2362
2364 // A pc value of 0 or 1 is impossible in the middle of the stack -- it
2365 // indicates the end of a stack walk.
2366 // On the currently executing frame (or such a frame interrupted
2367 // asynchronously by sigtramp et al) this may occur if code has jumped
2368 // through a NULL pointer -- we want to be able to unwind past that frame
2369 // to help find the bug.
2370
2371 if (ABISP abi_sp = m_thread.GetProcess()->GetABI())
2372 pc = abi_sp->FixCodeAddress(pc);
2373
2374 return !(m_all_registers_available == false &&
2375 above_trap_handler == false && (pc == 0 || pc == 1));
2376 } else {
2377 return false;
2378 }
2379}
2380
2381void RegisterContextUnwind::UnwindLogMsg(const char *fmt, ...) {
2382 Log *log = GetLog(LLDBLog::Unwind);
2383 if (!log)
2384 return;
2385
2386 va_list args;
2387 va_start(args, fmt);
2388
2389 llvm::SmallString<0> logmsg;
2390 if (VASprintf(logmsg, fmt, args)) {
2391 LLDB_LOGF(log, "%*sth%d/fr%u %s",
2392 m_frame_number < 100 ? m_frame_number : 100, "",
2393 m_thread.GetIndexID(), m_frame_number, logmsg.c_str());
2394 }
2395 va_end(args);
2396}
2397
2399 Log *log = GetLog(LLDBLog::Unwind);
2400 if (!log || !log->GetVerbose())
2401 return;
2402
2403 va_list args;
2404 va_start(args, fmt);
2405
2406 llvm::SmallString<0> logmsg;
2407 if (VASprintf(logmsg, fmt, args)) {
2408 LLDB_LOGF(log, "%*sth%d/fr%u %s",
2409 m_frame_number < 100 ? m_frame_number : 100, "",
2410 m_thread.GetIndexID(), m_frame_number, logmsg.c_str());
2411 }
2412 va_end(args);
2413}
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_LOGF(log,...)
Definition: Log.h:376
#define LLDB_LOG_ERROR(log, error,...)
Definition: Log.h:392
static ConstString GetSymbolOrFunctionName(const SymbolContext &sym_ctx)
A class to represent register numbers, and able to convert between different register numbering schem...
bool IsValid() const
uint32_t GetAsKind(lldb::RegisterKind kind)
lldb::RegisterKind GetRegisterKind() const
uint32_t GetRegisterNumber() const
void init(lldb_private::Thread &thread, lldb::RegisterKind kind, uint32_t num)
const char * GetName()
virtual bool GetFallbackRegisterLocation(const RegisterInfo *reg_info, UnwindPlan::Row::AbstractRegisterLocation &unwind_regloc)
Definition: ABI.cpp:211
virtual bool CreateDefaultUnwindPlan(UnwindPlan &unwind_plan)=0
virtual bool CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan)=0
A section + offset based address range class.
Definition: AddressRange.h:25
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:211
A section + offset based address class.
Definition: Address.h:62
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:313
bool SetLoadAddress(lldb::addr_t load_addr, Target *target, bool allow_section_end=false)
Set the address to represent load_addr.
Definition: Address.cpp:1047
lldb::SectionSP GetSection() const
Get const accessor for the section.
Definition: Address.h:439
bool ResolveFunctionScope(lldb_private::SymbolContext &sym_ctx, lldb_private::AddressRange *addr_range_ptr=nullptr)
Resolve this address to its containing function and optionally get that function's address range.
Definition: Address.cpp:268
lldb::ModuleSP GetModule() const
Get accessor for the module for this address.
Definition: Address.cpp:285
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:293
lldb::addr_t GetOffset() const
Get the section relative offset value.
Definition: Address.h:329
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:355
bool SetOffset(lldb::addr_t offset)
Set accessor for the offset.
Definition: Address.h:448
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:461
bool GetUnwindPlan(Target &target, const Address &addr, UnwindPlan &unwind_plan)
virtual bool GetUnwindPlan(const Address &addr, UnwindPlan &unwind_plan)=0
A uniqued constant string class.
Definition: ConstString.h:40
bool GetUnwindPlan(const Address &addr, UnwindPlan &unwind_plan)
Return an UnwindPlan based on the call frame information encoded in the FDE of this DWARFCallFrameInf...
"lldb/Expression/DWARFExpressionList.h" Encapsulates a range map from file address range to a single ...
llvm::Expected< Value > Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx, lldb::addr_t func_load_addr, const Value *initial_value_ptr, const Value *object_address_ptr) const
DWARFExpression * GetMutableExpressionAtAddress(lldb::addr_t func_load_addr=LLDB_INVALID_ADDRESS, lldb::addr_t load_addr=0)
void SetRegisterKind(lldb::RegisterKind reg_kind)
Set the call-frame-info style register kind.
An data extractor class.
Definition: DataExtractor.h:48
virtual bool AlwaysRelyOnEHUnwindInfo(SymbolContext &sym_ctx)
Ask if the eh_frame information for the given SymbolContext should be relied on even when it's the fi...
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
Target * GetTargetPtr() const
Returns a pointer to the target object.
Target & GetTargetRef() const
Returns a reference to the target object.
Process * GetProcessPtr() const
Returns a pointer to the process object.
ConstString GetName() const
Definition: Function.cpp:720
static lldb::UnwindPlanSP GetRuntimeUnwindPlan(lldb_private::Thread &thread, lldb_private::RegisterContext *regctx, bool &behaves_like_zeroth_frame)
A language runtime may be able to provide a special UnwindPlan for the frame represented by the regis...
bool GetVerbose() const
Definition: Log.cpp:326
A plug-in interface definition class for debugging a process.
Definition: Process.h:343
virtual bool GetLoadAddressPermissions(lldb::addr_t load_addr, uint32_t &permissions)
Attempt to get the attributes for a region of memory in the process.
Definition: Process.cpp:2555
lldb::ByteOrder GetByteOrder() const
Definition: Process.cpp:3611
lldb::addr_t ReadPointerFromMemory(lldb::addr_t vm_addr, Status &error)
Definition: Process.cpp:2239
lldb::addr_t FixCodeAddress(lldb::addr_t pc)
Some targets might use bits in a code address to indicate a mode switch, ARM uses bit zero to signify...
Definition: Process.cpp:5930
uint32_t GetAddressByteSize() const
Definition: Process.cpp:3615
virtual DynamicLoader * GetDynamicLoader()
Get the dynamic loader plug-in for this process.
Definition: Process.cpp:2830
const lldb::ABISP & GetABI()
Definition: Process.cpp:1504
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1246
bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override
void UnwindLogMsg(const char *fmt,...) __attribute__((format(printf
void void UnwindLogMsgVerbose(const char *fmt,...) __attribute__((format(printf
const lldb_private::RegisterInfo * GetRegisterInfoAtIndex(size_t reg) override
bool ReadRegisterValueFromRegisterLocation(lldb_private::UnwindLLDB::ConcreteRegisterLocation regloc, const lldb_private::RegisterInfo *reg_info, lldb_private::RegisterValue &value)
const lldb_private::RegisterSet * GetRegisterSet(size_t reg_set) override
std::shared_ptr< RegisterContextUnwind > SharedPtr
void PropagateTrapHandlerFlagFromUnwindPlan(lldb::UnwindPlanSP unwind_plan)
Check if the given unwind plan indicates a signal trap handler, and update frame type and symbol cont...
bool ReadAllRegisterValues(lldb::WritableDataBufferSP &data_sp) override
bool WriteRegister(const lldb_private::RegisterInfo *reg_info, const lldb_private::RegisterValue &value) override
RegisterContextUnwind(lldb_private::Thread &thread, const SharedPtr &next_frame, lldb_private::SymbolContext &sym_ctx, uint32_t frame_number, lldb_private::UnwindLLDB &unwind_lldb)
std::map< uint32_t, lldb_private::UnwindLLDB::ConcreteRegisterLocation > m_registers
bool ForceSwitchToFallbackUnwindPlan()
Switch to the fallback unwind plan unconditionally without any safety checks that it is providing bet...
lldb_private::UnwindLLDB::RegisterSearchResult SavedLocationForRegister(uint32_t lldb_regnum, lldb_private::UnwindLLDB::ConcreteRegisterLocation &regloc)
bool ReadGPRValue(lldb::RegisterKind register_kind, uint32_t regnum, lldb::addr_t &value)
lldb_private::UnwindLLDB & m_parent_unwind
void void bool IsUnwindPlanValidForCurrentPC(lldb::UnwindPlanSP unwind_plan_sp)
bool WriteRegisterValueToRegisterLocation(lldb_private::UnwindLLDB::ConcreteRegisterLocation regloc, const lldb_private::RegisterInfo *reg_info, const lldb_private::RegisterValue &value)
bool TryFallbackUnwindPlan()
If the unwind has to the caller frame has failed, try something else.
bool ReadRegister(const lldb_private::RegisterInfo *reg_info, lldb_private::RegisterValue &value) override
bool ReadFrameAddress(lldb::RegisterKind register_kind, UnwindPlan::Row::FAValue &fa, lldb::addr_t &address)
lldb::addr_t GetReturnAddressHint(int32_t plan_offset)
bool IsTrapHandlerSymbol(lldb_private::Process *process, const lldb_private::SymbolContext &m_sym_ctx) const
Determines if a SymbolContext is a trap handler or not.
uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, uint32_t num) override
Convert from a given register numbering scheme to the lldb register numbering scheme.
lldb_private::SymbolContext & m_sym_ctx
bool BehavesLikeZerothFrame() const override
Indicates that this frame is currently executing code, that the PC value is not a return-pc but an ac...
virtual Status ReadRegisterValueFromMemory(const lldb_private::RegisterInfo *reg_info, lldb::addr_t src_addr, uint32_t src_len, RegisterValue &reg_value)
lldb::TargetSP CalculateTarget() override
virtual Status WriteRegisterValueToMemory(const lldb_private::RegisterInfo *reg_info, lldb::addr_t dst_addr, uint32_t dst_len, const RegisterValue &reg_value)
bool SetUInt(uint64_t uint, uint32_t byte_size)
uint64_t GetAsUInt64(uint64_t fail_value=UINT64_MAX, bool *success_ptr=nullptr) const
RegisterValue::Type GetType() const
Definition: RegisterValue.h:91
An error handling class.
Definition: Status.h:118
bool Fail() const
Test for error condition.
Definition: Status.cpp:294
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:195
const char * GetData() const
Definition: StreamString.h:45
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:34
Function * function
The Function for a given query.
lldb::ModuleSP module_sp
The Module for a given query.
void Clear(bool clear_target)
Clear the object's state.
Symbol * symbol
The Symbol for a given query.
ConstString GetName() const
Definition: Symbol.cpp:548
lldb::PlatformSP GetPlatform()
Definition: Target.h:1463
const ArchSpec & GetArchitecture() const
Definition: Target.h:1039
virtual lldb::RegisterContextSP GetRegisterContext()=0
uint32_t GetIndexID() const
Definition: Thread.cpp:1406
lldb::TargetSP CalculateTarget() override
Definition: Thread.cpp:1408
lldb::ProcessSP GetProcess() const
Definition: Thread.h:157
const std::vector< ConstString > & GetUserSpecifiedTrapHandlerFunctionNames()
Provide the list of user-specified trap handler functions.
Definition: UnwindLLDB.h:110
RegisterContextLLDBSP GetRegisterContextForFrameNum(uint32_t frame_num)
Definition: UnwindLLDB.cpp:469
bool SearchForSavedLocationForRegister(uint32_t lldb_regnum, lldb_private::UnwindLLDB::ConcreteRegisterLocation &regloc, uint32_t starting_frame_num, bool pc_register)
Definition: UnwindLLDB.cpp:476
const uint8_t * GetDWARFExpressionBytes()
Definition: UnwindPlan.h:311
std::shared_ptr< Row > RowSP
Definition: UnwindPlan.h:429
@ LoadAddress
A load address value.
void SetValueType(ValueType value_type)
Definition: Value.h:89
#define LLDB_REGNUM_GENERIC_RA
Definition: lldb-defines.h:59
#define LLDB_REGNUM_GENERIC_SP
Definition: lldb-defines.h:57
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
#define LLDB_INVALID_REGNUM
Definition: lldb-defines.h:87
#define LLDB_REGNUM_GENERIC_PC
Definition: lldb-defines.h:56
#define LLDB_REGNUM_GENERIC_FP
Definition: lldb-defines.h:58
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:332
bool VASprintf(llvm::SmallVectorImpl< char > &buf, const char *fmt, va_list args)
Definition: VASprintf.cpp:19
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::ABI > ABISP
Definition: lldb-forward.h:317
std::shared_ptr< lldb_private::Platform > PlatformSP
Definition: lldb-forward.h:388
std::shared_ptr< lldb_private::FuncUnwinders > FuncUnwindersSP
Definition: lldb-forward.h:356
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:389
std::shared_ptr< lldb_private::UnwindPlan > UnwindPlanSP
Definition: lldb-forward.h:483
std::shared_ptr< lldb_private::DataBuffer > DataBufferSP
Definition: lldb-forward.h:336
std::shared_ptr< lldb_private::WritableDataBuffer > WritableDataBufferSP
Definition: lldb-forward.h:337
uint64_t addr_t
Definition: lldb-types.h:80
std::shared_ptr< lldb_private::RegisterContext > RegisterContextSP
Definition: lldb-forward.h:394
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:373
RegisterKind
Register numbering types.
@ eRegisterKindGeneric
insn ptr reg, stack ptr reg, etc not specific to any particular target
@ kNumRegisterKinds
@ eRegisterKindLLDB
lldb's internal register numbers
Every register is described in detail including its name, alternate name (optional),...
uint32_t byte_size
Size in bytes of the register.
uint32_t kinds[lldb::kNumRegisterKinds]
Holds all of the various register numbers for all register kinds.
Registers are grouped into register sets.
An UnwindPlan::Row::AbstractRegisterLocation, combined with the register context and memory for a spe...
Definition: UnwindLLDB.h:44
union lldb_private::UnwindLLDB::ConcreteRegisterLocation::@37 location