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 RegisterLocation 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 RegisterLocation 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, lldb_private::UnwindLLDB::RegisterLocation &regloc) {
1263 RegisterNumber regnum(m_thread, eRegisterKindLLDB, lldb_regnum);
1264 Log *log = GetLog(LLDBLog::Unwind);
1265
1266 // Have we already found this register location?
1267 if (!m_registers.empty()) {
1268 std::map<uint32_t,
1270 iterator;
1271 iterator = m_registers.find(regnum.GetAsKind(eRegisterKindLLDB));
1272 if (iterator != m_registers.end()) {
1273 regloc = iterator->second;
1274 UnwindLogMsg("supplying caller's saved %s (%d)'s location, cached",
1275 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
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
1287 UnwindPlan::RowSP active_row =
1288 m_fast_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
1289 unwindplan_registerkind = m_fast_unwind_plan_sp->GetRegisterKind();
1290 if (regnum.GetAsKind(unwindplan_registerkind) == LLDB_INVALID_REGNUM) {
1291 UnwindLogMsg("could not convert lldb regnum %s (%d) into %d RegisterKind "
1292 "reg numbering scheme",
1293 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
1294 (int)unwindplan_registerkind);
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(regnum.GetAsKind(unwindplan_registerkind),
1306 unwindplan_regloc) &&
1307 !unwindplan_regloc.IsUndefined()) {
1309 "supplying caller's saved %s (%d)'s location using FastUnwindPlan",
1310 regnum.GetName(), regnum.GetAsKind(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) {
1321 got_new_full_unwindplan = true;
1322 }
1323
1327
1328 UnwindPlan::RowSP active_row =
1329 m_full_unwind_plan_sp->GetRowForFunctionOffset(
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(active_row_strm, m_full_unwind_plan_sp.get(),
1337 &m_thread,
1339 UnwindLogMsg("Using full unwind plan '%s'",
1340 m_full_unwind_plan_sp->GetSourceName().AsCString());
1341 UnwindLogMsg("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() !=
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.
1358 active_row->GetRegisterInfo
1359 (pc_regnum.GetAsKind (unwindplan_registerkind), scratch)) {
1360 UnwindLogMsg("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 m_thread, m_full_unwind_plan_sp->GetRegisterKind(),
1366 m_full_unwind_plan_sp->GetReturnAddressRegister());
1367 regnum = return_address_reg;
1368 UnwindLogMsg("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(eRegisterKindLLDB));
1372 }
1373 } else {
1374 if (regnum.GetAsKind(unwindplan_registerkind) == LLDB_INVALID_REGNUM) {
1375 if (unwindplan_registerkind == eRegisterKindGeneric) {
1376 UnwindLogMsg("could not convert lldb regnum %s (%d) into "
1377 "eRegisterKindGeneric reg numbering scheme",
1378 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1379 } else {
1380 UnwindLogMsg("could not convert lldb regnum %s (%d) into %d "
1381 "RegisterKind reg numbering scheme",
1382 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
1383 (int)unwindplan_registerkind);
1384 }
1386 }
1387 }
1388
1389 if (regnum.IsValid() &&
1390 active_row->GetRegisterInfo(regnum.GetAsKind(unwindplan_registerkind),
1391 unwindplan_regloc)) {
1392 have_unwindplan_regloc = true;
1394 "supplying caller's saved %s (%d)'s location using %s UnwindPlan",
1395 regnum.GetName(), regnum.GetAsKind(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(eRegisterKindLLDB) !=
1408 new_regloc.type =
1410 new_regloc.location.register_number =
1411 return_address_reg.GetAsKind(eRegisterKindLLDB);
1412 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = new_regloc;
1413 regloc = new_regloc;
1414 UnwindLogMsg("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(eRegisterKindLLDB),
1418 return_address_reg.GetAsKind(eRegisterKindLLDB));
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,
1441
1442 if (arch_default_ra_regnum.GetAsKind(unwindplan_registerkind) !=
1444 pc_regnum == regnum && unwindplan_regloc.IsInOtherRegister() &&
1445 unwindplan_regloc.GetRegisterNumber() ==
1446 arch_default_ra_regnum.GetAsKind(unwindplan_registerkind) &&
1447 m_full_unwind_plan_sp->GetSourcedFromCompiler() != eLazyBoolYes &&
1449 UnwindLogMsg("%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
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(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,
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(unwindplan_registerkind) !=
1471 active_row->GetRegisterInfo(
1472 arch_default_pc_reg.GetAsKind(unwindplan_registerkind),
1473 unwindplan_regloc)) {
1474 can_fetch_pc_value = true;
1475 }
1476 if (ReadFrameAddress(unwindplan_registerkind,
1477 active_row->GetCFAValue(), 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 =
1502 if (reg_info &&
1503 abi->GetFallbackRegisterLocation(reg_info, unwindplan_regloc)) {
1505 "supplying caller's saved %s (%d)'s location using ABI default",
1506 regnum.GetName(), regnum.GetAsKind(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
1517 new_regloc.type =
1520 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = new_regloc;
1521 regloc = new_regloc;
1522 UnwindLogMsg("supplying caller's register %s (%d) from the live "
1523 "RegisterContext at frame 0",
1524 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1526 } else {
1527 std::string unwindplan_name;
1529 unwindplan_name += "via '";
1530 unwindplan_name += m_full_unwind_plan_sp->GetSourceName().AsCString();
1531 unwindplan_name += "'";
1532 }
1533 UnwindLogMsg("no save location for %s (%d) %s", regnum.GetName(),
1535 unwindplan_name.c_str());
1536 }
1538 }
1539
1540 // unwindplan_regloc has valid contents about where to retrieve the register
1541 if (unwindplan_regloc.IsUnspecified()) {
1544 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = new_regloc;
1545 UnwindLogMsg("save location for %s (%d) is unspecified, continue searching",
1546 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1548 }
1549
1550 if (unwindplan_regloc.IsUndefined()) {
1552 "did not supply reg location for %s (%d) because it is volatile",
1553 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1555 }
1556
1557 if (unwindplan_regloc.IsSame()) {
1558 if (!IsFrameZero() &&
1561 UnwindLogMsg("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(eRegisterKindLLDB));
1566 } else {
1569 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1571 "supplying caller's register %s (%d), saved in register %s (%d)",
1572 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
1573 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1575 }
1576 }
1577
1578 if (unwindplan_regloc.IsCFAPlusOffset()) {
1579 int offset = unwindplan_regloc.GetOffset();
1581 regloc.location.inferred_value = m_cfa + offset;
1582 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1583 UnwindLogMsg("supplying caller's register %s (%d), value is CFA plus "
1584 "offset %d [value is 0x%" PRIx64 "]",
1585 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), offset,
1586 regloc.location.inferred_value);
1588 }
1589
1590 if (unwindplan_regloc.IsAtCFAPlusOffset()) {
1591 int offset = unwindplan_regloc.GetOffset();
1593 regloc.location.target_memory_location = m_cfa + offset;
1594 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1595 UnwindLogMsg("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(eRegisterKindLLDB), offset,
1600 }
1601
1602 if (unwindplan_regloc.IsAFAPlusOffset()) {
1605
1606 int offset = unwindplan_regloc.GetOffset();
1608 regloc.location.inferred_value = m_afa + offset;
1609 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1610 UnwindLogMsg("supplying caller's register %s (%d), value is AFA plus "
1611 "offset %d [value is 0x%" PRIx64 "]",
1612 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), offset,
1613 regloc.location.inferred_value);
1615 }
1616
1617 if (unwindplan_regloc.IsAtAFAPlusOffset()) {
1620
1621 int offset = unwindplan_regloc.GetOffset();
1623 regloc.location.target_memory_location = m_afa + offset;
1624 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1625 UnwindLogMsg("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(eRegisterKindLLDB), offset,
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(eRegisterKindLLDB) == LLDB_INVALID_REGNUM) {
1637 UnwindLogMsg("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(eRegisterKindLLDB));
1641 }
1644 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1646 "supplying caller's register %s (%d), saved in register %s (%d)",
1647 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
1648 row_regnum.GetName(), row_regnum.GetAsKind(eRegisterKindLLDB));
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);
1661 unwindplan_registerkind);
1662 Value cfa_val = Scalar(m_cfa);
1664 Value result;
1665 Status error;
1666 if (dwarfexpr.Evaluate(&exe_ctx, this, 0, &cfa_val, nullptr, result,
1667 &error)) {
1668 addr_t val;
1669 val = result.GetScalar().ULongLong();
1670 if (unwindplan_regloc.IsDWARFExpression()) {
1672 regloc.location.inferred_value = val;
1673 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1674 UnwindLogMsg("supplying caller's register %s (%d) via DWARF expression "
1675 "(IsDWARFExpression)",
1676 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1678 } else {
1679 regloc.type =
1681 regloc.location.target_memory_location = val;
1682 m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
1683 UnwindLogMsg("supplying caller's register %s (%d) via DWARF expression "
1684 "(IsAtDWARFExpression)",
1685 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1687 }
1688 }
1689 UnwindLogMsg("tried to use IsDWARFExpression or IsAtDWARFExpression for %s "
1690 "(%d) but failed",
1691 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1693 }
1694
1695 UnwindLogMsg("no save location for %s (%d) in this stack frame",
1696 regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
1697
1698 // FIXME UnwindPlan::Row types atDWARFExpression and isDWARFExpression are
1699 // unsupported.
1700
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
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
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
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 = {};
1750 regloc) ==
1752 const RegisterInfo *reg_info =
1754 if (reg_info) {
1755 RegisterValue reg_value;
1756 if (ReadRegisterValueFromRegisterLocation(regloc, reg_info, 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(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
1786
1787 UnwindPlan::RowSP active_row =
1788 m_fallback_unwind_plan_sp->GetRowForFunctionOffset(
1790
1791 if (active_row &&
1792 active_row->GetCFAValue().GetValueType() !=
1794 addr_t new_cfa;
1795 if (!ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(),
1796 active_row->GetCFAValue(), new_cfa) ||
1797 new_cfa == 0 || new_cfa == 1 || new_cfa == LLDB_INVALID_ADDRESS) {
1798 UnwindLogMsg("failed to get cfa with fallback unwindplan");
1800 m_full_unwind_plan_sp = original_full_unwind_plan_sp;
1801 return false;
1802 }
1803 m_cfa = new_cfa;
1804
1806 active_row->GetAFAValue(), m_afa);
1807
1809 regloc) ==
1811 const RegisterInfo *reg_info =
1813 if (reg_info) {
1814 RegisterValue reg_value;
1815 if (ReadRegisterValueFromRegisterLocation(regloc, reg_info,
1816 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(new_caller_pc_value);
1821 }
1822 }
1823 }
1824 }
1825
1826 if (new_caller_pc_value == LLDB_INVALID_ADDRESS) {
1827 UnwindLogMsg("failed to get a pc value for the caller frame with the "
1828 "fallback unwind plan");
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("fallback unwind plan got the same values for this frame "
1840 "CFA and caller frame pc, not using");
1842 m_full_unwind_plan_sp = original_full_unwind_plan_sp;
1843 return false;
1844 }
1845
1846 UnwindLogMsg("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.
1855 }
1856
1857 return true;
1858}
1859
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
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(m_current_offset);
1875
1876 if (active_row &&
1877 active_row->GetCFAValue().GetValueType() !=
1879 addr_t new_cfa;
1880 if (!ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(),
1881 active_row->GetCFAValue(), new_cfa) ||
1882 new_cfa == 0 || new_cfa == 1 || new_cfa == LLDB_INVALID_ADDRESS) {
1883 UnwindLogMsg("failed to get cfa with fallback unwindplan");
1885 return false;
1886 }
1887
1889 active_row->GetAFAValue(), m_afa);
1890
1893
1894 m_registers.clear();
1895
1896 m_cfa = new_cfa;
1897
1899
1900 UnwindLogMsg("switched unconditionally to the fallback unwindplan %s",
1901 m_full_unwind_plan_sp->GetSourceName().GetCString());
1902 return true;
1903 }
1904 return false;
1905}
1906
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
1921
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("Resetting current offset and re-doing symbol lookup; "
1934 "old symbol was %s",
1935 GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
1937
1938 AddressRange addr_range;
1940
1941 UnwindLogMsg("Symbol is now %s",
1942 GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
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();
1951 }
1952}
1953
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()) {
1965 RegisterNumber cfa_reg(m_thread, row_register_kind,
1966 fa.GetRegisterNumber());
1967 if (ReadGPRValue(cfa_reg, cfa_reg_contents)) {
1968 const RegisterInfo *reg_info =
1970 RegisterValue reg_value;
1971 if (reg_info) {
1972 if (abi_sp)
1973 cfa_reg_contents = abi_sp->FixDataAddress(cfa_reg_contents);
1975 reg_info, cfa_reg_contents, reg_info->byte_size, reg_value);
1976 if (error.Success()) {
1977 address = reg_value.GetAsUInt64();
1978 if (abi_sp)
1979 address = abi_sp->FixCodeAddress(address);
1981 "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(eRegisterKindLLDB),
1984 cfa_reg_contents, address);
1985 return true;
1986 } else {
1987 UnwindLogMsg("Tried to deref reg %s (%d) [0x%" PRIx64
1988 "] but memory read failed.",
1989 cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB),
1990 cfa_reg_contents);
1991 }
1992 }
1993 }
1994 break;
1995 }
1997 RegisterNumber cfa_reg(m_thread, row_register_kind,
1998 fa.GetRegisterNumber());
1999 if (ReadGPRValue(cfa_reg, cfa_reg_contents)) {
2000 if (abi_sp)
2001 cfa_reg_contents = abi_sp->FixDataAddress(cfa_reg_contents);
2002 if (cfa_reg_contents == LLDB_INVALID_ADDRESS || cfa_reg_contents == 0 ||
2003 cfa_reg_contents == 1) {
2005 "Got an invalid CFA register value - reg %s (%d), value 0x%" PRIx64,
2006 cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB),
2007 cfa_reg_contents);
2008 cfa_reg_contents = LLDB_INVALID_ADDRESS;
2009 return false;
2010 }
2011 address = cfa_reg_contents + fa.GetOffset();
2013 "CFA is 0x%" PRIx64 ": Register %s (%d) contents are 0x%" PRIx64
2014 ", offset is %d",
2015 address, cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB),
2016 cfa_reg_contents, fa.GetOffset());
2017 return true;
2018 }
2019 break;
2020 }
2022 ExecutionContext exe_ctx(m_thread.shared_from_this());
2023 Process *process = exe_ctx.GetProcessPtr();
2026 process->GetByteOrder(),
2027 process->GetAddressByteSize());
2028 ModuleSP opcode_ctx;
2029 DWARFExpressionList dwarfexpr(opcode_ctx, dwarfdata, nullptr);
2031 row_register_kind);
2032 Value result;
2033 Status error;
2034 if (dwarfexpr.Evaluate(&exe_ctx, this, 0, nullptr, nullptr, result,
2035 &error)) {
2036 address = result.GetScalar().ULongLong();
2037 if (ABISP abi_sp = m_thread.GetProcess()->GetABI())
2038 address = abi_sp->FixCodeAddress(address);
2039
2040 UnwindLogMsg("CFA value set by DWARF expression is 0x%" PRIx64,
2041 address);
2042 return true;
2043 }
2044 UnwindLogMsg("Failed to set CFA value via DWARF expression: %s",
2045 error.AsCString());
2046 break;
2047 }
2049 Process &process = *m_thread.GetProcess();
2050 lldb::addr_t return_address_hint = GetReturnAddressHint(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(candidate_addr, st);
2060 if (st.Fail()) {
2061 UnwindLogMsg("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(candidate, permissions) &&
2068 permissions & lldb::ePermissionsExecutable) {
2069 address = candidate_addr;
2070 UnwindLogMsg("Heuristically found CFA: 0x%" PRIx64, address);
2071 return true;
2072 }
2073 }
2074 UnwindLogMsg("No suitable CFA found");
2075 break;
2076 }
2077 default:
2078 return false;
2079 }
2080 return false;
2081}
2082
2084 addr_t hint;
2086 return LLDB_INVALID_ADDRESS;
2088 return LLDB_INVALID_ADDRESS;
2089 if (ABISP abi_sp = m_thread.GetProcess()->GetABI())
2090 hint = abi_sp->FixCodeAddress(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 *next->m_sym_ctx.symbol))
2100 hint += *expected_size;
2101 else {
2102 UnwindLogMsgVerbose("Could not retrieve parameter size: %s",
2103 llvm::toString(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
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 register_kind, regnum, eRegisterKindLLDB, lldb_regnum)) {
2136 return false;
2137 }
2138
2139 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(lldb_regnum);
2140 assert(reg_info);
2141 if (!reg_info) {
2143 "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 register_kind, regnum, eRegisterKindGeneric, 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(value);
2166 if (generic_regnum == LLDB_REGNUM_GENERIC_SP ||
2167 generic_regnum == LLDB_REGNUM_GENERIC_FP)
2168 value = abi_sp->FixDataAddress(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
2183 lldb_regnum, regloc, m_frame_number - 1, pc_register)) {
2184 return false;
2185 }
2186 if (ReadRegisterValueFromRegisterLocation(regloc, reg_info, 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(value);
2191 }
2192 }
2193 return true;
2194 }
2195 return false;
2196}
2197
2199 addr_t &value) {
2200 return ReadGPRValue(regnum.GetRegisterKind(), regnum.GetRegisterNumber(),
2201 value);
2202}
2203
2204// Find the value of a register in THIS frame
2205
2207 RegisterValue &value) {
2208 if (!IsValid())
2209 return false;
2210
2211 const uint32_t lldb_regnum = reg_info->kinds[eRegisterKindLLDB];
2212 UnwindLogMsgVerbose("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("passing along to the live register context for reg %d",
2218 lldb_regnum);
2219 return m_thread.GetRegisterContext()->ReadRegister(reg_info, value);
2220 }
2221
2222 bool is_pc_regnum = false;
2225 is_pc_regnum = true;
2226 }
2227
2229 // Find out where the NEXT frame saved THIS frame's register contents
2231 lldb_regnum, regloc, m_frame_number - 1, 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(reg_value);
2241 }
2242 }
2243 }
2244 return result;
2245}
2246
2248 const RegisterValue &value) {
2249 if (!IsValid())
2250 return false;
2251
2252 const uint32_t lldb_regnum = reg_info->kinds[eRegisterKindLLDB];
2253 UnwindLogMsgVerbose("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("passing along to the live register context for reg %d",
2259 lldb_regnum);
2260 return m_thread.GetRegisterContext()->WriteRegister(reg_info, value);
2261 }
2262
2264 // Find out where the NEXT frame saved THIS frame's register contents
2266 lldb_regnum, regloc, m_frame_number - 1, false))
2267 return false;
2268
2269 return WriteRegisterValueToRegisterLocation(regloc, reg_info, value);
2270}
2271
2272// Don't need to implement this one
2274 lldb::WritableDataBufferSP &data_sp) {
2275 return false;
2276}
2277
2278// Don't need to implement this one
2280 const lldb::DataBufferSP &data_sp) {
2281 return false;
2282}
2283
2284// Retrieve the pc value for THIS from
2285
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
2299 if (m_frame_number == 0)
2300 return regctx;
2302}
2303
2307}
2308
2309// Retrieve the address of the start of the function of THIS frame
2310
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(start_pc);
2324 }
2325 }
2326 return read_successfully;
2327 }
2328 start_pc = m_start_pc.GetLoadAddress(CalculateTarget().get());
2329 return true;
2330}
2331
2332// Retrieve the current pc value for THIS frame, as saved by the NEXT frame.
2333
2335 if (!IsValid())
2336 return false;
2337
2338 bool above_trap_handler = false;
2339 if (GetNextFrame().get() && GetNextFrame()->IsValid() &&
2341 above_trap_handler = true;
2342
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(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(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
2379 Log *log = GetLog(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(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}
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_LOGF(log,...)
Definition: Log.h:349
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::RegisterLocation &unwind_regloc)
Definition: ABI.cpp:178
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:209
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:1046
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:450
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 ...
bool Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx, lldb::addr_t func_load_addr, const Value *initial_value_ptr, const Value *object_address_ptr, Value &result, Status *error_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:692
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:313
A plug-in interface definition class for debugging a process.
Definition: Process.h:340
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:2407
lldb::ByteOrder GetByteOrder() const
Definition: Process.cpp:3399
lldb::addr_t ReadPointerFromMemory(lldb::addr_t vm_addr, Status &error)
Definition: Process.cpp:2101
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:5739
uint32_t GetAddressByteSize() const
Definition: Process.cpp:3403
virtual DynamicLoader * GetDynamicLoader()
Get the dynamic loader plug-in for this process.
Definition: Process.cpp:2680
const lldb::ABISP & GetABI()
Definition: Process.cpp:1496
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1276
bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override
void UnwindLogMsg(const char *fmt,...) __attribute__((format(printf
bool WriteRegisterValueToRegisterLocation(lldb_private::UnwindLLDB::RegisterLocation regloc, const lldb_private::RegisterInfo *reg_info, const lldb_private::RegisterValue &value)
bool ReadRegisterValueFromRegisterLocation(lldb_private::UnwindLLDB::RegisterLocation regloc, const lldb_private::RegisterInfo *reg_info, lldb_private::RegisterValue &value)
void void UnwindLogMsgVerbose(const char *fmt,...) __attribute__((format(printf
const lldb_private::RegisterInfo * GetRegisterInfoAtIndex(size_t reg) override
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)
lldb_private::UnwindLLDB::RegisterSearchResult SavedLocationForRegister(uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation &regloc)
bool ForceSwitchToFallbackUnwindPlan()
Switch to the fallback unwind plan unconditionally without any safety checks that it is providing bet...
std::map< uint32_t, lldb_private::UnwindLLDB::RegisterLocation > m_registers
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 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
unsigned long long ULongLong(unsigned long long fail_value=0) const
Definition: Scalar.cpp:335
An error handling class.
Definition: Status.h:44
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:130
const char * GetData() const
Definition: StreamString.h:43
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:552
lldb::PlatformSP GetPlatform()
Definition: Target.h:1431
const ArchSpec & GetArchitecture() const
Definition: Target.h:1012
virtual lldb::RegisterContextSP GetRegisterContext()=0
uint32_t GetIndexID() const
Definition: Thread.cpp:1388
lldb::TargetSP CalculateTarget() override
Definition: Thread.cpp:1390
lldb::ProcessSP GetProcess() const
Definition: Thread.h:154
const std::vector< ConstString > & GetUserSpecifiedTrapHandlerFunctionNames()
Provide the list of user-specified trap handler functions.
Definition: UnwindLLDB.h:106
RegisterContextLLDBSP GetRegisterContextForFrameNum(uint32_t frame_num)
Definition: UnwindLLDB.cpp:464
bool SearchForSavedLocationForRegister(uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation &regloc, uint32_t starting_frame_num, bool pc_register)
Definition: UnwindLLDB.cpp:471
const uint8_t * GetDWARFExpressionBytes()
Definition: UnwindPlan.h:289
std::shared_ptr< Row > RowSP
Definition: UnwindPlan.h:395
const Scalar & GetScalar() const
Definition: Value.h:112
@ 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.
Definition: SBAttachInfo.h:14
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:314
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:310
std::shared_ptr< lldb_private::Platform > PlatformSP
Definition: lldb-forward.h:380
std::shared_ptr< lldb_private::FuncUnwinders > FuncUnwindersSP
Definition: lldb-forward.h:348
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:381
std::shared_ptr< lldb_private::UnwindPlan > UnwindPlanSP
Definition: lldb-forward.h:471
std::shared_ptr< lldb_private::DataBuffer > DataBufferSP
Definition: lldb-forward.h:328
std::shared_ptr< lldb_private::WritableDataBuffer > WritableDataBufferSP
Definition: lldb-forward.h:329
uint64_t addr_t
Definition: lldb-types.h:79
std::shared_ptr< lldb_private::RegisterContext > RegisterContextSP
Definition: lldb-forward.h:386
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:365
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.
union lldb_private::UnwindLLDB::RegisterLocation::@38 location