//===-- 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 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() {} UnwindPlanSP FuncUnwinders::GetUnwindPlanAtCallSite(Target &target, Thread &thread) { std::lock_guard 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 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 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(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 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(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 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(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 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(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 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 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(*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 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(*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 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(*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 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; UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target)); if (assembly_profiler_sp) { m_unwind_plan_assembly_sp = std::make_shared(lldb::eRegisterKindGeneric); if (!assembly_profiler_sp->GetNonCallSiteUnwindPlanFromAssembly( m_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::RegisterLocation a_pc_regloc; UnwindPlan::Row::RegisterLocation 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 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(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 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(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 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(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 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; }