OSchip
/
llvm-project
mirror of https://github.com/THU-DSP-LAB/llvm-project.git
13
0
Fork 6
Code Issues Packages Projects Releases Wiki Activity
llvm-project/lldb/source/Target/RegisterContextUnwind.cpp

2364 lines
93 KiB
C++
Raw Blame History

//===-- RegisterContextUnwind.cpp -----------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "lldb/Target/RegisterContextUnwind.h"
#include "lldb/Core/Address.h"
#include "lldb/Core/AddressRange.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/Value.h"
#include "lldb/Expression/DWARFExpressionList.h"
#include "lldb/Symbol/ArmUnwindInfo.h"
#include "lldb/Symbol/CallFrameInfo.h"
#include "lldb/Symbol/DWARFCallFrameInfo.h"
#include "lldb/Symbol/FuncUnwinders.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/SymbolFile.h"
#include "lldb/Target/ABI.h"
#include "lldb/Target/DynamicLoader.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/LanguageRuntime.h"
#include "lldb/Target/Platform.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/RegisterValue.h"
#include "lldb/Utility/VASPrintf.h"
#include "lldb/lldb-private.h"
#include <memory>
using namespace lldb;
using namespace lldb_private;
static ConstString GetSymbolOrFunctionName(const SymbolContext &sym_ctx) {
if (sym_ctx.symbol)
return sym_ctx.symbol->GetName();
else if (sym_ctx.function)
return sym_ctx.function->GetName();
return ConstString();
}
RegisterContextUnwind::RegisterContextUnwind(Thread &thread,
const SharedPtr &next_frame,
SymbolContext &sym_ctx,
uint32_t frame_number,
UnwindLLDB &unwind_lldb)
: RegisterContext(thread, frame_number), m_thread(thread),
m_fast_unwind_plan_sp(), m_full_unwind_plan_sp(),
m_fallback_unwind_plan_sp(), m_all_registers_available(false),
m_frame_type(-1), m_cfa(LLDB_INVALID_ADDRESS),
m_afa(LLDB_INVALID_ADDRESS), m_start_pc(), m_current_pc(),
m_current_offset(0), m_current_offset_backed_up_one(0),
m_behaves_like_zeroth_frame(false), m_sym_ctx(sym_ctx),
m_sym_ctx_valid(false), m_frame_number(frame_number), m_registers(),
m_parent_unwind(unwind_lldb) {
m_sym_ctx.Clear(false);
m_sym_ctx_valid = false;
if (IsFrameZero()) {
InitializeZerothFrame();
} else {
InitializeNonZerothFrame();
}
// This same code exists over in the GetFullUnwindPlanForFrame() but it may
// not have been executed yet
if (IsFrameZero() || next_frame->m_frame_type == eTrapHandlerFrame ||
next_frame->m_frame_type == eDebuggerFrame) {
m_all_registers_available = true;
}
}
bool RegisterContextUnwind::IsUnwindPlanValidForCurrentPC(
lldb::UnwindPlanSP unwind_plan_sp) {
if (!unwind_plan_sp)
return false;
// check if m_current_pc is valid
if (unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
// yes - current offset can be used as is
return true;
}
// if m_current_offset <= 0, we've got nothing else to try
if (m_current_offset <= 0)
return false;
// check pc - 1 to see if it's valid
Address pc_minus_one(m_current_pc);
pc_minus_one.SetOffset(m_current_pc.GetOffset() - 1);
if (unwind_plan_sp->PlanValidAtAddress(pc_minus_one)) {
return true;
}
return false;
}
// Initialize a RegisterContextUnwind which is the first frame of a stack -- the
// zeroth frame or currently executing frame.
void RegisterContextUnwind::InitializeZerothFrame() {
Log *log = GetLog(LLDBLog::Unwind);
ExecutionContext exe_ctx(m_thread.shared_from_this());
RegisterContextSP reg_ctx_sp = m_thread.GetRegisterContext();
if (reg_ctx_sp.get() == nullptr) {
m_frame_type = eNotAValidFrame;
UnwindLogMsg("frame does not have a register context");
return;
}
addr_t current_pc = reg_ctx_sp->GetPC();
if (current_pc == LLDB_INVALID_ADDRESS) {
m_frame_type = eNotAValidFrame;
UnwindLogMsg("frame does not have a pc");
return;
}
Process *process = exe_ctx.GetProcessPtr();
// Let ABIs fixup code addresses to make sure they are valid. In ARM ABIs
// this will strip bit zero in case we read a PC from memory or from the LR.
// (which would be a no-op in frame 0 where we get it from the register set,
// but still a good idea to make the call here for other ABIs that may
// exist.)
ABI *abi = process->GetABI().get();
if (abi)
current_pc = abi->FixCodeAddress(current_pc);
UnwindPlanSP lang_runtime_plan_sp = LanguageRuntime::GetRuntimeUnwindPlan(
m_thread, this, m_behaves_like_zeroth_frame);
if (lang_runtime_plan_sp.get()) {
UnwindLogMsg("This is an async frame");
}
// Initialize m_current_pc, an Address object, based on current_pc, an
// addr_t.
m_current_pc.SetLoadAddress(current_pc, &process->GetTarget());
// If we don't have a Module for some reason, we're not going to find
// symbol/function information - just stick in some reasonable defaults and
// hope we can unwind past this frame.
ModuleSP pc_module_sp(m_current_pc.GetModule());
if (!m_current_pc.IsValid() || !pc_module_sp) {
UnwindLogMsg("using architectural default unwind method");
}
AddressRange addr_range;
m_sym_ctx_valid = m_current_pc.ResolveFunctionScope(m_sym_ctx, &addr_range);
if (m_sym_ctx.symbol) {
UnwindLogMsg("with pc value of 0x%" PRIx64 ", symbol name is '%s'",
current_pc, GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
} else if (m_sym_ctx.function) {
UnwindLogMsg("with pc value of 0x%" PRIx64 ", function name is '%s'",
current_pc, GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
} else {
UnwindLogMsg("with pc value of 0x%" PRIx64
", no symbol/function name is known.",
current_pc);
}
if (IsTrapHandlerSymbol(process, m_sym_ctx)) {
m_frame_type = eTrapHandlerFrame;
} else {
// FIXME: Detect eDebuggerFrame here.
m_frame_type = eNormalFrame;
}
// If we were able to find a symbol/function, set addr_range to the bounds of
// that symbol/function. else treat the current pc value as the start_pc and
// record no offset.
if (addr_range.GetBaseAddress().IsValid()) {
m_start_pc = addr_range.GetBaseAddress();
if (m_current_pc.GetSection() == m_start_pc.GetSection()) {
m_current_offset = m_current_pc.GetOffset() - m_start_pc.GetOffset();
} else if (m_current_pc.GetModule() == m_start_pc.GetModule()) {
// This means that whatever symbol we kicked up isn't really correct ---
// we should not cross section boundaries ... We really should NULL out
// the function/symbol in this case unless there is a bad assumption here
// due to inlined functions?
m_current_offset =
m_current_pc.GetFileAddress() - m_start_pc.GetFileAddress();
}
m_current_offset_backed_up_one = m_current_offset;
} else {
m_start_pc = m_current_pc;
m_current_offset = -1;
m_current_offset_backed_up_one = -1;
}
// We've set m_frame_type and m_sym_ctx before these calls.
m_fast_unwind_plan_sp = GetFastUnwindPlanForFrame();
m_full_unwind_plan_sp = GetFullUnwindPlanForFrame();
UnwindPlan::RowSP active_row;
lldb::RegisterKind row_register_kind = eRegisterKindGeneric;
// If we have LanguageRuntime UnwindPlan for this unwind, use those
// rules to find the caller frame instead of the function's normal
// UnwindPlans. The full unwind plan for this frame will be
// the LanguageRuntime-provided unwind plan, and there will not be a
// fast unwind plan.
if (lang_runtime_plan_sp.get()) {
active_row =
lang_runtime_plan_sp->GetRowForFunctionOffset(m_current_offset);
row_register_kind = lang_runtime_plan_sp->GetRegisterKind();
if (!ReadFrameAddress(row_register_kind, active_row->GetCFAValue(),
m_cfa)) {
UnwindLogMsg("Cannot set cfa");
} else {
m_full_unwind_plan_sp = lang_runtime_plan_sp;
if (log) {
StreamString active_row_strm;
active_row->Dump(active_row_strm, lang_runtime_plan_sp.get(), &m_thread,
m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
UnwindLogMsg("async active row: %s", active_row_strm.GetData());
}
UnwindLogMsg("m_cfa = 0x%" PRIx64 " m_afa = 0x%" PRIx64, m_cfa, m_afa);
UnwindLogMsg(
"initialized async frame current pc is 0x%" PRIx64
" cfa is 0x%" PRIx64 " afa is 0x%" PRIx64,
(uint64_t)m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr()),
(uint64_t)m_cfa, (uint64_t)m_afa);
return;
}
}
if (m_full_unwind_plan_sp &&
m_full_unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
active_row =
m_full_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
if (active_row.get() && log) {
StreamString active_row_strm;
active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(), &m_thread,
m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
UnwindLogMsg("%s", active_row_strm.GetData());
}
}
if (!active_row.get()) {
UnwindLogMsg("could not find an unwindplan row for this frame's pc");
m_frame_type = eNotAValidFrame;
return;
}
if (!ReadFrameAddress(row_register_kind, active_row->GetCFAValue(), m_cfa)) {
// Try the fall back unwind plan since the
// full unwind plan failed.
FuncUnwindersSP func_unwinders_sp;
UnwindPlanSP call_site_unwind_plan;
bool cfa_status = false;
if (m_sym_ctx_valid) {
func_unwinders_sp =
pc_module_sp->GetUnwindTable().GetFuncUnwindersContainingAddress(
m_current_pc, m_sym_ctx);
}
if (func_unwinders_sp.get() != nullptr)
call_site_unwind_plan = func_unwinders_sp->GetUnwindPlanAtCallSite(
process->GetTarget(), m_thread);
if (call_site_unwind_plan.get() != nullptr) {
m_fallback_unwind_plan_sp = call_site_unwind_plan;
if (TryFallbackUnwindPlan())
cfa_status = true;
}
if (!cfa_status) {
UnwindLogMsg("could not read CFA value for first frame.");
m_frame_type = eNotAValidFrame;
return;
}
} else
ReadFrameAddress(row_register_kind, active_row->GetAFAValue(), m_afa);
UnwindLogMsg("initialized frame current pc is 0x%" PRIx64 " cfa is 0x%" PRIx64
" afa is 0x%" PRIx64 " using %s UnwindPlan",
(uint64_t)m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr()),
(uint64_t)m_cfa,
(uint64_t)m_afa,
m_full_unwind_plan_sp->GetSourceName().GetCString());
}
// Initialize a RegisterContextUnwind for the non-zeroth frame -- rely on the
// RegisterContextUnwind "below" it to provide things like its current pc value.
void RegisterContextUnwind::InitializeNonZerothFrame() {
Log *log = GetLog(LLDBLog::Unwind);
if (IsFrameZero()) {
m_frame_type = eNotAValidFrame;
UnwindLogMsg("non-zeroth frame tests positive for IsFrameZero -- that "
"shouldn't happen.");
return;
}
if (!GetNextFrame().get() || !GetNextFrame()->IsValid()) {
m_frame_type = eNotAValidFrame;
UnwindLogMsg("Could not get next frame, marking this frame as invalid.");
return;
}
if (!m_thread.GetRegisterContext()) {
m_frame_type = eNotAValidFrame;
UnwindLogMsg("Could not get register context for this thread, marking this "
"frame as invalid.");
return;
}
ExecutionContext exe_ctx(m_thread.shared_from_this());
Process *process = exe_ctx.GetProcessPtr();
// Some languages may have a logical parent stack frame which is
// not a real stack frame, but the programmer would consider it to
// be the caller of the frame, e.g. Swift asynchronous frames.
//
// A LanguageRuntime may provide an UnwindPlan that is used in this
// stack trace base on the RegisterContext contents, intsead
// of the normal UnwindPlans we would use for the return-pc.
UnwindPlanSP lang_runtime_plan_sp = LanguageRuntime::GetRuntimeUnwindPlan(
m_thread, this, m_behaves_like_zeroth_frame);
if (lang_runtime_plan_sp.get()) {
UnwindLogMsg("This is an async frame");
}
addr_t pc;
if (!ReadGPRValue(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, pc)) {
UnwindLogMsg("could not get pc value");
m_frame_type = eNotAValidFrame;
return;
}
// Let ABIs fixup code addresses to make sure they are valid. In ARM ABIs
// this will strip bit zero in case we read a PC from memory or from the LR.
ABI *abi = process->GetABI().get();
if (abi)
pc = abi->FixCodeAddress(pc);
if (log) {
UnwindLogMsg("pc = 0x%" PRIx64, pc);
addr_t reg_val;
if (ReadGPRValue(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FP, reg_val))
UnwindLogMsg("fp = 0x%" PRIx64, reg_val);
if (ReadGPRValue(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP, reg_val))
UnwindLogMsg("sp = 0x%" PRIx64, reg_val);
}
// A pc of 0x0 means it's the end of the stack crawl unless we're above a trap
// handler function
bool above_trap_handler = false;
if (GetNextFrame().get() && GetNextFrame()->IsValid() &&
GetNextFrame()->IsTrapHandlerFrame())
above_trap_handler = true;
if (pc == 0 || pc == 0x1) {
if (!above_trap_handler) {
m_frame_type = eNotAValidFrame;
UnwindLogMsg("this frame has a pc of 0x0");
return;
}
}
const bool allow_section_end = true;
m_current_pc.SetLoadAddress(pc, &process->GetTarget(), allow_section_end);
// If we don't have a Module for some reason, we're not going to find
// symbol/function information - just stick in some reasonable defaults and
// hope we can unwind past this frame. If we're above a trap handler,
// we may be at a bogus address because we jumped through a bogus function
// pointer and trapped, so don't force the arch default unwind plan in that
// case.
ModuleSP pc_module_sp(m_current_pc.GetModule());
if ((!m_current_pc.IsValid() || !pc_module_sp) &&
above_trap_handler == false) {
UnwindLogMsg("using architectural default unwind method");
// Test the pc value to see if we know it's in an unmapped/non-executable
// region of memory.
uint32_t permissions;
if (process->GetLoadAddressPermissions(pc, permissions) &&
(permissions & ePermissionsExecutable) == 0) {
// If this is the second frame off the stack, we may have unwound the
// first frame incorrectly. But using the architecture default unwind
// plan may get us back on track -- albeit possibly skipping a real
// frame. Give this frame a clearly-invalid pc and see if we can get any
// further.
if (GetNextFrame().get() && GetNextFrame()->IsValid() &&
GetNextFrame()->IsFrameZero()) {
UnwindLogMsg("had a pc of 0x%" PRIx64 " which is not in executable "
"memory but on frame 1 -- "
"allowing it once.",
(uint64_t)pc);
m_frame_type = eSkipFrame;
} else {
// anywhere other than the second frame, a non-executable pc means
// we're off in the weeds -- stop now.
m_frame_type = eNotAValidFrame;
UnwindLogMsg("pc is in a non-executable section of memory and this "
"isn't the 2nd frame in the stack walk.");
return;
}
}
if (abi) {
m_fast_unwind_plan_sp.reset();
m_full_unwind_plan_sp =
std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
abi->CreateDefaultUnwindPlan(*m_full_unwind_plan_sp);
if (m_frame_type != eSkipFrame) // don't override eSkipFrame
{
m_frame_type = eNormalFrame;
}
m_all_registers_available = false;
m_current_offset = -1;
m_current_offset_backed_up_one = -1;
RegisterKind row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
UnwindPlan::RowSP row = m_full_unwind_plan_sp->GetRowForFunctionOffset(0);
if (row.get()) {
if (!ReadFrameAddress(row_register_kind, row->GetCFAValue(), m_cfa)) {
UnwindLogMsg("failed to get cfa value");
if (m_frame_type != eSkipFrame) // don't override eSkipFrame
{
m_frame_type = eNotAValidFrame;
}
return;
}
ReadFrameAddress(row_register_kind, row->GetAFAValue(), m_afa);
// A couple of sanity checks..
if (m_cfa == LLDB_INVALID_ADDRESS || m_cfa == 0 || m_cfa == 1) {
UnwindLogMsg("could not find a valid cfa address");
m_frame_type = eNotAValidFrame;
return;
}
// m_cfa should point into the stack memory; if we can query memory
// region permissions, see if the memory is allocated & readable.
if (process->GetLoadAddressPermissions(m_cfa, permissions) &&
(permissions & ePermissionsReadable) == 0) {
m_frame_type = eNotAValidFrame;
UnwindLogMsg(
"the CFA points to a region of memory that is not readable");
return;
}
} else {
UnwindLogMsg("could not find a row for function offset zero");
m_frame_type = eNotAValidFrame;
return;
}
if (CheckIfLoopingStack()) {
TryFallbackUnwindPlan();
if (CheckIfLoopingStack()) {
UnwindLogMsg("same CFA address as next frame, assuming the unwind is "
"looping - stopping");
m_frame_type = eNotAValidFrame;
return;
}
}
UnwindLogMsg("initialized frame cfa is 0x%" PRIx64 " afa is 0x%" PRIx64,
(uint64_t)m_cfa, (uint64_t)m_afa);
return;
}
m_frame_type = eNotAValidFrame;
UnwindLogMsg("could not find any symbol for this pc, or a default unwind "
"plan, to continue unwind.");
return;
}
AddressRange addr_range;
m_sym_ctx_valid = m_current_pc.ResolveFunctionScope(m_sym_ctx, &addr_range);
if (m_sym_ctx.symbol) {
UnwindLogMsg("with pc value of 0x%" PRIx64 ", symbol name is '%s'", pc,
GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
} else if (m_sym_ctx.function) {
UnwindLogMsg("with pc value of 0x%" PRIx64 ", function name is '%s'", pc,
GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
} else {
UnwindLogMsg("with pc value of 0x%" PRIx64
", no symbol/function name is known.",
pc);
}
bool decr_pc_and_recompute_addr_range;
if (!m_sym_ctx_valid) {
// Always decrement and recompute if the symbol lookup failed
decr_pc_and_recompute_addr_range = true;
} else if (GetNextFrame()->m_frame_type == eTrapHandlerFrame ||
GetNextFrame()->m_frame_type == eDebuggerFrame) {
// Don't decrement if we're "above" an asynchronous event like
// sigtramp.
decr_pc_and_recompute_addr_range = false;
} else if (!addr_range.GetBaseAddress().IsValid() ||
addr_range.GetBaseAddress().GetSection() != m_current_pc.GetSection() ||
addr_range.GetBaseAddress().GetOffset() != m_current_pc.GetOffset()) {
// If our "current" pc isn't the start of a function, decrement the pc
// if we're up the stack.
if (m_behaves_like_zeroth_frame)
decr_pc_and_recompute_addr_range = false;
else
decr_pc_and_recompute_addr_range = true;
} else if (IsTrapHandlerSymbol(process, m_sym_ctx)) {
// Signal dispatch may set the return address of the handler it calls to
// point to the first byte of a return trampoline (like __kernel_rt_sigreturn),
// so do not decrement and recompute if the symbol we already found is a trap
// handler.
decr_pc_and_recompute_addr_range = false;
} else if (m_behaves_like_zeroth_frame) {
decr_pc_and_recompute_addr_range = false;
} else {
// Decrement to find the function containing the call.
decr_pc_and_recompute_addr_range = true;
}
// We need to back up the pc by 1 byte and re-search for the Symbol to handle
// the case where the "saved pc" value is pointing to the next function, e.g.
// if a function ends with a CALL instruction.
// FIXME this may need to be an architectural-dependent behavior; if so we'll
// need to add a member function
// to the ABI plugin and consult that.
if (decr_pc_and_recompute_addr_range) {
UnwindLogMsg("Backing up the pc value of 0x%" PRIx64
" by 1 and re-doing symbol lookup; old symbol was %s",
pc, GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
Address temporary_pc;
temporary_pc.SetLoadAddress(pc - 1, &process->GetTarget());
m_sym_ctx.Clear(false);
m_sym_ctx_valid = temporary_pc.ResolveFunctionScope(m_sym_ctx, &addr_range);
UnwindLogMsg("Symbol is now %s",
GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
}
// If we were able to find a symbol/function, set addr_range_ptr to the
// bounds of that symbol/function. else treat the current pc value as the
// start_pc and record no offset.
if (addr_range.GetBaseAddress().IsValid()) {
m_start_pc = addr_range.GetBaseAddress();
m_current_offset = pc - m_start_pc.GetLoadAddress(&process->GetTarget());
m_current_offset_backed_up_one = m_current_offset;
if (decr_pc_and_recompute_addr_range &&
m_current_offset_backed_up_one > 0) {
m_current_offset_backed_up_one--;
if (m_sym_ctx_valid) {
m_current_pc.SetLoadAddress(pc - 1, &process->GetTarget());
}
}
} else {
m_start_pc = m_current_pc;
m_current_offset = -1;
m_current_offset_backed_up_one = -1;
}
if (IsTrapHandlerSymbol(process, m_sym_ctx)) {
m_frame_type = eTrapHandlerFrame;
} else {
// FIXME: Detect eDebuggerFrame here.
if (m_frame_type != eSkipFrame) // don't override eSkipFrame
{
m_frame_type = eNormalFrame;
}
}
UnwindPlan::RowSP active_row;
RegisterKind row_register_kind = eRegisterKindGeneric;
// If we have LanguageRuntime UnwindPlan for this unwind, use those
// rules to find the caller frame instead of the function's normal
// UnwindPlans. The full unwind plan for this frame will be
// the LanguageRuntime-provided unwind plan, and there will not be a
// fast unwind plan.
if (lang_runtime_plan_sp.get()) {
active_row =
lang_runtime_plan_sp->GetRowForFunctionOffset(m_current_offset);
row_register_kind = lang_runtime_plan_sp->GetRegisterKind();
if (!ReadFrameAddress(row_register_kind, active_row->GetCFAValue(),
m_cfa)) {
UnwindLogMsg("Cannot set cfa");
} else {
m_full_unwind_plan_sp = lang_runtime_plan_sp;
if (log) {
StreamString active_row_strm;
active_row->Dump(active_row_strm, lang_runtime_plan_sp.get(), &m_thread,
m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
UnwindLogMsg("async active row: %s", active_row_strm.GetData());
}
UnwindLogMsg("m_cfa = 0x%" PRIx64 " m_afa = 0x%" PRIx64, m_cfa, m_afa);
UnwindLogMsg(
"initialized async frame current pc is 0x%" PRIx64
" cfa is 0x%" PRIx64 " afa is 0x%" PRIx64,
(uint64_t)m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr()),
(uint64_t)m_cfa, (uint64_t)m_afa);
return;
}
}
// We've set m_frame_type and m_sym_ctx before this call.
m_fast_unwind_plan_sp = GetFastUnwindPlanForFrame();
// Try to get by with just the fast UnwindPlan if possible - the full
// UnwindPlan may be expensive to get (e.g. if we have to parse the entire
// eh_frame section of an ObjectFile for the first time.)
if (m_fast_unwind_plan_sp &&
m_fast_unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
active_row =
m_fast_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
row_register_kind = m_fast_unwind_plan_sp->GetRegisterKind();
PropagateTrapHandlerFlagFromUnwindPlan(m_fast_unwind_plan_sp);
if (active_row.get() && log) {
StreamString active_row_strm;
active_row->Dump(active_row_strm, m_fast_unwind_plan_sp.get(), &m_thread,
m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
UnwindLogMsg("Using fast unwind plan '%s'",
m_fast_unwind_plan_sp->GetSourceName().AsCString());
UnwindLogMsg("active row: %s", active_row_strm.GetData());
}
} else {
m_full_unwind_plan_sp = GetFullUnwindPlanForFrame();
if (IsUnwindPlanValidForCurrentPC(m_full_unwind_plan_sp)) {
active_row = m_full_unwind_plan_sp->GetRowForFunctionOffset(
m_current_offset_backed_up_one);
row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
PropagateTrapHandlerFlagFromUnwindPlan(m_full_unwind_plan_sp);
if (active_row.get() && log) {
StreamString active_row_strm;
active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(),
&m_thread,
m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
UnwindLogMsg("Using full unwind plan '%s'",
m_full_unwind_plan_sp->GetSourceName().AsCString());
UnwindLogMsg("active row: %s", active_row_strm.GetData());
}
}
}
if (!active_row.get()) {
m_frame_type = eNotAValidFrame;
UnwindLogMsg("could not find unwind row for this pc");
return;
}
if (!ReadFrameAddress(row_register_kind, active_row->GetCFAValue(), m_cfa)) {
UnwindLogMsg("failed to get cfa");
m_frame_type = eNotAValidFrame;
return;
}
ReadFrameAddress(row_register_kind, active_row->GetAFAValue(), m_afa);
UnwindLogMsg("m_cfa = 0x%" PRIx64 " m_afa = 0x%" PRIx64, m_cfa, m_afa);
if (CheckIfLoopingStack()) {
TryFallbackUnwindPlan();
if (CheckIfLoopingStack()) {
UnwindLogMsg("same CFA address as next frame, assuming the unwind is "
"looping - stopping");
m_frame_type = eNotAValidFrame;
return;
}
}
UnwindLogMsg("initialized frame current pc is 0x%" PRIx64
" cfa is 0x%" PRIx64 " afa is 0x%" PRIx64,
(uint64_t)m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr()),
(uint64_t)m_cfa,
(uint64_t)m_afa);
}
bool RegisterContextUnwind::CheckIfLoopingStack() {
// If we have a bad stack setup, we can get the same CFA value multiple times
// -- or even more devious, we can actually oscillate between two CFA values.
// Detect that here and break out to avoid a possible infinite loop in lldb
// trying to unwind the stack. To detect when we have the same CFA value
// multiple times, we compare the
// CFA of the current
// frame with the 2nd next frame because in some specail case (e.g. signal
// hanlders, hand written assembly without ABI compliance) we can have 2
// frames with the same
// CFA (in theory we
// can have arbitrary number of frames with the same CFA, but more then 2 is
// very very unlikely)
RegisterContextUnwind::SharedPtr next_frame = GetNextFrame();
if (next_frame) {
RegisterContextUnwind::SharedPtr next_next_frame =
next_frame->GetNextFrame();
addr_t next_next_frame_cfa = LLDB_INVALID_ADDRESS;
if (next_next_frame && next_next_frame->GetCFA(next_next_frame_cfa)) {
if (next_next_frame_cfa == m_cfa) {
// We have a loop in the stack unwind
return true;
}
}
}
return false;
}
bool RegisterContextUnwind::IsFrameZero() const { return m_frame_number == 0; }
bool RegisterContextUnwind::BehavesLikeZerothFrame() const {
if (m_frame_number == 0)
return true;
if (m_behaves_like_zeroth_frame)
return true;
return false;
}
// Find a fast unwind plan for this frame, if possible.
//
// On entry to this method,
//
// 1. m_frame_type should already be set to eTrapHandlerFrame/eDebuggerFrame
// if either of those are correct,
// 2. m_sym_ctx should already be filled in, and
// 3. m_current_pc should have the current pc value for this frame
// 4. m_current_offset_backed_up_one should have the current byte offset into
// the function, maybe backed up by 1, -1 if unknown
UnwindPlanSP RegisterContextUnwind::GetFastUnwindPlanForFrame() {
UnwindPlanSP unwind_plan_sp;
ModuleSP pc_module_sp(m_current_pc.GetModule());
if (!m_current_pc.IsValid() || !pc_module_sp ||
pc_module_sp->GetObjectFile() == nullptr)
return unwind_plan_sp;
if (IsFrameZero())
return unwind_plan_sp;
FuncUnwindersSP func_unwinders_sp(
pc_module_sp->GetUnwindTable().GetFuncUnwindersContainingAddress(
m_current_pc, m_sym_ctx));
if (!func_unwinders_sp)
return unwind_plan_sp;
// If we're in _sigtramp(), unwinding past this frame requires special
// knowledge.
if (m_frame_type == eTrapHandlerFrame || m_frame_type == eDebuggerFrame)
return unwind_plan_sp;
unwind_plan_sp = func_unwinders_sp->GetUnwindPlanFastUnwind(
*m_thread.CalculateTarget(), m_thread);
if (unwind_plan_sp) {
if (unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
m_frame_type = eNormalFrame;
return unwind_plan_sp;
} else {
unwind_plan_sp.reset();
}
}
return unwind_plan_sp;
}
// On entry to this method,
//
// 1. m_frame_type should already be set to eTrapHandlerFrame/eDebuggerFrame
// if either of those are correct,
// 2. m_sym_ctx should already be filled in, and
// 3. m_current_pc should have the current pc value for this frame
// 4. m_current_offset_backed_up_one should have the current byte offset into
// the function, maybe backed up by 1, -1 if unknown
UnwindPlanSP RegisterContextUnwind::GetFullUnwindPlanForFrame() {
UnwindPlanSP unwind_plan_sp;
UnwindPlanSP arch_default_unwind_plan_sp;
ExecutionContext exe_ctx(m_thread.shared_from_this());
Process *process = exe_ctx.GetProcessPtr();
ABI *abi = process ? process->GetABI().get() : nullptr;
if (abi) {
arch_default_unwind_plan_sp =
std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
abi->CreateDefaultUnwindPlan(*arch_default_unwind_plan_sp);
} else {
UnwindLogMsg(
"unable to get architectural default UnwindPlan from ABI plugin");
}
if (IsFrameZero() || GetNextFrame()->m_frame_type == eTrapHandlerFrame ||
GetNextFrame()->m_frame_type == eDebuggerFrame) {
m_behaves_like_zeroth_frame = true;
// If this frame behaves like a 0th frame (currently executing or
// interrupted asynchronously), all registers can be retrieved.
m_all_registers_available = true;
}
// If we've done a jmp 0x0 / bl 0x0 (called through a null function pointer)
// so the pc is 0x0 in the zeroth frame, we need to use the "unwind at first
// instruction" arch default UnwindPlan Also, if this Process can report on
// memory region attributes, any non-executable region means we jumped
// through a bad function pointer - handle the same way as 0x0. Note, if we
// have a symbol context & a symbol, we don't want to follow this code path.
// This is for jumping to memory regions without any information available.
if ((!m_sym_ctx_valid ||
(m_sym_ctx.function == nullptr && m_sym_ctx.symbol == nullptr)) &&
m_behaves_like_zeroth_frame && m_current_pc.IsValid()) {
uint32_t permissions;
addr_t current_pc_addr =
m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr());
if (current_pc_addr == 0 ||
(process &&
process->GetLoadAddressPermissions(current_pc_addr, permissions) &&
(permissions & ePermissionsExecutable) == 0)) {
if (abi) {
unwind_plan_sp =
std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
abi->CreateFunctionEntryUnwindPlan(*unwind_plan_sp);
m_frame_type = eNormalFrame;
return unwind_plan_sp;
}
}
}
// No Module for the current pc, try using the architecture default unwind.
ModuleSP pc_module_sp(m_current_pc.GetModule());
if (!m_current_pc.IsValid() || !pc_module_sp ||
pc_module_sp->GetObjectFile() == nullptr) {
m_frame_type = eNormalFrame;
return arch_default_unwind_plan_sp;
}
FuncUnwindersSP func_unwinders_sp;
if (m_sym_ctx_valid) {
func_unwinders_sp =
pc_module_sp->GetUnwindTable().GetFuncUnwindersContainingAddress(
m_current_pc, m_sym_ctx);
}
// No FuncUnwinders available for this pc (stripped function symbols, lldb
// could not augment its function table with another source, like
// LC_FUNCTION_STARTS or eh_frame in ObjectFileMachO). See if eh_frame or the
// .ARM.exidx tables have unwind information for this address, else fall back
// to the architectural default unwind.
if (!func_unwinders_sp) {
m_frame_type = eNormalFrame;
if (!pc_module_sp || !pc_module_sp->GetObjectFile() ||
!m_current_pc.IsValid())
return arch_default_unwind_plan_sp;
// Even with -fomit-frame-pointer, we can try eh_frame to get back on
// track.
DWARFCallFrameInfo *eh_frame =
pc_module_sp->GetUnwindTable().GetEHFrameInfo();
if (eh_frame) {
unwind_plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
if (eh_frame->GetUnwindPlan(m_current_pc, *unwind_plan_sp))
return unwind_plan_sp;
else
unwind_plan_sp.reset();
}
ArmUnwindInfo *arm_exidx =
pc_module_sp->GetUnwindTable().GetArmUnwindInfo();
if (arm_exidx) {
unwind_plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
if (arm_exidx->GetUnwindPlan(exe_ctx.GetTargetRef(), m_current_pc,
*unwind_plan_sp))
return unwind_plan_sp;
else
unwind_plan_sp.reset();
}
CallFrameInfo *object_file_unwind =
pc_module_sp->GetUnwindTable().GetObjectFileUnwindInfo();
if (object_file_unwind) {
unwind_plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
if (object_file_unwind->GetUnwindPlan(m_current_pc, *unwind_plan_sp))
return unwind_plan_sp;
else
unwind_plan_sp.reset();
}
return arch_default_unwind_plan_sp;
}
if (m_frame_type == eTrapHandlerFrame && process) {
m_fast_unwind_plan_sp.reset();
// On some platforms the unwind information for signal handlers is not
// present or correct. Give the platform plugins a chance to provide
// substitute plan. Otherwise, use eh_frame.
if (m_sym_ctx_valid) {
lldb::PlatformSP platform = process->GetTarget().GetPlatform();
unwind_plan_sp = platform->GetTrapHandlerUnwindPlan(
process->GetTarget().GetArchitecture().GetTriple(),
GetSymbolOrFunctionName(m_sym_ctx));
if (unwind_plan_sp)
return unwind_plan_sp;
}
unwind_plan_sp =
func_unwinders_sp->GetEHFrameUnwindPlan(process->GetTarget());
if (!unwind_plan_sp)
unwind_plan_sp =
func_unwinders_sp->GetObjectFileUnwindPlan(process->GetTarget());
if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc) &&
unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolYes) {
return unwind_plan_sp;
}
}
// Ask the DynamicLoader if the eh_frame CFI should be trusted in this frame
// even when it's frame zero This comes up if we have hand-written functions
// in a Module and hand-written eh_frame. The assembly instruction
// inspection may fail and the eh_frame CFI were probably written with some
// care to do the right thing. It'd be nice if there was a way to ask the
// eh_frame directly if it is asynchronous (can be trusted at every
// instruction point) or synchronous (the normal case - only at call sites).
// But there is not.
if (process && process->GetDynamicLoader() &&
process->GetDynamicLoader()->AlwaysRelyOnEHUnwindInfo(m_sym_ctx)) {
// We must specifically call the GetEHFrameUnwindPlan() method here --
// normally we would call GetUnwindPlanAtCallSite() -- because CallSite may
// return an unwind plan sourced from either eh_frame (that's what we
// intend) or compact unwind (this won't work)
unwind_plan_sp =
func_unwinders_sp->GetEHFrameUnwindPlan(process->GetTarget());
if (!unwind_plan_sp)
unwind_plan_sp =
func_unwinders_sp->GetObjectFileUnwindPlan(process->GetTarget());
if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
UnwindLogMsgVerbose("frame uses %s for full UnwindPlan because the "
"DynamicLoader suggested we prefer it",
unwind_plan_sp->GetSourceName().GetCString());
return unwind_plan_sp;
}
}
// Typically the NonCallSite UnwindPlan is the unwind created by inspecting
// the assembly language instructions
if (m_behaves_like_zeroth_frame && process) {
unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite(
process->GetTarget(), m_thread);
if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
if (unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolNo) {
// We probably have an UnwindPlan created by inspecting assembly
// instructions. The assembly profilers work really well with compiler-
// generated functions but hand- written assembly can be problematic.
// We set the eh_frame based unwind plan as our fallback unwind plan if
// instruction emulation doesn't work out even for non call sites if it
// is available and use the architecture default unwind plan if it is
// not available. The eh_frame unwind plan is more reliable even on non
// call sites then the architecture default plan and for hand written
// assembly code it is often written in a way that it valid at all
// location what helps in the most common cases when the instruction
// emulation fails.
UnwindPlanSP call_site_unwind_plan =
func_unwinders_sp->GetUnwindPlanAtCallSite(process->GetTarget(),
m_thread);
if (call_site_unwind_plan &&
call_site_unwind_plan.get() != unwind_plan_sp.get() &&
call_site_unwind_plan->GetSourceName() !=
unwind_plan_sp->GetSourceName()) {
m_fallback_unwind_plan_sp = call_site_unwind_plan;
} else {
m_fallback_unwind_plan_sp = arch_default_unwind_plan_sp;
}
}
UnwindLogMsgVerbose("frame uses %s for full UnwindPlan because this "
"is the non-call site unwind plan and this is a "
"zeroth frame",
unwind_plan_sp->GetSourceName().GetCString());
return unwind_plan_sp;
}
// If we're on the first instruction of a function, and we have an
// architectural default UnwindPlan for the initial instruction of a
// function, use that.
if (m_current_offset == 0) {
unwind_plan_sp =
func_unwinders_sp->GetUnwindPlanArchitectureDefaultAtFunctionEntry(
m_thread);
if (unwind_plan_sp) {
UnwindLogMsgVerbose("frame uses %s for full UnwindPlan because we are at "
"the first instruction of a function",
unwind_plan_sp->GetSourceName().GetCString());
return unwind_plan_sp;
}
}
}
// Typically this is unwind info from an eh_frame section intended for
// exception handling; only valid at call sites
if (process) {
unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtCallSite(
process->GetTarget(), m_thread);
}
if (IsUnwindPlanValidForCurrentPC(unwind_plan_sp)) {
UnwindLogMsgVerbose("frame uses %s for full UnwindPlan because this "
"is the call-site unwind plan",
unwind_plan_sp->GetSourceName().GetCString());
return unwind_plan_sp;
}
// We'd prefer to use an UnwindPlan intended for call sites when we're at a
// call site but if we've struck out on that, fall back to using the non-
// call-site assembly inspection UnwindPlan if possible.
if (process) {
unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite(
process->GetTarget(), m_thread);
}
if (unwind_plan_sp &&
unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolNo) {
// We probably have an UnwindPlan created by inspecting assembly
// instructions. The assembly profilers work really well with compiler-
// generated functions but hand- written assembly can be problematic. We
// set the eh_frame based unwind plan as our fallback unwind plan if
// instruction emulation doesn't work out even for non call sites if it is
// available and use the architecture default unwind plan if it is not
// available. The eh_frame unwind plan is more reliable even on non call
// sites then the architecture default plan and for hand written assembly
// code it is often written in a way that it valid at all location what
// helps in the most common cases when the instruction emulation fails.
UnwindPlanSP call_site_unwind_plan =
func_unwinders_sp->GetUnwindPlanAtCallSite(process->GetTarget(),
m_thread);
if (call_site_unwind_plan &&
call_site_unwind_plan.get() != unwind_plan_sp.get() &&
call_site_unwind_plan->GetSourceName() !=
unwind_plan_sp->GetSourceName()) {
m_fallback_unwind_plan_sp = call_site_unwind_plan;
} else {
m_fallback_unwind_plan_sp = arch_default_unwind_plan_sp;
}
}
if (IsUnwindPlanValidForCurrentPC(unwind_plan_sp)) {
UnwindLogMsgVerbose("frame uses %s for full UnwindPlan because we "
"failed to find a call-site unwind plan that would work",
unwind_plan_sp->GetSourceName().GetCString());
return unwind_plan_sp;
}
// If nothing else, use the architectural default UnwindPlan and hope that
// does the job.
if (arch_default_unwind_plan_sp)
UnwindLogMsgVerbose(
"frame uses %s for full UnwindPlan because we are falling back "
"to the arch default plan",
arch_default_unwind_plan_sp->GetSourceName().GetCString());
else
UnwindLogMsg(
"Unable to find any UnwindPlan for full unwind of this frame.");
return arch_default_unwind_plan_sp;
}
void RegisterContextUnwind::InvalidateAllRegisters() {
m_frame_type = eNotAValidFrame;
}
size_t RegisterContextUnwind::GetRegisterCount() {
return m_thread.GetRegisterContext()->GetRegisterCount();
}
const RegisterInfo *RegisterContextUnwind::GetRegisterInfoAtIndex(size_t reg) {
return m_thread.GetRegisterContext()->GetRegisterInfoAtIndex(reg);
}
size_t RegisterContextUnwind::GetRegisterSetCount() {
return m_thread.GetRegisterContext()->GetRegisterSetCount();
}
const RegisterSet *RegisterContextUnwind::GetRegisterSet(size_t reg_set) {
return m_thread.GetRegisterContext()->GetRegisterSet(reg_set);
}
uint32_t RegisterContextUnwind::ConvertRegisterKindToRegisterNumber(
lldb::RegisterKind kind, uint32_t num) {
return m_thread.GetRegisterContext()->ConvertRegisterKindToRegisterNumber(
kind, num);
}
bool RegisterContextUnwind::ReadRegisterValueFromRegisterLocation(
lldb_private::UnwindLLDB::RegisterLocation regloc,
const RegisterInfo *reg_info, RegisterValue &value) {
if (!IsValid())
return false;
bool success = false;
switch (regloc.type) {
case UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext: {
const RegisterInfo *other_reg_info =
GetRegisterInfoAtIndex(regloc.location.register_number);
if (!other_reg_info)
return false;
success =
m_thread.GetRegisterContext()->ReadRegister(other_reg_info, value);
} break;
case UnwindLLDB::RegisterLocation::eRegisterInRegister: {
const RegisterInfo *other_reg_info =
GetRegisterInfoAtIndex(regloc.location.register_number);
if (!other_reg_info)
return false;
if (IsFrameZero()) {
success =
m_thread.GetRegisterContext()->ReadRegister(other_reg_info, value);
} else {
success = GetNextFrame()->ReadRegister(other_reg_info, value);
}
} break;
case UnwindLLDB::RegisterLocation::eRegisterValueInferred:
success =
value.SetUInt(regloc.location.inferred_value, reg_info->byte_size);
break;
case UnwindLLDB::RegisterLocation::eRegisterNotSaved:
break;
case UnwindLLDB::RegisterLocation::eRegisterSavedAtHostMemoryLocation:
llvm_unreachable("FIXME debugger inferior function call unwind");
case UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation: {
Status error(ReadRegisterValueFromMemory(
reg_info, regloc.location.target_memory_location, reg_info->byte_size,
value));
success = error.Success();
} break;
default:
llvm_unreachable("Unknown RegisterLocation type.");
}
return success;
}
bool RegisterContextUnwind::WriteRegisterValueToRegisterLocation(
lldb_private::UnwindLLDB::RegisterLocation regloc,
const RegisterInfo *reg_info, const RegisterValue &value) {
if (!IsValid())
return false;
bool success = false;
switch (regloc.type) {
case UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext: {
const RegisterInfo *other_reg_info =
GetRegisterInfoAtIndex(regloc.location.register_number);
success =
m_thread.GetRegisterContext()->WriteRegister(other_reg_info, value);
} break;
case UnwindLLDB::RegisterLocation::eRegisterInRegister: {
const RegisterInfo *other_reg_info =
GetRegisterInfoAtIndex(regloc.location.register_number);
if (IsFrameZero()) {
success =
m_thread.GetRegisterContext()->WriteRegister(other_reg_info, value);
} else {
success = GetNextFrame()->WriteRegister(other_reg_info, value);
}
} break;
case UnwindLLDB::RegisterLocation::eRegisterValueInferred:
case UnwindLLDB::RegisterLocation::eRegisterNotSaved:
break;
case UnwindLLDB::RegisterLocation::eRegisterSavedAtHostMemoryLocation:
llvm_unreachable("FIXME debugger inferior function call unwind");
case UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation: {
Status error(WriteRegisterValueToMemory(
reg_info, regloc.location.target_memory_location, reg_info->byte_size,
value));
success = error.Success();
} break;
default:
llvm_unreachable("Unknown RegisterLocation type.");
}
return success;
}
bool RegisterContextUnwind::IsValid() const {
return m_frame_type != eNotAValidFrame;
}
// After the final stack frame in a stack walk we'll get one invalid
// (eNotAValidFrame) stack frame -- one past the end of the stack walk. But
// higher-level code will need to tell the difference between "the unwind plan
// below this frame failed" versus "we successfully completed the stack walk"
// so this method helps to disambiguate that.
bool RegisterContextUnwind::IsTrapHandlerFrame() const {
return m_frame_type == eTrapHandlerFrame;
}
// A skip frame is a bogus frame on the stack -- but one where we're likely to
// find a real frame farther
// up the stack if we keep looking. It's always the second frame in an unwind
// (i.e. the first frame after frame zero) where unwinding can be the
// trickiest. Ideally we'll mark up this frame in some way so the user knows
// we're displaying bad data and we may have skipped one frame of their real
// program in the process of getting back on track.
bool RegisterContextUnwind::IsSkipFrame() const {
return m_frame_type == eSkipFrame;
}
bool RegisterContextUnwind::IsTrapHandlerSymbol(
lldb_private::Process *process,
const lldb_private::SymbolContext &m_sym_ctx) const {
PlatformSP platform_sp(process->GetTarget().GetPlatform());
if (platform_sp) {
const std::vector<ConstString> trap_handler_names(
platform_sp->GetTrapHandlerSymbolNames());
for (ConstString name : trap_handler_names) {
if ((m_sym_ctx.function && m_sym_ctx.function->GetName() == name) ||
(m_sym_ctx.symbol && m_sym_ctx.symbol->GetName() == name)) {
return true;
}
}
}
const std::vector<ConstString> user_specified_trap_handler_names(
m_parent_unwind.GetUserSpecifiedTrapHandlerFunctionNames());
for (ConstString name : user_specified_trap_handler_names) {
if ((m_sym_ctx.function && m_sym_ctx.function->GetName() == name) ||
(m_sym_ctx.symbol && m_sym_ctx.symbol->GetName() == name)) {
return true;
}
}
return false;
}
// Answer the question: Where did THIS frame save the CALLER frame ("previous"
// frame)'s register value?
enum UnwindLLDB::RegisterSearchResult
RegisterContextUnwind::SavedLocationForRegister(
uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation &regloc) {
RegisterNumber regnum(m_thread, eRegisterKindLLDB, lldb_regnum);
Log *log = GetLog(LLDBLog::Unwind);
// Have we already found this register location?
if (!m_registers.empty()) {
std::map<uint32_t,
lldb_private::UnwindLLDB::RegisterLocation>::const_iterator
iterator;
iterator = m_registers.find(regnum.GetAsKind(eRegisterKindLLDB));
if (iterator != m_registers.end()) {
regloc = iterator->second;
UnwindLogMsg("supplying caller's saved %s (%d)'s location, cached",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
return UnwindLLDB::RegisterSearchResult::eRegisterFound;
}
}
// Look through the available UnwindPlans for the register location.
UnwindPlan::Row::RegisterLocation unwindplan_regloc;
bool have_unwindplan_regloc = false;
RegisterKind unwindplan_registerkind = kNumRegisterKinds;
if (m_fast_unwind_plan_sp) {
UnwindPlan::RowSP active_row =
m_fast_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
unwindplan_registerkind = m_fast_unwind_plan_sp->GetRegisterKind();
if (regnum.GetAsKind(unwindplan_registerkind) == LLDB_INVALID_REGNUM) {
UnwindLogMsg("could not convert lldb regnum %s (%d) into %d RegisterKind "
"reg numbering scheme",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
(int)unwindplan_registerkind);
return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
}
// The architecture default unwind plan marks unknown registers as
// Undefined so that we don't forward them up the stack when a
// jitted stack frame may have overwritten them. But when the
// arch default unwind plan is used as the Fast Unwind Plan, we
// need to recognize this & switch over to the Full Unwind Plan
// to see what unwind rule that (more knoweldgeable, probably)
// UnwindPlan has. If the full UnwindPlan says the register
// location is Undefined, then it really is.
if (active_row->GetRegisterInfo(regnum.GetAsKind(unwindplan_registerkind),
unwindplan_regloc) &&
!unwindplan_regloc.IsUndefined()) {
UnwindLogMsg(
"supplying caller's saved %s (%d)'s location using FastUnwindPlan",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
have_unwindplan_regloc = true;
}
}
if (!have_unwindplan_regloc) {
// m_full_unwind_plan_sp being NULL means that we haven't tried to find a
// full UnwindPlan yet
bool got_new_full_unwindplan = false;
if (!m_full_unwind_plan_sp) {
m_full_unwind_plan_sp = GetFullUnwindPlanForFrame();
got_new_full_unwindplan = true;
}
if (m_full_unwind_plan_sp) {
RegisterNumber pc_regnum(m_thread, eRegisterKindGeneric,
LLDB_REGNUM_GENERIC_PC);
UnwindPlan::RowSP active_row =
m_full_unwind_plan_sp->GetRowForFunctionOffset(
m_current_offset_backed_up_one);
unwindplan_registerkind = m_full_unwind_plan_sp->GetRegisterKind();
if (got_new_full_unwindplan && active_row.get() && log) {
StreamString active_row_strm;
ExecutionContext exe_ctx(m_thread.shared_from_this());
active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(),
&m_thread,
m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
UnwindLogMsg("Using full unwind plan '%s'",
m_full_unwind_plan_sp->GetSourceName().AsCString());
UnwindLogMsg("active row: %s", active_row_strm.GetData());
}
RegisterNumber return_address_reg;
// If we're fetching the saved pc and this UnwindPlan defines a
// ReturnAddress register (e.g. lr on arm), look for the return address
// register number in the UnwindPlan's row.
if (pc_regnum.IsValid() && pc_regnum == regnum &&
m_full_unwind_plan_sp->GetReturnAddressRegister() !=
LLDB_INVALID_REGNUM) {
// If this is a trap handler frame, we should have access to
// the complete register context when the interrupt/async
// signal was received, we should fetch the actual saved $pc
// value instead of the Return Address register.
// If $pc is not available, fall back to the RA reg.
UnwindPlan::Row::RegisterLocation scratch;
if (m_frame_type == eTrapHandlerFrame &&
active_row->GetRegisterInfo
(pc_regnum.GetAsKind (unwindplan_registerkind), scratch)) {
UnwindLogMsg("Providing pc register instead of rewriting to "
"RA reg because this is a trap handler and there is "
"a location for the saved pc register value.");
} else {
return_address_reg.init(
m_thread, m_full_unwind_plan_sp->GetRegisterKind(),
m_full_unwind_plan_sp->GetReturnAddressRegister());
regnum = return_address_reg;
UnwindLogMsg("requested caller's saved PC but this UnwindPlan uses a "
"RA reg; getting %s (%d) instead",
return_address_reg.GetName(),
return_address_reg.GetAsKind(eRegisterKindLLDB));
}
} else {
if (regnum.GetAsKind(unwindplan_registerkind) == LLDB_INVALID_REGNUM) {
if (unwindplan_registerkind == eRegisterKindGeneric) {
UnwindLogMsg("could not convert lldb regnum %s (%d) into "
"eRegisterKindGeneric reg numbering scheme",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
} else {
UnwindLogMsg("could not convert lldb regnum %s (%d) into %d "
"RegisterKind reg numbering scheme",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
(int)unwindplan_registerkind);
}
return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
}
}
if (regnum.IsValid() &&
active_row->GetRegisterInfo(regnum.GetAsKind(unwindplan_registerkind),
unwindplan_regloc)) {
have_unwindplan_regloc = true;
UnwindLogMsg(
"supplying caller's saved %s (%d)'s location using %s UnwindPlan",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
m_full_unwind_plan_sp->GetSourceName().GetCString());
}
// This is frame 0 and we're retrieving the PC and it's saved in a Return
// Address register and it hasn't been saved anywhere yet -- that is,
// it's still live in the actual register. Handle this specially.
if (!have_unwindplan_regloc && return_address_reg.IsValid() &&
IsFrameZero()) {
if (return_address_reg.GetAsKind(eRegisterKindLLDB) !=
LLDB_INVALID_REGNUM) {
lldb_private::UnwindLLDB::RegisterLocation new_regloc;
new_regloc.type =
UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext;
new_regloc.location.register_number =
return_address_reg.GetAsKind(eRegisterKindLLDB);
m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = new_regloc;
regloc = new_regloc;
UnwindLogMsg("supplying caller's register %s (%d) from the live "
"RegisterContext at frame 0, saved in %d",
return_address_reg.GetName(),
return_address_reg.GetAsKind(eRegisterKindLLDB),
return_address_reg.GetAsKind(eRegisterKindLLDB));
return UnwindLLDB::RegisterSearchResult::eRegisterFound;
}
}
// If this architecture stores the return address in a register (it
// defines a Return Address register) and we're on a non-zero stack frame
// and the Full UnwindPlan says that the pc is stored in the
// RA registers (e.g. lr on arm), then we know that the full unwindplan is
// not trustworthy -- this
// is an impossible situation and the instruction emulation code has
// likely been misled. If this stack frame meets those criteria, we need
// to throw away the Full UnwindPlan that the instruction emulation came
// up with and fall back to the architecture's Default UnwindPlan so the
// stack walk can get past this point.
// Special note: If the Full UnwindPlan was generated from the compiler,
// don't second-guess it when we're at a call site location.
// arch_default_ra_regnum is the return address register # in the Full
// UnwindPlan register numbering
RegisterNumber arch_default_ra_regnum(m_thread, eRegisterKindGeneric,
LLDB_REGNUM_GENERIC_RA);
if (arch_default_ra_regnum.GetAsKind(unwindplan_registerkind) !=
LLDB_INVALID_REGNUM &&
pc_regnum == regnum && unwindplan_regloc.IsInOtherRegister() &&
unwindplan_regloc.GetRegisterNumber() ==
arch_default_ra_regnum.GetAsKind(unwindplan_registerkind) &&
m_full_unwind_plan_sp->GetSourcedFromCompiler() != eLazyBoolYes &&
!m_all_registers_available) {
UnwindLogMsg("%s UnwindPlan tried to restore the pc from the link "
"register but this is a non-zero frame",
m_full_unwind_plan_sp->GetSourceName().GetCString());
// Throw away the full unwindplan; install the arch default unwindplan
if (ForceSwitchToFallbackUnwindPlan()) {
// Update for the possibly new unwind plan
unwindplan_registerkind = m_full_unwind_plan_sp->GetRegisterKind();
UnwindPlan::RowSP active_row =
m_full_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
// Sanity check: Verify that we can fetch a pc value and CFA value
// with this unwind plan
RegisterNumber arch_default_pc_reg(m_thread, eRegisterKindGeneric,
LLDB_REGNUM_GENERIC_PC);
bool can_fetch_pc_value = false;
bool can_fetch_cfa = false;
addr_t cfa_value;
if (active_row) {
if (arch_default_pc_reg.GetAsKind(unwindplan_registerkind) !=
LLDB_INVALID_REGNUM &&
active_row->GetRegisterInfo(
arch_default_pc_reg.GetAsKind(unwindplan_registerkind),
unwindplan_regloc)) {
can_fetch_pc_value = true;
}
if (ReadFrameAddress(unwindplan_registerkind,
active_row->GetCFAValue(), cfa_value)) {
can_fetch_cfa = true;
}
}
have_unwindplan_regloc = can_fetch_pc_value && can_fetch_cfa;
} else {
// We were unable to fall back to another unwind plan
have_unwindplan_regloc = false;
}
}
}
}
ExecutionContext exe_ctx(m_thread.shared_from_this());
Process *process = exe_ctx.GetProcessPtr();
if (!have_unwindplan_regloc) {
// If the UnwindPlan failed to give us an unwind location for this
// register, we may be able to fall back to some ABI-defined default. For
// example, some ABIs allow to determine the caller's SP via the CFA. Also,
// the ABI may set volatile registers to the undefined state.
ABI *abi = process ? process->GetABI().get() : nullptr;
if (abi) {
const RegisterInfo *reg_info =
GetRegisterInfoAtIndex(regnum.GetAsKind(eRegisterKindLLDB));
if (reg_info &&
abi->GetFallbackRegisterLocation(reg_info, unwindplan_regloc)) {
UnwindLogMsg(
"supplying caller's saved %s (%d)'s location using ABI default",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
have_unwindplan_regloc = true;
}
}
}
if (!have_unwindplan_regloc) {
if (IsFrameZero()) {
// This is frame 0 - we should return the actual live register context
// value
lldb_private::UnwindLLDB::RegisterLocation new_regloc;
new_regloc.type =
UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext;
new_regloc.location.register_number = regnum.GetAsKind(eRegisterKindLLDB);
m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = new_regloc;
regloc = new_regloc;
UnwindLogMsg("supplying caller's register %s (%d) from the live "
"RegisterContext at frame 0",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
return UnwindLLDB::RegisterSearchResult::eRegisterFound;
} else {
std::string unwindplan_name;
if (m_full_unwind_plan_sp) {
unwindplan_name += "via '";
unwindplan_name += m_full_unwind_plan_sp->GetSourceName().AsCString();
unwindplan_name += "'";
}
UnwindLogMsg("no save location for %s (%d) %s", regnum.GetName(),
regnum.GetAsKind(eRegisterKindLLDB),
unwindplan_name.c_str());
}
return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
}
// unwindplan_regloc has valid contents about where to retrieve the register
if (unwindplan_regloc.IsUnspecified()) {
lldb_private::UnwindLLDB::RegisterLocation new_regloc;
new_regloc.type = UnwindLLDB::RegisterLocation::eRegisterNotSaved;
m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = new_regloc;
UnwindLogMsg("save location for %s (%d) is unspecified, continue searching",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
}
if (unwindplan_regloc.IsUndefined()) {
UnwindLogMsg(
"did not supply reg location for %s (%d) because it is volatile",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
return UnwindLLDB::RegisterSearchResult::eRegisterIsVolatile;
}
if (unwindplan_regloc.IsSame()) {
if (!IsFrameZero() &&
(regnum.GetAsKind(eRegisterKindGeneric) == LLDB_REGNUM_GENERIC_PC ||
regnum.GetAsKind(eRegisterKindGeneric) == LLDB_REGNUM_GENERIC_RA)) {
UnwindLogMsg("register %s (%d) is marked as 'IsSame' - it is a pc or "
"return address reg on a non-zero frame -- treat as if we "
"have no information",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
} else {
regloc.type = UnwindLLDB::RegisterLocation::eRegisterInRegister;
regloc.location.register_number = regnum.GetAsKind(eRegisterKindLLDB);
m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
UnwindLogMsg(
"supplying caller's register %s (%d), saved in register %s (%d)",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
return UnwindLLDB::RegisterSearchResult::eRegisterFound;
}
}
if (unwindplan_regloc.IsCFAPlusOffset()) {
int offset = unwindplan_regloc.GetOffset();
regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
regloc.location.inferred_value = m_cfa + offset;
m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
UnwindLogMsg("supplying caller's register %s (%d), value is CFA plus "
"offset %d [value is 0x%" PRIx64 "]",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), offset,
regloc.location.inferred_value);
return UnwindLLDB::RegisterSearchResult::eRegisterFound;
}
if (unwindplan_regloc.IsAtCFAPlusOffset()) {
int offset = unwindplan_regloc.GetOffset();
regloc.type = UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation;
regloc.location.target_memory_location = m_cfa + offset;
m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
UnwindLogMsg("supplying caller's register %s (%d) from the stack, saved at "
"CFA plus offset %d [saved at 0x%" PRIx64 "]",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), offset,
regloc.location.target_memory_location);
return UnwindLLDB::RegisterSearchResult::eRegisterFound;
}
if (unwindplan_regloc.IsAFAPlusOffset()) {
if (m_afa == LLDB_INVALID_ADDRESS)
return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
int offset = unwindplan_regloc.GetOffset();
regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
regloc.location.inferred_value = m_afa + offset;
m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
UnwindLogMsg("supplying caller's register %s (%d), value is AFA plus "
"offset %d [value is 0x%" PRIx64 "]",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), offset,
regloc.location.inferred_value);
return UnwindLLDB::RegisterSearchResult::eRegisterFound;
}
if (unwindplan_regloc.IsAtAFAPlusOffset()) {
if (m_afa == LLDB_INVALID_ADDRESS)
return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
int offset = unwindplan_regloc.GetOffset();
regloc.type = UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation;
regloc.location.target_memory_location = m_afa + offset;
m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
UnwindLogMsg("supplying caller's register %s (%d) from the stack, saved at "
"AFA plus offset %d [saved at 0x%" PRIx64 "]",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), offset,
regloc.location.target_memory_location);
return UnwindLLDB::RegisterSearchResult::eRegisterFound;
}
if (unwindplan_regloc.IsInOtherRegister()) {
uint32_t unwindplan_regnum = unwindplan_regloc.GetRegisterNumber();
RegisterNumber row_regnum(m_thread, unwindplan_registerkind,
unwindplan_regnum);
if (row_regnum.GetAsKind(eRegisterKindLLDB) == LLDB_INVALID_REGNUM) {
UnwindLogMsg("could not supply caller's %s (%d) location - was saved in "
"another reg but couldn't convert that regnum",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
}
regloc.type = UnwindLLDB::RegisterLocation::eRegisterInRegister;
regloc.location.register_number = row_regnum.GetAsKind(eRegisterKindLLDB);
m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
UnwindLogMsg(
"supplying caller's register %s (%d), saved in register %s (%d)",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
row_regnum.GetName(), row_regnum.GetAsKind(eRegisterKindLLDB));
return UnwindLLDB::RegisterSearchResult::eRegisterFound;
}
if (unwindplan_regloc.IsDWARFExpression() ||
unwindplan_regloc.IsAtDWARFExpression()) {
DataExtractor dwarfdata(unwindplan_regloc.GetDWARFExpressionBytes(),
unwindplan_regloc.GetDWARFExpressionLength(),
process->GetByteOrder(),
process->GetAddressByteSize());
ModuleSP opcode_ctx;
DWARFExpressionList dwarfexpr(opcode_ctx, dwarfdata, nullptr);
dwarfexpr.GetMutableExpressionAtAddress()->SetRegisterKind(
unwindplan_registerkind);
Value cfa_val = Scalar(m_cfa);
cfa_val.SetValueType(Value::ValueType::LoadAddress);
Value result;
Status error;
if (dwarfexpr.Evaluate(&exe_ctx, this, 0, &cfa_val, nullptr, result,
&error)) {
addr_t val;
val = result.GetScalar().ULongLong();
if (unwindplan_regloc.IsDWARFExpression()) {
regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
regloc.location.inferred_value = val;
m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
UnwindLogMsg("supplying caller's register %s (%d) via DWARF expression "
"(IsDWARFExpression)",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
return UnwindLLDB::RegisterSearchResult::eRegisterFound;
} else {
regloc.type =
UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation;
regloc.location.target_memory_location = val;
m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
UnwindLogMsg("supplying caller's register %s (%d) via DWARF expression "
"(IsAtDWARFExpression)",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
return UnwindLLDB::RegisterSearchResult::eRegisterFound;
}
}
UnwindLogMsg("tried to use IsDWARFExpression or IsAtDWARFExpression for %s "
"(%d) but failed",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
}
UnwindLogMsg("no save location for %s (%d) in this stack frame",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
// FIXME UnwindPlan::Row types atDWARFExpression and isDWARFExpression are
// unsupported.
return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
}
// TryFallbackUnwindPlan() -- this method is a little tricky.
//
// When this is called, the frame above -- the caller frame, the "previous"
// frame -- is invalid or bad.
//
// Instead of stopping the stack walk here, we'll try a different UnwindPlan
// and see if we can get a valid frame above us.
//
// This most often happens when an unwind plan based on assembly instruction
// inspection is not correct -- mostly with hand-written assembly functions or
// functions where the stack frame is set up "out of band", e.g. the kernel
// saved the register context and then called an asynchronous trap handler like
// _sigtramp.
//
// Often in these cases, if we just do a dumb stack walk we'll get past this
// tricky frame and our usual techniques can continue to be used.
bool RegisterContextUnwind::TryFallbackUnwindPlan() {
if (m_fallback_unwind_plan_sp.get() == nullptr)
return false;
if (m_full_unwind_plan_sp.get() == nullptr)
return false;
if (m_full_unwind_plan_sp.get() == m_fallback_unwind_plan_sp.get() ||
m_full_unwind_plan_sp->GetSourceName() ==
m_fallback_unwind_plan_sp->GetSourceName()) {
return false;
}
// If a compiler generated unwind plan failed, trying the arch default
// unwindplan isn't going to do any better.
if (m_full_unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolYes)
return false;
// Get the caller's pc value and our own CFA value. Swap in the fallback
// unwind plan, re-fetch the caller's pc value and CFA value. If they're the
// same, then the fallback unwind plan provides no benefit.
RegisterNumber pc_regnum(m_thread, eRegisterKindGeneric,
LLDB_REGNUM_GENERIC_PC);
addr_t old_caller_pc_value = LLDB_INVALID_ADDRESS;
addr_t new_caller_pc_value = LLDB_INVALID_ADDRESS;
UnwindLLDB::RegisterLocation regloc;
if (SavedLocationForRegister(pc_regnum.GetAsKind(eRegisterKindLLDB),
regloc) ==
UnwindLLDB::RegisterSearchResult::eRegisterFound) {
const RegisterInfo *reg_info =
GetRegisterInfoAtIndex(pc_regnum.GetAsKind(eRegisterKindLLDB));
if (reg_info) {
RegisterValue reg_value;
if (ReadRegisterValueFromRegisterLocation(regloc, reg_info, reg_value)) {
old_caller_pc_value = reg_value.GetAsUInt64();
if (ProcessSP process_sp = m_thread.GetProcess()) {
if (ABISP abi = process_sp->GetABI())
old_caller_pc_value = abi->FixCodeAddress(old_caller_pc_value);
}
}
}
}
// This is a tricky wrinkle! If SavedLocationForRegister() detects a really
// impossible register location for the full unwind plan, it may call
// ForceSwitchToFallbackUnwindPlan() which in turn replaces the full
// unwindplan with the fallback... in short, we're done, we're using the
// fallback UnwindPlan. We checked if m_fallback_unwind_plan_sp was nullptr
// at the top -- the only way it became nullptr since then is via
// SavedLocationForRegister().
if (m_fallback_unwind_plan_sp.get() == nullptr)
return true;
// Switch the full UnwindPlan to be the fallback UnwindPlan. If we decide
// this isn't working, we need to restore. We'll also need to save & restore
// the value of the m_cfa ivar. Save is down below a bit in 'old_cfa'.
UnwindPlanSP original_full_unwind_plan_sp = m_full_unwind_plan_sp;
addr_t old_cfa = m_cfa;
addr_t old_afa = m_afa;
m_registers.clear();
m_full_unwind_plan_sp = m_fallback_unwind_plan_sp;
UnwindPlan::RowSP active_row =
m_fallback_unwind_plan_sp->GetRowForFunctionOffset(
m_current_offset_backed_up_one);
if (active_row &&
active_row->GetCFAValue().GetValueType() !=
UnwindPlan::Row::FAValue::unspecified) {
addr_t new_cfa;
if (!ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(),
active_row->GetCFAValue(), new_cfa) ||
new_cfa == 0 || new_cfa == 1 || new_cfa == LLDB_INVALID_ADDRESS) {
UnwindLogMsg("failed to get cfa with fallback unwindplan");
m_fallback_unwind_plan_sp.reset();
m_full_unwind_plan_sp = original_full_unwind_plan_sp;
return false;
}
m_cfa = new_cfa;
ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(),
active_row->GetAFAValue(), m_afa);
if (SavedLocationForRegister(pc_regnum.GetAsKind(eRegisterKindLLDB),
regloc) ==
UnwindLLDB::RegisterSearchResult::eRegisterFound) {
const RegisterInfo *reg_info =
GetRegisterInfoAtIndex(pc_regnum.GetAsKind(eRegisterKindLLDB));
if (reg_info) {
RegisterValue reg_value;
if (ReadRegisterValueFromRegisterLocation(regloc, reg_info,
reg_value)) {
new_caller_pc_value = reg_value.GetAsUInt64();
if (ProcessSP process_sp = m_thread.GetProcess()) {
if (ABISP abi = process_sp->GetABI())
new_caller_pc_value = abi->FixCodeAddress(new_caller_pc_value);
}
}
}
}
if (new_caller_pc_value == LLDB_INVALID_ADDRESS) {
UnwindLogMsg("failed to get a pc value for the caller frame with the "
"fallback unwind plan");
m_fallback_unwind_plan_sp.reset();
m_full_unwind_plan_sp = original_full_unwind_plan_sp;
m_cfa = old_cfa;
m_afa = old_afa;
return false;
}
if (old_caller_pc_value == new_caller_pc_value &&
m_cfa == old_cfa &&
m_afa == old_afa) {
UnwindLogMsg("fallback unwind plan got the same values for this frame "
"CFA and caller frame pc, not using");
m_fallback_unwind_plan_sp.reset();
m_full_unwind_plan_sp = original_full_unwind_plan_sp;
return false;
}
UnwindLogMsg("trying to unwind from this function with the UnwindPlan '%s' "
"because UnwindPlan '%s' failed.",
m_fallback_unwind_plan_sp->GetSourceName().GetCString(),
original_full_unwind_plan_sp->GetSourceName().GetCString());
// We've copied the fallback unwind plan into the full - now clear the
// fallback.
m_fallback_unwind_plan_sp.reset();
PropagateTrapHandlerFlagFromUnwindPlan(m_full_unwind_plan_sp);
}
return true;
}
bool RegisterContextUnwind::ForceSwitchToFallbackUnwindPlan() {
if (m_fallback_unwind_plan_sp.get() == nullptr)
return false;
if (m_full_unwind_plan_sp.get() == nullptr)
return false;
if (m_full_unwind_plan_sp.get() == m_fallback_unwind_plan_sp.get() ||
m_full_unwind_plan_sp->GetSourceName() ==
m_fallback_unwind_plan_sp->GetSourceName()) {
return false;
}
UnwindPlan::RowSP active_row =
m_fallback_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
if (active_row &&
active_row->GetCFAValue().GetValueType() !=
UnwindPlan::Row::FAValue::unspecified) {
addr_t new_cfa;
if (!ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(),
active_row->GetCFAValue(), new_cfa) ||
new_cfa == 0 || new_cfa == 1 || new_cfa == LLDB_INVALID_ADDRESS) {
UnwindLogMsg("failed to get cfa with fallback unwindplan");
m_fallback_unwind_plan_sp.reset();
return false;
}
ReadFrameAddress(m_fallback_unwind_plan_sp->GetRegisterKind(),
active_row->GetAFAValue(), m_afa);
m_full_unwind_plan_sp = m_fallback_unwind_plan_sp;
m_fallback_unwind_plan_sp.reset();
m_registers.clear();
m_cfa = new_cfa;
PropagateTrapHandlerFlagFromUnwindPlan(m_full_unwind_plan_sp);
UnwindLogMsg("switched unconditionally to the fallback unwindplan %s",
m_full_unwind_plan_sp->GetSourceName().GetCString());
return true;
}
return false;
}
void RegisterContextUnwind::PropagateTrapHandlerFlagFromUnwindPlan(
lldb::UnwindPlanSP unwind_plan) {
if (unwind_plan->GetUnwindPlanForSignalTrap() != eLazyBoolYes) {
// Unwind plan does not indicate trap handler. Do nothing. We may
// already be flagged as trap handler flag due to the symbol being
// in the trap handler symbol list, and that should take precedence.
return;
} else if (m_frame_type != eNormalFrame) {
// If this is already a trap handler frame, nothing to do.
// If this is a skip or debug or invalid frame, don't override that.
return;
}
m_frame_type = eTrapHandlerFrame;
if (m_current_offset_backed_up_one != m_current_offset) {
// We backed up the pc by 1 to compute the symbol context, but
// now need to undo that because the pc of the trap handler
// frame may in fact be the first instruction of a signal return
// trampoline, rather than the instruction after a call. This
// happens on systems where the signal handler dispatch code, rather
// than calling the handler and being returned to, jumps to the
// handler after pushing the address of a return trampoline on the
// stack -- on these systems, when the handler returns, control will
// be transferred to the return trampoline, so that's the best
// symbol we can present in the callstack.
UnwindLogMsg("Resetting current offset and re-doing symbol lookup; "
"old symbol was %s",
GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
m_current_offset_backed_up_one = m_current_offset;
AddressRange addr_range;
m_sym_ctx_valid = m_current_pc.ResolveFunctionScope(m_sym_ctx, &addr_range);
UnwindLogMsg("Symbol is now %s",
GetSymbolOrFunctionName(m_sym_ctx).AsCString(""));
ExecutionContext exe_ctx(m_thread.shared_from_this());
Process *process = exe_ctx.GetProcessPtr();
Target *target = &process->GetTarget();
m_start_pc = addr_range.GetBaseAddress();
m_current_offset =
m_current_pc.GetLoadAddress(target) - m_start_pc.GetLoadAddress(target);
}
}
bool RegisterContextUnwind::ReadFrameAddress(
lldb::RegisterKind row_register_kind, UnwindPlan::Row::FAValue &fa,
addr_t &address) {
RegisterValue reg_value;
address = LLDB_INVALID_ADDRESS;
addr_t cfa_reg_contents;
switch (fa.GetValueType()) {
case UnwindPlan::Row::FAValue::isRegisterDereferenced: {
RegisterNumber cfa_reg(m_thread, row_register_kind,
fa.GetRegisterNumber());
if (ReadGPRValue(cfa_reg, cfa_reg_contents)) {
const RegisterInfo *reg_info =
GetRegisterInfoAtIndex(cfa_reg.GetAsKind(eRegisterKindLLDB));
RegisterValue reg_value;
if (reg_info) {
Status error = ReadRegisterValueFromMemory(
reg_info, cfa_reg_contents, reg_info->byte_size, reg_value);
if (error.Success()) {
address = reg_value.GetAsUInt64();
if (ABISP abi_sp = m_thread.GetProcess()->GetABI())
address = abi_sp->FixCodeAddress(address);
UnwindLogMsg(
"CFA value via dereferencing reg %s (%d): reg has val 0x%" PRIx64
", CFA value is 0x%" PRIx64,
cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB),
cfa_reg_contents, address);
return true;
} else {
UnwindLogMsg("Tried to deref reg %s (%d) [0x%" PRIx64
"] but memory read failed.",
cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB),
cfa_reg_contents);
}
}
}
break;
}
case UnwindPlan::Row::FAValue::isRegisterPlusOffset: {
RegisterNumber cfa_reg(m_thread, row_register_kind,
fa.GetRegisterNumber());
if (ReadGPRValue(cfa_reg, cfa_reg_contents)) {
if (cfa_reg_contents == LLDB_INVALID_ADDRESS || cfa_reg_contents == 0 ||
cfa_reg_contents == 1) {
UnwindLogMsg(
"Got an invalid CFA register value - reg %s (%d), value 0x%" PRIx64,
cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB),
cfa_reg_contents);
cfa_reg_contents = LLDB_INVALID_ADDRESS;
return false;
}
address = cfa_reg_contents + fa.GetOffset();
UnwindLogMsg(
"CFA is 0x%" PRIx64 ": Register %s (%d) contents are 0x%" PRIx64
", offset is %d",
address, cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB),
cfa_reg_contents, fa.GetOffset());
return true;
}
break;
}
case UnwindPlan::Row::FAValue::isDWARFExpression: {
ExecutionContext exe_ctx(m_thread.shared_from_this());
Process *process = exe_ctx.GetProcessPtr();
DataExtractor dwarfdata(fa.GetDWARFExpressionBytes(),
fa.GetDWARFExpressionLength(),
process->GetByteOrder(),
process->GetAddressByteSize());
ModuleSP opcode_ctx;
DWARFExpressionList dwarfexpr(opcode_ctx, dwarfdata, nullptr);
dwarfexpr.GetMutableExpressionAtAddress()->SetRegisterKind(
row_register_kind);
Value result;
Status error;
if (dwarfexpr.Evaluate(&exe_ctx, this, 0, nullptr, nullptr, result,
&error)) {
address = result.GetScalar().ULongLong();
if (ABISP abi_sp = m_thread.GetProcess()->GetABI())
address = abi_sp->FixCodeAddress(address);
UnwindLogMsg("CFA value set by DWARF expression is 0x%" PRIx64,
address);
return true;
}
UnwindLogMsg("Failed to set CFA value via DWARF expression: %s",
error.AsCString());
break;
}
case UnwindPlan::Row::FAValue::isRaSearch: {
Process &process = *m_thread.GetProcess();
lldb::addr_t return_address_hint = GetReturnAddressHint(fa.GetOffset());
if (return_address_hint == LLDB_INVALID_ADDRESS)
return false;
const unsigned max_iterations = 256;
for (unsigned i = 0; i < max_iterations; ++i) {
Status st;
lldb::addr_t candidate_addr =
return_address_hint + i * process.GetAddressByteSize();
lldb::addr_t candidate =
process.ReadPointerFromMemory(candidate_addr, st);
if (st.Fail()) {
UnwindLogMsg("Cannot read memory at 0x%" PRIx64 ": %s", candidate_addr,
st.AsCString());
return false;
}
Address addr;
uint32_t permissions;
if (process.GetLoadAddressPermissions(candidate, permissions) &&
permissions & lldb::ePermissionsExecutable) {
address = candidate_addr;
UnwindLogMsg("Heuristically found CFA: 0x%" PRIx64, address);
return true;
}
}
UnwindLogMsg("No suitable CFA found");
break;
}
default:
return false;
}
return false;
}
lldb::addr_t RegisterContextUnwind::GetReturnAddressHint(int32_t plan_offset) {
addr_t hint;
if (!ReadGPRValue(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP, hint))
return LLDB_INVALID_ADDRESS;
if (!m_sym_ctx.module_sp || !m_sym_ctx.symbol)
return LLDB_INVALID_ADDRESS;
hint += plan_offset;
if (auto next = GetNextFrame()) {
if (!next->m_sym_ctx.module_sp || !next->m_sym_ctx.symbol)
return LLDB_INVALID_ADDRESS;
if (auto expected_size =
next->m_sym_ctx.module_sp->GetSymbolFile()->GetParameterStackSize(
*next->m_sym_ctx.symbol))
hint += *expected_size;
else {
UnwindLogMsgVerbose("Could not retrieve parameter size: %s",
llvm::toString(expected_size.takeError()).c_str());
return LLDB_INVALID_ADDRESS;
}
}
return hint;
}
// Retrieve a general purpose register value for THIS frame, as saved by the
// NEXT frame, i.e. the frame that
// this frame called. e.g.
//
// foo () { }
// bar () { foo (); }
// main () { bar (); }
//
// stopped in foo() so
// frame 0 - foo
// frame 1 - bar
// frame 2 - main
// and this RegisterContext is for frame 1 (bar) - if we want to get the pc
// value for frame 1, we need to ask
// where frame 0 (the "next" frame) saved that and retrieve the value.
bool RegisterContextUnwind::ReadGPRValue(lldb::RegisterKind register_kind,
uint32_t regnum, addr_t &value) {
if (!IsValid())
return false;
uint32_t lldb_regnum;
if (register_kind == eRegisterKindLLDB) {
lldb_regnum = regnum;
} else if (!m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds(
register_kind, regnum, eRegisterKindLLDB, lldb_regnum)) {
return false;
}
const RegisterInfo *reg_info = GetRegisterInfoAtIndex(lldb_regnum);
RegisterValue reg_value;
// if this is frame 0 (currently executing frame), get the requested reg
// contents from the actual thread registers
if (IsFrameZero()) {
if (m_thread.GetRegisterContext()->ReadRegister(reg_info, reg_value)) {
value = reg_value.GetAsUInt64();
return true;
}
return false;
}
bool pc_register = false;
uint32_t generic_regnum;
if (register_kind == eRegisterKindGeneric &&
(regnum == LLDB_REGNUM_GENERIC_PC || regnum == LLDB_REGNUM_GENERIC_RA)) {
pc_register = true;
} else if (m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds(
register_kind, regnum, eRegisterKindGeneric, generic_regnum) &&
(generic_regnum == LLDB_REGNUM_GENERIC_PC ||
generic_regnum == LLDB_REGNUM_GENERIC_RA)) {
pc_register = true;
}
lldb_private::UnwindLLDB::RegisterLocation regloc;
if (!m_parent_unwind.SearchForSavedLocationForRegister(
lldb_regnum, regloc, m_frame_number - 1, pc_register)) {
return false;
}
if (ReadRegisterValueFromRegisterLocation(regloc, reg_info, reg_value)) {
value = reg_value.GetAsUInt64();
if (pc_register) {
if (ProcessSP process_sp = m_thread.GetProcess()) {
if (ABISP abi = process_sp->GetABI())
value = abi->FixCodeAddress(value);
}
}
return true;
}
return false;
}
bool RegisterContextUnwind::ReadGPRValue(const RegisterNumber &regnum,
addr_t &value) {
return ReadGPRValue(regnum.GetRegisterKind(), regnum.GetRegisterNumber(),
value);
}
// Find the value of a register in THIS frame
bool RegisterContextUnwind::ReadRegister(const RegisterInfo *reg_info,
RegisterValue &value) {
if (!IsValid())
return false;
const uint32_t lldb_regnum = reg_info->kinds[eRegisterKindLLDB];
UnwindLogMsgVerbose("looking for register saved location for reg %d",
lldb_regnum);
// If this is the 0th frame, hand this over to the live register context
if (IsFrameZero()) {
UnwindLogMsgVerbose("passing along to the live register context for reg %d",
lldb_regnum);
return m_thread.GetRegisterContext()->ReadRegister(reg_info, value);
}
bool is_pc_regnum = false;
if (reg_info->kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_PC ||
reg_info->kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_RA) {
is_pc_regnum = true;
}
lldb_private::UnwindLLDB::RegisterLocation regloc;
// Find out where the NEXT frame saved THIS frame's register contents
if (!m_parent_unwind.SearchForSavedLocationForRegister(
lldb_regnum, regloc, m_frame_number - 1, is_pc_regnum))
return false;
bool result = ReadRegisterValueFromRegisterLocation(regloc, reg_info, value);
if (result) {
if (is_pc_regnum && value.GetType() == RegisterValue::eTypeUInt64) {
addr_t reg_value = value.GetAsUInt64(LLDB_INVALID_ADDRESS);
if (reg_value != LLDB_INVALID_ADDRESS) {
if(ProcessSP process_sp = m_thread.GetProcess()) {
if (ABISP abi = process_sp->GetABI())
value = abi->FixCodeAddress(reg_value);
}
}
}
}
return result;
}
bool RegisterContextUnwind::WriteRegister(const RegisterInfo *reg_info,
const RegisterValue &value) {
if (!IsValid())
return false;
const uint32_t lldb_regnum = reg_info->kinds[eRegisterKindLLDB];
UnwindLogMsgVerbose("looking for register saved location for reg %d",
lldb_regnum);
// If this is the 0th frame, hand this over to the live register context
if (IsFrameZero()) {
UnwindLogMsgVerbose("passing along to the live register context for reg %d",
lldb_regnum);
return m_thread.GetRegisterContext()->WriteRegister(reg_info, value);
}
lldb_private::UnwindLLDB::RegisterLocation regloc;
// Find out where the NEXT frame saved THIS frame's register contents
if (!m_parent_unwind.SearchForSavedLocationForRegister(
lldb_regnum, regloc, m_frame_number - 1, false))
return false;
return WriteRegisterValueToRegisterLocation(regloc, reg_info, value);
}
// Don't need to implement this one
bool RegisterContextUnwind::ReadAllRegisterValues(
lldb::WritableDataBufferSP &data_sp) {
return false;
}
// Don't need to implement this one
bool RegisterContextUnwind::WriteAllRegisterValues(
const lldb::DataBufferSP &data_sp) {
return false;
}
// Retrieve the pc value for THIS from
bool RegisterContextUnwind::GetCFA(addr_t &cfa) {
if (!IsValid()) {
return false;
}
if (m_cfa == LLDB_INVALID_ADDRESS) {
return false;
}
cfa = m_cfa;
return true;
}
RegisterContextUnwind::SharedPtr RegisterContextUnwind::GetNextFrame() const {
RegisterContextUnwind::SharedPtr regctx;
if (m_frame_number == 0)
return regctx;
return m_parent_unwind.GetRegisterContextForFrameNum(m_frame_number - 1);
}
RegisterContextUnwind::SharedPtr RegisterContextUnwind::GetPrevFrame() const {
RegisterContextUnwind::SharedPtr regctx;
return m_parent_unwind.GetRegisterContextForFrameNum(m_frame_number + 1);
}
// Retrieve the address of the start of the function of THIS frame
bool RegisterContextUnwind::GetStartPC(addr_t &start_pc) {
if (!IsValid())
return false;
if (!m_start_pc.IsValid()) {
bool read_successfully = ReadPC (start_pc);
if (read_successfully)
{
ProcessSP process_sp (m_thread.GetProcess());
if (process_sp)
{
ABI *abi = process_sp->GetABI().get();
if (abi)
start_pc = abi->FixCodeAddress(start_pc);
}
}
return read_successfully;
}
start_pc = m_start_pc.GetLoadAddress(CalculateTarget().get());
return true;
}
// Retrieve the current pc value for THIS frame, as saved by the NEXT frame.
bool RegisterContextUnwind::ReadPC(addr_t &pc) {
if (!IsValid())
return false;
bool above_trap_handler = false;
if (GetNextFrame().get() && GetNextFrame()->IsValid() &&
GetNextFrame()->IsTrapHandlerFrame())
above_trap_handler = true;
if (ReadGPRValue(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, pc)) {
// A pc value of 0 or 1 is impossible in the middle of the stack -- it
// indicates the end of a stack walk.
// On the currently executing frame (or such a frame interrupted
// asynchronously by sigtramp et al) this may occur if code has jumped
// through a NULL pointer -- we want to be able to unwind past that frame
// to help find the bug.
ProcessSP process_sp (m_thread.GetProcess());
if (process_sp)
{
ABI *abi = process_sp->GetABI().get();
if (abi)
pc = abi->FixCodeAddress(pc);
}
return !(m_all_registers_available == false &&
above_trap_handler == false && (pc == 0 || pc == 1));
} else {
return false;
}
}
void RegisterContextUnwind::UnwindLogMsg(const char *fmt, ...) {
Log *log = GetLog(LLDBLog::Unwind);
if (!log)
return;
va_list args;
va_start(args, fmt);
llvm::SmallString<0> logmsg;
if (VASprintf(logmsg, fmt, args)) {
LLDB_LOGF(log, "%*sth%d/fr%u %s",
m_frame_number < 100 ? m_frame_number : 100, "",
m_thread.GetIndexID(), m_frame_number, logmsg.c_str());
}
va_end(args);
}
void RegisterContextUnwind::UnwindLogMsgVerbose(const char *fmt, ...) {
Log *log = GetLog(LLDBLog::Unwind);
if (!log || !log->GetVerbose())
return;
va_list args;
va_start(args, fmt);
llvm::SmallString<0> logmsg;
if (VASprintf(logmsg, fmt, args)) {
LLDB_LOGF(log, "%*sth%d/fr%u %s",
m_frame_number < 100 ? m_frame_number : 100, "",
m_thread.GetIndexID(), m_frame_number, logmsg.c_str());
}
va_end(args);
}
Reference in New Issue View Git Blame Copy Permalink