3336d73126
lldb has two RegisterLocation classes that do slightly different things. UnwindPlan::Row::RegisterLocation (new: AbstractRegisterLocation) has a description of how to find a register's value or location, not specific to a particular stopping point. It may say that at a given offset into a function, the caller's register has been spilled to stack memory at CFA minus an offset. Or it may say that the caller's register is at a DWARF exprssion. UnwindLLDB::RegisterLocation (new: ConcreteRegisterLocation) is a specific address where the register is currently stored, or the register it has been copied into, or its value at this point in the current function execution. When lldb stops in a function, it interprets the AbstractRegisterLocation's instructions using the register context and stack memory, to create the ConcreteRegisterLocation at this point in time for this stack frame. I'm not thrilled with AbstractRegisterLocation and ConcreteRegisterLocation, but it's better than the same name and it will be easier to update them if someone suggests a better pair.
573 lines
22 KiB
C++
573 lines
22 KiB
C++
//===-- FuncUnwinders.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/Symbol/FuncUnwinders.h"
|
|
#include "lldb/Core/Address.h"
|
|
#include "lldb/Core/AddressRange.h"
|
|
#include "lldb/Symbol/ArmUnwindInfo.h"
|
|
#include "lldb/Symbol/CallFrameInfo.h"
|
|
#include "lldb/Symbol/CompactUnwindInfo.h"
|
|
#include "lldb/Symbol/DWARFCallFrameInfo.h"
|
|
#include "lldb/Symbol/ObjectFile.h"
|
|
#include "lldb/Symbol/SymbolFile.h"
|
|
#include "lldb/Symbol/UnwindPlan.h"
|
|
#include "lldb/Symbol/UnwindTable.h"
|
|
#include "lldb/Target/ABI.h"
|
|
#include "lldb/Target/ExecutionContext.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/RegisterContext.h"
|
|
#include "lldb/Target/RegisterNumber.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Target/Thread.h"
|
|
#include "lldb/Target/UnwindAssembly.h"
|
|
|
|
#include <memory>
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
/// constructor
|
|
|
|
FuncUnwinders::FuncUnwinders(UnwindTable &unwind_table, AddressRange range)
|
|
: m_unwind_table(unwind_table), m_range(range), m_mutex(),
|
|
m_unwind_plan_assembly_sp(), m_unwind_plan_eh_frame_sp(),
|
|
m_unwind_plan_eh_frame_augmented_sp(), m_unwind_plan_compact_unwind(),
|
|
m_unwind_plan_arm_unwind_sp(), m_unwind_plan_fast_sp(),
|
|
m_unwind_plan_arch_default_sp(),
|
|
m_unwind_plan_arch_default_at_func_entry_sp(),
|
|
m_tried_unwind_plan_assembly(false), m_tried_unwind_plan_eh_frame(false),
|
|
m_tried_unwind_plan_object_file(false),
|
|
m_tried_unwind_plan_debug_frame(false),
|
|
m_tried_unwind_plan_object_file_augmented(false),
|
|
m_tried_unwind_plan_eh_frame_augmented(false),
|
|
m_tried_unwind_plan_debug_frame_augmented(false),
|
|
m_tried_unwind_plan_compact_unwind(false),
|
|
m_tried_unwind_plan_arm_unwind(false),
|
|
m_tried_unwind_plan_symbol_file(false), m_tried_unwind_fast(false),
|
|
m_tried_unwind_arch_default(false),
|
|
m_tried_unwind_arch_default_at_func_entry(false),
|
|
m_first_non_prologue_insn() {}
|
|
|
|
/// destructor
|
|
|
|
FuncUnwinders::~FuncUnwinders() = default;
|
|
|
|
UnwindPlanSP FuncUnwinders::GetUnwindPlanAtCallSite(Target &target,
|
|
Thread &thread) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
|
|
if (UnwindPlanSP plan_sp = GetObjectFileUnwindPlan(target))
|
|
return plan_sp;
|
|
if (UnwindPlanSP plan_sp = GetSymbolFileUnwindPlan(thread))
|
|
return plan_sp;
|
|
if (UnwindPlanSP plan_sp = GetDebugFrameUnwindPlan(target))
|
|
return plan_sp;
|
|
if (UnwindPlanSP plan_sp = GetEHFrameUnwindPlan(target))
|
|
return plan_sp;
|
|
if (UnwindPlanSP plan_sp = GetCompactUnwindUnwindPlan(target))
|
|
return plan_sp;
|
|
if (UnwindPlanSP plan_sp = GetArmUnwindUnwindPlan(target))
|
|
return plan_sp;
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
UnwindPlanSP FuncUnwinders::GetCompactUnwindUnwindPlan(Target &target) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
if (m_unwind_plan_compact_unwind.size() > 0)
|
|
return m_unwind_plan_compact_unwind[0]; // FIXME support multiple compact
|
|
// unwind plans for one func
|
|
if (m_tried_unwind_plan_compact_unwind)
|
|
return UnwindPlanSP();
|
|
|
|
m_tried_unwind_plan_compact_unwind = true;
|
|
if (m_range.GetBaseAddress().IsValid()) {
|
|
Address current_pc(m_range.GetBaseAddress());
|
|
CompactUnwindInfo *compact_unwind = m_unwind_table.GetCompactUnwindInfo();
|
|
if (compact_unwind) {
|
|
UnwindPlanSP unwind_plan_sp(new UnwindPlan(lldb::eRegisterKindGeneric));
|
|
if (compact_unwind->GetUnwindPlan(target, current_pc, *unwind_plan_sp)) {
|
|
m_unwind_plan_compact_unwind.push_back(unwind_plan_sp);
|
|
return m_unwind_plan_compact_unwind[0]; // FIXME support multiple
|
|
// compact unwind plans for one
|
|
// func
|
|
}
|
|
}
|
|
}
|
|
return UnwindPlanSP();
|
|
}
|
|
|
|
lldb::UnwindPlanSP FuncUnwinders::GetObjectFileUnwindPlan(Target &target) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
if (m_unwind_plan_object_file_sp.get() ||
|
|
m_tried_unwind_plan_object_file)
|
|
return m_unwind_plan_object_file_sp;
|
|
|
|
m_tried_unwind_plan_object_file = true;
|
|
if (m_range.GetBaseAddress().IsValid()) {
|
|
CallFrameInfo *object_file_frame = m_unwind_table.GetObjectFileUnwindInfo();
|
|
if (object_file_frame) {
|
|
m_unwind_plan_object_file_sp =
|
|
std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
|
|
if (!object_file_frame->GetUnwindPlan(m_range,
|
|
*m_unwind_plan_object_file_sp))
|
|
m_unwind_plan_object_file_sp.reset();
|
|
}
|
|
}
|
|
return m_unwind_plan_object_file_sp;
|
|
}
|
|
|
|
UnwindPlanSP FuncUnwinders::GetEHFrameUnwindPlan(Target &target) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
if (m_unwind_plan_eh_frame_sp.get() || m_tried_unwind_plan_eh_frame)
|
|
return m_unwind_plan_eh_frame_sp;
|
|
|
|
m_tried_unwind_plan_eh_frame = true;
|
|
if (m_range.GetBaseAddress().IsValid()) {
|
|
DWARFCallFrameInfo *eh_frame = m_unwind_table.GetEHFrameInfo();
|
|
if (eh_frame) {
|
|
m_unwind_plan_eh_frame_sp =
|
|
std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
|
|
if (!eh_frame->GetUnwindPlan(m_range, *m_unwind_plan_eh_frame_sp))
|
|
m_unwind_plan_eh_frame_sp.reset();
|
|
}
|
|
}
|
|
return m_unwind_plan_eh_frame_sp;
|
|
}
|
|
|
|
UnwindPlanSP FuncUnwinders::GetDebugFrameUnwindPlan(Target &target) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
if (m_unwind_plan_debug_frame_sp || m_tried_unwind_plan_debug_frame)
|
|
return m_unwind_plan_debug_frame_sp;
|
|
|
|
m_tried_unwind_plan_debug_frame = true;
|
|
if (m_range.GetBaseAddress().IsValid()) {
|
|
DWARFCallFrameInfo *debug_frame = m_unwind_table.GetDebugFrameInfo();
|
|
if (debug_frame) {
|
|
m_unwind_plan_debug_frame_sp =
|
|
std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
|
|
if (!debug_frame->GetUnwindPlan(m_range, *m_unwind_plan_debug_frame_sp))
|
|
m_unwind_plan_debug_frame_sp.reset();
|
|
}
|
|
}
|
|
return m_unwind_plan_debug_frame_sp;
|
|
}
|
|
|
|
UnwindPlanSP FuncUnwinders::GetArmUnwindUnwindPlan(Target &target) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
if (m_unwind_plan_arm_unwind_sp.get() || m_tried_unwind_plan_arm_unwind)
|
|
return m_unwind_plan_arm_unwind_sp;
|
|
|
|
m_tried_unwind_plan_arm_unwind = true;
|
|
if (m_range.GetBaseAddress().IsValid()) {
|
|
Address current_pc(m_range.GetBaseAddress());
|
|
ArmUnwindInfo *arm_unwind_info = m_unwind_table.GetArmUnwindInfo();
|
|
if (arm_unwind_info) {
|
|
m_unwind_plan_arm_unwind_sp =
|
|
std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
|
|
if (!arm_unwind_info->GetUnwindPlan(target, current_pc,
|
|
*m_unwind_plan_arm_unwind_sp))
|
|
m_unwind_plan_arm_unwind_sp.reset();
|
|
}
|
|
}
|
|
return m_unwind_plan_arm_unwind_sp;
|
|
}
|
|
|
|
namespace {
|
|
class RegisterContextToInfo: public SymbolFile::RegisterInfoResolver {
|
|
public:
|
|
RegisterContextToInfo(RegisterContext &ctx) : m_ctx(ctx) {}
|
|
|
|
const RegisterInfo *ResolveName(llvm::StringRef name) const override {
|
|
return m_ctx.GetRegisterInfoByName(name);
|
|
}
|
|
const RegisterInfo *ResolveNumber(lldb::RegisterKind kind,
|
|
uint32_t number) const override {
|
|
return m_ctx.GetRegisterInfo(kind, number);
|
|
}
|
|
|
|
private:
|
|
RegisterContext &m_ctx;
|
|
};
|
|
} // namespace
|
|
|
|
UnwindPlanSP FuncUnwinders::GetSymbolFileUnwindPlan(Thread &thread) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
if (m_unwind_plan_symbol_file_sp.get() || m_tried_unwind_plan_symbol_file)
|
|
return m_unwind_plan_symbol_file_sp;
|
|
|
|
m_tried_unwind_plan_symbol_file = true;
|
|
if (SymbolFile *symfile = m_unwind_table.GetSymbolFile()) {
|
|
m_unwind_plan_symbol_file_sp = symfile->GetUnwindPlan(
|
|
m_range.GetBaseAddress(),
|
|
RegisterContextToInfo(*thread.GetRegisterContext()));
|
|
}
|
|
return m_unwind_plan_symbol_file_sp;
|
|
}
|
|
|
|
UnwindPlanSP
|
|
FuncUnwinders::GetObjectFileAugmentedUnwindPlan(Target &target,
|
|
Thread &thread) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
if (m_unwind_plan_object_file_augmented_sp.get() ||
|
|
m_tried_unwind_plan_object_file_augmented)
|
|
return m_unwind_plan_object_file_augmented_sp;
|
|
|
|
m_tried_unwind_plan_object_file_augmented = true;
|
|
|
|
UnwindPlanSP object_file_unwind_plan = GetObjectFileUnwindPlan(target);
|
|
if (!object_file_unwind_plan)
|
|
return m_unwind_plan_object_file_augmented_sp;
|
|
|
|
m_unwind_plan_object_file_augmented_sp =
|
|
std::make_shared<UnwindPlan>(*object_file_unwind_plan);
|
|
|
|
// Augment the instructions with epilogue descriptions if necessary
|
|
// so the UnwindPlan can be used at any instruction in the function.
|
|
|
|
UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
|
|
if (assembly_profiler_sp) {
|
|
if (!assembly_profiler_sp->AugmentUnwindPlanFromCallSite(
|
|
m_range, thread, *m_unwind_plan_object_file_augmented_sp)) {
|
|
m_unwind_plan_object_file_augmented_sp.reset();
|
|
}
|
|
} else {
|
|
m_unwind_plan_object_file_augmented_sp.reset();
|
|
}
|
|
return m_unwind_plan_object_file_augmented_sp;
|
|
}
|
|
|
|
UnwindPlanSP FuncUnwinders::GetEHFrameAugmentedUnwindPlan(Target &target,
|
|
Thread &thread) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
if (m_unwind_plan_eh_frame_augmented_sp.get() ||
|
|
m_tried_unwind_plan_eh_frame_augmented)
|
|
return m_unwind_plan_eh_frame_augmented_sp;
|
|
|
|
// Only supported on x86 architectures where we get eh_frame from the
|
|
// compiler that describes the prologue instructions perfectly, and sometimes
|
|
// the epilogue instructions too.
|
|
if (target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_32_i386 &&
|
|
target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_64_x86_64 &&
|
|
target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_64_x86_64h) {
|
|
m_tried_unwind_plan_eh_frame_augmented = true;
|
|
return m_unwind_plan_eh_frame_augmented_sp;
|
|
}
|
|
|
|
m_tried_unwind_plan_eh_frame_augmented = true;
|
|
|
|
UnwindPlanSP eh_frame_plan = GetEHFrameUnwindPlan(target);
|
|
if (!eh_frame_plan)
|
|
return m_unwind_plan_eh_frame_augmented_sp;
|
|
|
|
m_unwind_plan_eh_frame_augmented_sp =
|
|
std::make_shared<UnwindPlan>(*eh_frame_plan);
|
|
|
|
// Augment the eh_frame instructions with epilogue descriptions if necessary
|
|
// so the UnwindPlan can be used at any instruction in the function.
|
|
|
|
UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
|
|
if (assembly_profiler_sp) {
|
|
if (!assembly_profiler_sp->AugmentUnwindPlanFromCallSite(
|
|
m_range, thread, *m_unwind_plan_eh_frame_augmented_sp)) {
|
|
m_unwind_plan_eh_frame_augmented_sp.reset();
|
|
}
|
|
} else {
|
|
m_unwind_plan_eh_frame_augmented_sp.reset();
|
|
}
|
|
return m_unwind_plan_eh_frame_augmented_sp;
|
|
}
|
|
|
|
UnwindPlanSP FuncUnwinders::GetDebugFrameAugmentedUnwindPlan(Target &target,
|
|
Thread &thread) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
if (m_unwind_plan_debug_frame_augmented_sp.get() ||
|
|
m_tried_unwind_plan_debug_frame_augmented)
|
|
return m_unwind_plan_debug_frame_augmented_sp;
|
|
|
|
// Only supported on x86 architectures where we get debug_frame from the
|
|
// compiler that describes the prologue instructions perfectly, and sometimes
|
|
// the epilogue instructions too.
|
|
if (target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_32_i386 &&
|
|
target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_64_x86_64 &&
|
|
target.GetArchitecture().GetCore() != ArchSpec::eCore_x86_64_x86_64h) {
|
|
m_tried_unwind_plan_debug_frame_augmented = true;
|
|
return m_unwind_plan_debug_frame_augmented_sp;
|
|
}
|
|
|
|
m_tried_unwind_plan_debug_frame_augmented = true;
|
|
|
|
UnwindPlanSP debug_frame_plan = GetDebugFrameUnwindPlan(target);
|
|
if (!debug_frame_plan)
|
|
return m_unwind_plan_debug_frame_augmented_sp;
|
|
|
|
m_unwind_plan_debug_frame_augmented_sp =
|
|
std::make_shared<UnwindPlan>(*debug_frame_plan);
|
|
|
|
// Augment the debug_frame instructions with epilogue descriptions if
|
|
// necessary so the UnwindPlan can be used at any instruction in the
|
|
// function.
|
|
|
|
UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
|
|
if (assembly_profiler_sp) {
|
|
if (!assembly_profiler_sp->AugmentUnwindPlanFromCallSite(
|
|
m_range, thread, *m_unwind_plan_debug_frame_augmented_sp)) {
|
|
m_unwind_plan_debug_frame_augmented_sp.reset();
|
|
}
|
|
} else
|
|
m_unwind_plan_debug_frame_augmented_sp.reset();
|
|
return m_unwind_plan_debug_frame_augmented_sp;
|
|
}
|
|
|
|
UnwindPlanSP FuncUnwinders::GetAssemblyUnwindPlan(Target &target,
|
|
Thread &thread) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
if (m_unwind_plan_assembly_sp.get() || m_tried_unwind_plan_assembly ||
|
|
!m_unwind_table.GetAllowAssemblyEmulationUnwindPlans()) {
|
|
return m_unwind_plan_assembly_sp;
|
|
}
|
|
|
|
m_tried_unwind_plan_assembly = true;
|
|
|
|
// Don't analyze more than 10 megabytes of instructions,
|
|
// if a function is legitimately larger than that, we'll
|
|
// miss the epilogue instructions, but guard against a
|
|
// bogusly large function and analyzing large amounts of
|
|
// non-instruction data.
|
|
AddressRange range = m_range;
|
|
const addr_t func_size =
|
|
std::min(range.GetByteSize(), (addr_t)1024 * 10 * 10);
|
|
range.SetByteSize(func_size);
|
|
|
|
UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
|
|
if (assembly_profiler_sp) {
|
|
m_unwind_plan_assembly_sp =
|
|
std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
|
|
if (!assembly_profiler_sp->GetNonCallSiteUnwindPlanFromAssembly(
|
|
range, thread, *m_unwind_plan_assembly_sp)) {
|
|
m_unwind_plan_assembly_sp.reset();
|
|
}
|
|
}
|
|
return m_unwind_plan_assembly_sp;
|
|
}
|
|
|
|
// This method compares the pc unwind rule in the first row of two UnwindPlans.
|
|
// If they have the same way of getting the pc value (e.g. "CFA - 8" + "CFA is
|
|
// sp"), then it will return LazyBoolTrue.
|
|
LazyBool FuncUnwinders::CompareUnwindPlansForIdenticalInitialPCLocation(
|
|
Thread &thread, const UnwindPlanSP &a, const UnwindPlanSP &b) {
|
|
LazyBool plans_are_identical = eLazyBoolCalculate;
|
|
|
|
RegisterNumber pc_reg(thread, eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
|
|
uint32_t pc_reg_lldb_regnum = pc_reg.GetAsKind(eRegisterKindLLDB);
|
|
|
|
if (a.get() && b.get()) {
|
|
UnwindPlan::RowSP a_first_row = a->GetRowAtIndex(0);
|
|
UnwindPlan::RowSP b_first_row = b->GetRowAtIndex(0);
|
|
|
|
if (a_first_row.get() && b_first_row.get()) {
|
|
UnwindPlan::Row::AbstractRegisterLocation a_pc_regloc;
|
|
UnwindPlan::Row::AbstractRegisterLocation b_pc_regloc;
|
|
|
|
a_first_row->GetRegisterInfo(pc_reg_lldb_regnum, a_pc_regloc);
|
|
b_first_row->GetRegisterInfo(pc_reg_lldb_regnum, b_pc_regloc);
|
|
|
|
plans_are_identical = eLazyBoolYes;
|
|
|
|
if (a_first_row->GetCFAValue() != b_first_row->GetCFAValue()) {
|
|
plans_are_identical = eLazyBoolNo;
|
|
}
|
|
if (a_pc_regloc != b_pc_regloc) {
|
|
plans_are_identical = eLazyBoolNo;
|
|
}
|
|
}
|
|
}
|
|
return plans_are_identical;
|
|
}
|
|
|
|
UnwindPlanSP FuncUnwinders::GetUnwindPlanAtNonCallSite(Target &target,
|
|
Thread &thread) {
|
|
UnwindPlanSP eh_frame_sp = GetEHFrameUnwindPlan(target);
|
|
if (!eh_frame_sp)
|
|
eh_frame_sp = GetDebugFrameUnwindPlan(target);
|
|
if (!eh_frame_sp)
|
|
eh_frame_sp = GetObjectFileUnwindPlan(target);
|
|
UnwindPlanSP arch_default_at_entry_sp =
|
|
GetUnwindPlanArchitectureDefaultAtFunctionEntry(thread);
|
|
UnwindPlanSP arch_default_sp = GetUnwindPlanArchitectureDefault(thread);
|
|
UnwindPlanSP assembly_sp = GetAssemblyUnwindPlan(target, thread);
|
|
|
|
// This point of this code is to detect when a function is using a non-
|
|
// standard ABI, and the eh_frame correctly describes that alternate ABI.
|
|
// This is addressing a specific situation on x86_64 linux systems where one
|
|
// function in a library pushes a value on the stack and jumps to another
|
|
// function. So using an assembly instruction based unwind will not work
|
|
// when you're in the second function - the stack has been modified in a non-
|
|
// ABI way. But we have eh_frame that correctly describes how to unwind from
|
|
// this location. So we're looking to see if the initial pc register save
|
|
// location from the eh_frame is different from the assembly unwind, the arch
|
|
// default unwind, and the arch default at initial function entry.
|
|
//
|
|
// We may have eh_frame that describes the entire function -- or we may have
|
|
// eh_frame that only describes the unwind after the prologue has executed --
|
|
// so we need to check both the arch default (once the prologue has executed)
|
|
// and the arch default at initial function entry. And we may be running on
|
|
// a target where we have only some of the assembly/arch default unwind plans
|
|
// available.
|
|
|
|
if (CompareUnwindPlansForIdenticalInitialPCLocation(
|
|
thread, eh_frame_sp, arch_default_at_entry_sp) == eLazyBoolNo &&
|
|
CompareUnwindPlansForIdenticalInitialPCLocation(
|
|
thread, eh_frame_sp, arch_default_sp) == eLazyBoolNo &&
|
|
CompareUnwindPlansForIdenticalInitialPCLocation(
|
|
thread, assembly_sp, arch_default_sp) == eLazyBoolNo) {
|
|
return eh_frame_sp;
|
|
}
|
|
|
|
if (UnwindPlanSP plan_sp = GetSymbolFileUnwindPlan(thread))
|
|
return plan_sp;
|
|
if (UnwindPlanSP plan_sp = GetDebugFrameAugmentedUnwindPlan(target, thread))
|
|
return plan_sp;
|
|
if (UnwindPlanSP plan_sp = GetEHFrameAugmentedUnwindPlan(target, thread))
|
|
return plan_sp;
|
|
if (UnwindPlanSP plan_sp = GetObjectFileAugmentedUnwindPlan(target, thread))
|
|
return plan_sp;
|
|
|
|
return assembly_sp;
|
|
}
|
|
|
|
UnwindPlanSP FuncUnwinders::GetUnwindPlanFastUnwind(Target &target,
|
|
Thread &thread) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
if (m_unwind_plan_fast_sp.get() || m_tried_unwind_fast)
|
|
return m_unwind_plan_fast_sp;
|
|
|
|
m_tried_unwind_fast = true;
|
|
|
|
UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
|
|
if (assembly_profiler_sp) {
|
|
m_unwind_plan_fast_sp =
|
|
std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
|
|
if (!assembly_profiler_sp->GetFastUnwindPlan(m_range, thread,
|
|
*m_unwind_plan_fast_sp)) {
|
|
m_unwind_plan_fast_sp.reset();
|
|
}
|
|
}
|
|
return m_unwind_plan_fast_sp;
|
|
}
|
|
|
|
UnwindPlanSP FuncUnwinders::GetUnwindPlanArchitectureDefault(Thread &thread) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
if (m_unwind_plan_arch_default_sp.get() || m_tried_unwind_arch_default)
|
|
return m_unwind_plan_arch_default_sp;
|
|
|
|
m_tried_unwind_arch_default = true;
|
|
|
|
Address current_pc;
|
|
ProcessSP process_sp(thread.CalculateProcess());
|
|
if (process_sp) {
|
|
ABI *abi = process_sp->GetABI().get();
|
|
if (abi) {
|
|
m_unwind_plan_arch_default_sp =
|
|
std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
|
|
if (!abi->CreateDefaultUnwindPlan(*m_unwind_plan_arch_default_sp)) {
|
|
m_unwind_plan_arch_default_sp.reset();
|
|
}
|
|
}
|
|
}
|
|
|
|
return m_unwind_plan_arch_default_sp;
|
|
}
|
|
|
|
UnwindPlanSP
|
|
FuncUnwinders::GetUnwindPlanArchitectureDefaultAtFunctionEntry(Thread &thread) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
if (m_unwind_plan_arch_default_at_func_entry_sp.get() ||
|
|
m_tried_unwind_arch_default_at_func_entry)
|
|
return m_unwind_plan_arch_default_at_func_entry_sp;
|
|
|
|
m_tried_unwind_arch_default_at_func_entry = true;
|
|
|
|
Address current_pc;
|
|
ProcessSP process_sp(thread.CalculateProcess());
|
|
if (process_sp) {
|
|
ABI *abi = process_sp->GetABI().get();
|
|
if (abi) {
|
|
m_unwind_plan_arch_default_at_func_entry_sp =
|
|
std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
|
|
if (!abi->CreateFunctionEntryUnwindPlan(
|
|
*m_unwind_plan_arch_default_at_func_entry_sp)) {
|
|
m_unwind_plan_arch_default_at_func_entry_sp.reset();
|
|
}
|
|
}
|
|
}
|
|
|
|
return m_unwind_plan_arch_default_at_func_entry_sp;
|
|
}
|
|
|
|
Address &FuncUnwinders::GetFirstNonPrologueInsn(Target &target) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
if (m_first_non_prologue_insn.IsValid())
|
|
return m_first_non_prologue_insn;
|
|
|
|
ExecutionContext exe_ctx(target.shared_from_this(), false);
|
|
UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
|
|
if (assembly_profiler_sp)
|
|
assembly_profiler_sp->FirstNonPrologueInsn(m_range, exe_ctx,
|
|
m_first_non_prologue_insn);
|
|
return m_first_non_prologue_insn;
|
|
}
|
|
|
|
const Address &FuncUnwinders::GetFunctionStartAddress() const {
|
|
return m_range.GetBaseAddress();
|
|
}
|
|
|
|
lldb::UnwindAssemblySP
|
|
FuncUnwinders::GetUnwindAssemblyProfiler(Target &target) {
|
|
UnwindAssemblySP assembly_profiler_sp;
|
|
if (ArchSpec arch = m_unwind_table.GetArchitecture()) {
|
|
arch.MergeFrom(target.GetArchitecture());
|
|
assembly_profiler_sp = UnwindAssembly::FindPlugin(arch);
|
|
}
|
|
return assembly_profiler_sp;
|
|
}
|
|
|
|
Address FuncUnwinders::GetLSDAAddress(Target &target) {
|
|
Address lsda_addr;
|
|
|
|
UnwindPlanSP unwind_plan_sp = GetEHFrameUnwindPlan(target);
|
|
if (unwind_plan_sp.get() == nullptr) {
|
|
unwind_plan_sp = GetCompactUnwindUnwindPlan(target);
|
|
}
|
|
if (unwind_plan_sp.get() == nullptr) {
|
|
unwind_plan_sp = GetObjectFileUnwindPlan(target);
|
|
}
|
|
if (unwind_plan_sp.get() && unwind_plan_sp->GetLSDAAddress().IsValid()) {
|
|
lsda_addr = unwind_plan_sp->GetLSDAAddress();
|
|
}
|
|
return lsda_addr;
|
|
}
|
|
|
|
Address FuncUnwinders::GetPersonalityRoutinePtrAddress(Target &target) {
|
|
Address personality_addr;
|
|
|
|
UnwindPlanSP unwind_plan_sp = GetEHFrameUnwindPlan(target);
|
|
if (unwind_plan_sp.get() == nullptr) {
|
|
unwind_plan_sp = GetCompactUnwindUnwindPlan(target);
|
|
}
|
|
if (unwind_plan_sp.get() == nullptr) {
|
|
unwind_plan_sp = GetObjectFileUnwindPlan(target);
|
|
}
|
|
if (unwind_plan_sp.get() &&
|
|
unwind_plan_sp->GetPersonalityFunctionPtr().IsValid()) {
|
|
personality_addr = unwind_plan_sp->GetPersonalityFunctionPtr();
|
|
}
|
|
|
|
return personality_addr;
|
|
}
|