Author: Vladislav Dzhidzhoev Date: 2025-04-03T11:33:11+02:00 New Revision: 094904303d50e0ab14bc5f2586a602f79af95953
URL: https://github.com/llvm/llvm-project/commit/094904303d50e0ab14bc5f2586a602f79af95953 DIFF: https://github.com/llvm/llvm-project/commit/094904303d50e0ab14bc5f2586a602f79af95953.diff LOG: Revert "[lldb] Return *const* UnwindPlan pointers from FuncUnwinders (#133247)" This reverts commit d7afafdbc464e65c56a0a1d77bad426aa7538306. Caused remote Linux to Linux buildbot failure https://lab.llvm.org/buildbot/#/builders/195/builds/7046. Added: Modified: lldb/include/lldb/Symbol/FuncUnwinders.h lldb/include/lldb/Symbol/UnwindPlan.h lldb/include/lldb/Target/RegisterContextUnwind.h lldb/source/Commands/CommandObjectTarget.cpp lldb/source/Symbol/FuncUnwinders.cpp lldb/source/Symbol/UnwindPlan.cpp lldb/source/Target/RegisterContextUnwind.cpp Removed: ################################################################################ diff --git a/lldb/include/lldb/Symbol/FuncUnwinders.h b/lldb/include/lldb/Symbol/FuncUnwinders.h index 479ccf87b6e2c..1d4c28324e90f 100644 --- a/lldb/include/lldb/Symbol/FuncUnwinders.h +++ b/lldb/include/lldb/Symbol/FuncUnwinders.h @@ -36,19 +36,18 @@ class FuncUnwinders { ~FuncUnwinders(); - std::shared_ptr<const UnwindPlan> GetUnwindPlanAtCallSite(Target &target, - Thread &thread); + lldb::UnwindPlanSP GetUnwindPlanAtCallSite(Target &target, Thread &thread); - std::shared_ptr<const UnwindPlan> - GetUnwindPlanAtNonCallSite(Target &target, lldb_private::Thread &thread); + lldb::UnwindPlanSP GetUnwindPlanAtNonCallSite(Target &target, + lldb_private::Thread &thread); - std::shared_ptr<const UnwindPlan> - GetUnwindPlanFastUnwind(Target &target, lldb_private::Thread &thread); + lldb::UnwindPlanSP GetUnwindPlanFastUnwind(Target &target, + lldb_private::Thread &thread); - std::shared_ptr<const UnwindPlan> + lldb::UnwindPlanSP GetUnwindPlanArchitectureDefault(lldb_private::Thread &thread); - std::shared_ptr<const UnwindPlan> + lldb::UnwindPlanSP GetUnwindPlanArchitectureDefaultAtFunctionEntry(lldb_private::Thread &thread); Address &GetFirstNonPrologueInsn(Target &target); @@ -78,34 +77,32 @@ class FuncUnwinders { // used. Instead, clients should ask for the *behavior* they are looking for, // using one of the above UnwindPlan retrieval methods. - std::shared_ptr<const UnwindPlan> GetAssemblyUnwindPlan(Target &target, - Thread &thread); + lldb::UnwindPlanSP GetAssemblyUnwindPlan(Target &target, Thread &thread); - std::shared_ptr<const UnwindPlan> GetObjectFileUnwindPlan(Target &target); + lldb::UnwindPlanSP GetObjectFileUnwindPlan(Target &target); - std::shared_ptr<const UnwindPlan> - GetObjectFileAugmentedUnwindPlan(Target &target, Thread &thread); + lldb::UnwindPlanSP GetObjectFileAugmentedUnwindPlan(Target &target, + Thread &thread); - std::shared_ptr<const UnwindPlan> GetEHFrameUnwindPlan(Target &target); + lldb::UnwindPlanSP GetEHFrameUnwindPlan(Target &target); - std::shared_ptr<const UnwindPlan> - GetEHFrameAugmentedUnwindPlan(Target &target, Thread &thread); + lldb::UnwindPlanSP GetEHFrameAugmentedUnwindPlan(Target &target, + Thread &thread); - std::shared_ptr<const UnwindPlan> GetDebugFrameUnwindPlan(Target &target); + lldb::UnwindPlanSP GetDebugFrameUnwindPlan(Target &target); - std::shared_ptr<const UnwindPlan> - GetDebugFrameAugmentedUnwindPlan(Target &target, Thread &thread); + lldb::UnwindPlanSP GetDebugFrameAugmentedUnwindPlan(Target &target, + Thread &thread); - std::shared_ptr<const UnwindPlan> GetCompactUnwindUnwindPlan(Target &target); + lldb::UnwindPlanSP GetCompactUnwindUnwindPlan(Target &target); - std::shared_ptr<const UnwindPlan> GetArmUnwindUnwindPlan(Target &target); + lldb::UnwindPlanSP GetArmUnwindUnwindPlan(Target &target); - std::shared_ptr<const UnwindPlan> GetSymbolFileUnwindPlan(Thread &thread); + lldb::UnwindPlanSP GetSymbolFileUnwindPlan(Thread &thread); - std::shared_ptr<const UnwindPlan> GetArchDefaultUnwindPlan(Thread &thread); + lldb::UnwindPlanSP GetArchDefaultUnwindPlan(Thread &thread); - std::shared_ptr<const UnwindPlan> - GetArchDefaultAtFuncEntryUnwindPlan(Thread &thread); + lldb::UnwindPlanSP GetArchDefaultAtFuncEntryUnwindPlan(Thread &thread); private: lldb::UnwindAssemblySP GetUnwindAssemblyProfiler(Target &target); @@ -116,8 +113,7 @@ class FuncUnwinders { // unwind rule for the pc, and LazyBoolCalculate if it was unable to // determine this for some reason. lldb_private::LazyBool CompareUnwindPlansForIdenticalInitialPCLocation( - Thread &thread, const std::shared_ptr<const UnwindPlan> &a, - const std::shared_ptr<const UnwindPlan> &b); + Thread &thread, const lldb::UnwindPlanSP &a, const lldb::UnwindPlanSP &b); UnwindTable &m_unwind_table; @@ -133,22 +129,22 @@ class FuncUnwinders { std::recursive_mutex m_mutex; - std::shared_ptr<const UnwindPlan> m_unwind_plan_assembly_sp; - std::shared_ptr<const UnwindPlan> m_unwind_plan_object_file_sp; - std::shared_ptr<const UnwindPlan> m_unwind_plan_eh_frame_sp; - std::shared_ptr<const UnwindPlan> m_unwind_plan_debug_frame_sp; + lldb::UnwindPlanSP m_unwind_plan_assembly_sp; + lldb::UnwindPlanSP m_unwind_plan_object_file_sp; + lldb::UnwindPlanSP m_unwind_plan_eh_frame_sp; + lldb::UnwindPlanSP m_unwind_plan_debug_frame_sp; // augmented by assembly inspection so it's valid everywhere - std::shared_ptr<const UnwindPlan> m_unwind_plan_object_file_augmented_sp; - std::shared_ptr<const UnwindPlan> m_unwind_plan_eh_frame_augmented_sp; - std::shared_ptr<const UnwindPlan> m_unwind_plan_debug_frame_augmented_sp; - - std::vector<std::shared_ptr<const UnwindPlan>> m_unwind_plan_compact_unwind; - std::shared_ptr<const UnwindPlan> m_unwind_plan_arm_unwind_sp; - std::shared_ptr<const UnwindPlan> m_unwind_plan_symbol_file_sp; - std::shared_ptr<const UnwindPlan> m_unwind_plan_fast_sp; - std::shared_ptr<const UnwindPlan> m_unwind_plan_arch_default_sp; - std::shared_ptr<const UnwindPlan> m_unwind_plan_arch_default_at_func_entry_sp; + lldb::UnwindPlanSP m_unwind_plan_object_file_augmented_sp; + lldb::UnwindPlanSP m_unwind_plan_eh_frame_augmented_sp; + lldb::UnwindPlanSP m_unwind_plan_debug_frame_augmented_sp; + + std::vector<lldb::UnwindPlanSP> m_unwind_plan_compact_unwind; + lldb::UnwindPlanSP m_unwind_plan_arm_unwind_sp; + lldb::UnwindPlanSP m_unwind_plan_symbol_file_sp; + lldb::UnwindPlanSP m_unwind_plan_fast_sp; + lldb::UnwindPlanSP m_unwind_plan_arch_default_sp; + lldb::UnwindPlanSP m_unwind_plan_arch_default_at_func_entry_sp; // Fetching the UnwindPlans can be expensive - if we've already attempted to // get one & failed, don't try again. diff --git a/lldb/include/lldb/Symbol/UnwindPlan.h b/lldb/include/lldb/Symbol/UnwindPlan.h index 6640a23a3e868..9adda27b8f928 100644 --- a/lldb/include/lldb/Symbol/UnwindPlan.h +++ b/lldb/include/lldb/Symbol/UnwindPlan.h @@ -482,7 +482,7 @@ class UnwindPlan { m_return_addr_register = regnum; } - uint32_t GetReturnAddressRegister() const { return m_return_addr_register; } + uint32_t GetReturnAddressRegister() { return m_return_addr_register; } uint32_t GetInitialCFARegister() const { if (m_row_list.empty()) @@ -497,7 +497,7 @@ class UnwindPlan { m_plan_valid_ranges = std::move(ranges); } - bool PlanValidAtAddress(Address addr) const; + bool PlanValidAtAddress(Address addr); bool IsValidRowIndex(uint32_t idx) const; diff --git a/lldb/include/lldb/Target/RegisterContextUnwind.h b/lldb/include/lldb/Target/RegisterContextUnwind.h index 044a387fe5aa2..c4ae29e657bfb 100644 --- a/lldb/include/lldb/Target/RegisterContextUnwind.h +++ b/lldb/include/lldb/Target/RegisterContextUnwind.h @@ -127,8 +127,7 @@ class RegisterContextUnwind : public lldb_private::RegisterContext { /// Check if the given unwind plan indicates a signal trap handler, and /// update frame type and symbol context if so. - void PropagateTrapHandlerFlagFromUnwindPlan( - std::shared_ptr<const UnwindPlan> unwind_plan); + void PropagateTrapHandlerFlagFromUnwindPlan(lldb::UnwindPlanSP unwind_plan); // Provide a location for where THIS function saved the CALLER's register // value @@ -195,17 +194,16 @@ class RegisterContextUnwind : public lldb_private::RegisterContext { const UnwindPlan::Row::FAValue &fa, lldb::addr_t &address); - std::shared_ptr<const UnwindPlan> GetFastUnwindPlanForFrame(); + lldb::UnwindPlanSP GetFastUnwindPlanForFrame(); - std::shared_ptr<const UnwindPlan> GetFullUnwindPlanForFrame(); + lldb::UnwindPlanSP GetFullUnwindPlanForFrame(); void UnwindLogMsg(const char *fmt, ...) __attribute__((format(printf, 2, 3))); void UnwindLogMsgVerbose(const char *fmt, ...) __attribute__((format(printf, 2, 3))); - bool IsUnwindPlanValidForCurrentPC( - std::shared_ptr<const UnwindPlan> unwind_plan_sp); + bool IsUnwindPlanValidForCurrentPC(lldb::UnwindPlanSP unwind_plan_sp); lldb::addr_t GetReturnAddressHint(int32_t plan_offset); @@ -217,9 +215,9 @@ class RegisterContextUnwind : public lldb_private::RegisterContext { // i.e. where THIS frame saved them /// - std::shared_ptr<const UnwindPlan> m_fast_unwind_plan_sp; // may be NULL - std::shared_ptr<const UnwindPlan> m_full_unwind_plan_sp; - std::shared_ptr<const UnwindPlan> m_fallback_unwind_plan_sp; // may be NULL + lldb::UnwindPlanSP m_fast_unwind_plan_sp; // may be NULL + lldb::UnwindPlanSP m_full_unwind_plan_sp; + lldb::UnwindPlanSP m_fallback_unwind_plan_sp; // may be NULL bool m_all_registers_available; // Can we retrieve all regs or just // nonvolatile regs? diff --git a/lldb/source/Commands/CommandObjectTarget.cpp b/lldb/source/Commands/CommandObjectTarget.cpp index 3f7d3007ed168..c77bddb4af061 100644 --- a/lldb/source/Commands/CommandObjectTarget.cpp +++ b/lldb/source/Commands/CommandObjectTarget.cpp @@ -3641,70 +3641,77 @@ class CommandObjectTargetModulesShowUnwind : public CommandObjectParsed { result.GetOutputStream().Printf("\n"); - if (std::shared_ptr<const UnwindPlan> plan_sp = - func_unwinders_sp->GetUnwindPlanAtNonCallSite(*target, *thread)) { + UnwindPlanSP non_callsite_unwind_plan = + func_unwinders_sp->GetUnwindPlanAtNonCallSite(*target, *thread); + if (non_callsite_unwind_plan) { result.GetOutputStream().Printf( "Asynchronous (not restricted to call-sites) UnwindPlan is '%s'\n", - plan_sp->GetSourceName().AsCString()); + non_callsite_unwind_plan->GetSourceName().AsCString()); } - if (std::shared_ptr<const UnwindPlan> plan_sp = - func_unwinders_sp->GetUnwindPlanAtCallSite(*target, *thread)) { + UnwindPlanSP callsite_unwind_plan = + func_unwinders_sp->GetUnwindPlanAtCallSite(*target, *thread); + if (callsite_unwind_plan) { result.GetOutputStream().Printf( "Synchronous (restricted to call-sites) UnwindPlan is '%s'\n", - plan_sp->GetSourceName().AsCString()); + callsite_unwind_plan->GetSourceName().AsCString()); } - if (std::shared_ptr<const UnwindPlan> plan_sp = - func_unwinders_sp->GetUnwindPlanFastUnwind(*target, *thread)) { - result.GetOutputStream().Printf("Fast UnwindPlan is '%s'\n", - plan_sp->GetSourceName().AsCString()); + UnwindPlanSP fast_unwind_plan = + func_unwinders_sp->GetUnwindPlanFastUnwind(*target, *thread); + if (fast_unwind_plan) { + result.GetOutputStream().Printf( + "Fast UnwindPlan is '%s'\n", + fast_unwind_plan->GetSourceName().AsCString()); } result.GetOutputStream().Printf("\n"); - if (std::shared_ptr<const UnwindPlan> plan_sp = - func_unwinders_sp->GetAssemblyUnwindPlan(*target, *thread)) { + UnwindPlanSP assembly_sp = + func_unwinders_sp->GetAssemblyUnwindPlan(*target, *thread); + if (assembly_sp) { result.GetOutputStream().Printf( "Assembly language inspection UnwindPlan:\n"); - plan_sp->Dump(result.GetOutputStream(), thread.get(), - LLDB_INVALID_ADDRESS); + assembly_sp->Dump(result.GetOutputStream(), thread.get(), + LLDB_INVALID_ADDRESS); result.GetOutputStream().Printf("\n"); } - if (std::shared_ptr<const UnwindPlan> plan_sp = - func_unwinders_sp->GetObjectFileUnwindPlan(*target)) { + UnwindPlanSP of_unwind_sp = + func_unwinders_sp->GetObjectFileUnwindPlan(*target); + if (of_unwind_sp) { result.GetOutputStream().Printf("object file UnwindPlan:\n"); - plan_sp->Dump(result.GetOutputStream(), thread.get(), - LLDB_INVALID_ADDRESS); + of_unwind_sp->Dump(result.GetOutputStream(), thread.get(), + LLDB_INVALID_ADDRESS); result.GetOutputStream().Printf("\n"); } - if (std::shared_ptr<const UnwindPlan> plan_sp = - func_unwinders_sp->GetObjectFileAugmentedUnwindPlan(*target, - *thread)) { + UnwindPlanSP of_unwind_augmented_sp = + func_unwinders_sp->GetObjectFileAugmentedUnwindPlan(*target, *thread); + if (of_unwind_augmented_sp) { result.GetOutputStream().Printf("object file augmented UnwindPlan:\n"); - plan_sp->Dump(result.GetOutputStream(), thread.get(), - LLDB_INVALID_ADDRESS); + of_unwind_augmented_sp->Dump(result.GetOutputStream(), thread.get(), + LLDB_INVALID_ADDRESS); result.GetOutputStream().Printf("\n"); } - if (std::shared_ptr<const UnwindPlan> plan_sp = - func_unwinders_sp->GetEHFrameUnwindPlan(*target)) { + UnwindPlanSP ehframe_sp = + func_unwinders_sp->GetEHFrameUnwindPlan(*target); + if (ehframe_sp) { result.GetOutputStream().Printf("eh_frame UnwindPlan:\n"); - plan_sp->Dump(result.GetOutputStream(), thread.get(), - LLDB_INVALID_ADDRESS); + ehframe_sp->Dump(result.GetOutputStream(), thread.get(), + LLDB_INVALID_ADDRESS); result.GetOutputStream().Printf("\n"); } - if (std::shared_ptr<const UnwindPlan> plan_sp = - func_unwinders_sp->GetEHFrameAugmentedUnwindPlan(*target, - *thread)) { + UnwindPlanSP ehframe_augmented_sp = + func_unwinders_sp->GetEHFrameAugmentedUnwindPlan(*target, *thread); + if (ehframe_augmented_sp) { result.GetOutputStream().Printf("eh_frame augmented UnwindPlan:\n"); - plan_sp->Dump(result.GetOutputStream(), thread.get(), - LLDB_INVALID_ADDRESS); + ehframe_augmented_sp->Dump(result.GetOutputStream(), thread.get(), + LLDB_INVALID_ADDRESS); result.GetOutputStream().Printf("\n"); } - if (std::shared_ptr<const UnwindPlan> plan_sp = + if (UnwindPlanSP plan_sp = func_unwinders_sp->GetDebugFrameUnwindPlan(*target)) { result.GetOutputStream().Printf("debug_frame UnwindPlan:\n"); plan_sp->Dump(result.GetOutputStream(), thread.get(), @@ -3712,7 +3719,7 @@ class CommandObjectTargetModulesShowUnwind : public CommandObjectParsed { result.GetOutputStream().Printf("\n"); } - if (std::shared_ptr<const UnwindPlan> plan_sp = + if (UnwindPlanSP plan_sp = func_unwinders_sp->GetDebugFrameAugmentedUnwindPlan(*target, *thread)) { result.GetOutputStream().Printf("debug_frame augmented UnwindPlan:\n"); @@ -3721,35 +3728,36 @@ class CommandObjectTargetModulesShowUnwind : public CommandObjectParsed { result.GetOutputStream().Printf("\n"); } - if (std::shared_ptr<const UnwindPlan> plan_sp = - func_unwinders_sp->GetArmUnwindUnwindPlan(*target)) { + UnwindPlanSP arm_unwind_sp = + func_unwinders_sp->GetArmUnwindUnwindPlan(*target); + if (arm_unwind_sp) { result.GetOutputStream().Printf("ARM.exidx unwind UnwindPlan:\n"); - plan_sp->Dump(result.GetOutputStream(), thread.get(), - LLDB_INVALID_ADDRESS); + arm_unwind_sp->Dump(result.GetOutputStream(), thread.get(), + LLDB_INVALID_ADDRESS); result.GetOutputStream().Printf("\n"); } - if (std::shared_ptr<const UnwindPlan> plan_sp = + if (UnwindPlanSP symfile_plan_sp = func_unwinders_sp->GetSymbolFileUnwindPlan(*thread)) { result.GetOutputStream().Printf("Symbol file UnwindPlan:\n"); - plan_sp->Dump(result.GetOutputStream(), thread.get(), - LLDB_INVALID_ADDRESS); + symfile_plan_sp->Dump(result.GetOutputStream(), thread.get(), + LLDB_INVALID_ADDRESS); result.GetOutputStream().Printf("\n"); } - if (std::shared_ptr<const UnwindPlan> plan_sp = - func_unwinders_sp->GetCompactUnwindUnwindPlan(*target)) { + UnwindPlanSP compact_unwind_sp = + func_unwinders_sp->GetCompactUnwindUnwindPlan(*target); + if (compact_unwind_sp) { result.GetOutputStream().Printf("Compact unwind UnwindPlan:\n"); - plan_sp->Dump(result.GetOutputStream(), thread.get(), - LLDB_INVALID_ADDRESS); + compact_unwind_sp->Dump(result.GetOutputStream(), thread.get(), + LLDB_INVALID_ADDRESS); result.GetOutputStream().Printf("\n"); } - if (std::shared_ptr<const UnwindPlan> plan_sp = - func_unwinders_sp->GetUnwindPlanFastUnwind(*target, *thread)) { + if (fast_unwind_plan) { result.GetOutputStream().Printf("Fast UnwindPlan:\n"); - plan_sp->Dump(result.GetOutputStream(), thread.get(), - LLDB_INVALID_ADDRESS); + fast_unwind_plan->Dump(result.GetOutputStream(), thread.get(), + LLDB_INVALID_ADDRESS); result.GetOutputStream().Printf("\n"); } diff --git a/lldb/source/Symbol/FuncUnwinders.cpp b/lldb/source/Symbol/FuncUnwinders.cpp index a74029d8343c7..a5ca7b094c949 100644 --- a/lldb/source/Symbol/FuncUnwinders.cpp +++ b/lldb/source/Symbol/FuncUnwinders.cpp @@ -71,47 +71,40 @@ FuncUnwinders::FuncUnwinders(UnwindTable &unwind_table, Address addr, FuncUnwinders::~FuncUnwinders() = default; -std::shared_ptr<const UnwindPlan> -FuncUnwinders::GetUnwindPlanAtCallSite(Target &target, Thread &thread) { +UnwindPlanSP FuncUnwinders::GetUnwindPlanAtCallSite(Target &target, + Thread &thread) { std::lock_guard<std::recursive_mutex> guard(m_mutex); - if (std::shared_ptr<const UnwindPlan> plan_sp = - GetObjectFileUnwindPlan(target)) + if (UnwindPlanSP plan_sp = GetObjectFileUnwindPlan(target)) return plan_sp; - if (std::shared_ptr<const UnwindPlan> plan_sp = - GetSymbolFileUnwindPlan(thread)) + if (UnwindPlanSP plan_sp = GetSymbolFileUnwindPlan(thread)) return plan_sp; - if (std::shared_ptr<const UnwindPlan> plan_sp = - GetDebugFrameUnwindPlan(target)) + if (UnwindPlanSP plan_sp = GetDebugFrameUnwindPlan(target)) return plan_sp; - if (std::shared_ptr<const UnwindPlan> plan_sp = GetEHFrameUnwindPlan(target)) + if (UnwindPlanSP plan_sp = GetEHFrameUnwindPlan(target)) return plan_sp; - if (std::shared_ptr<const UnwindPlan> plan_sp = - GetCompactUnwindUnwindPlan(target)) + if (UnwindPlanSP plan_sp = GetCompactUnwindUnwindPlan(target)) return plan_sp; - if (std::shared_ptr<const UnwindPlan> plan_sp = - GetArmUnwindUnwindPlan(target)) + if (UnwindPlanSP plan_sp = GetArmUnwindUnwindPlan(target)) return plan_sp; return nullptr; } -std::shared_ptr<const UnwindPlan> -FuncUnwinders::GetCompactUnwindUnwindPlan(Target &target) { +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 nullptr; + 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) { - auto unwind_plan_sp = - std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric); + 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 @@ -120,11 +113,10 @@ FuncUnwinders::GetCompactUnwindUnwindPlan(Target &target) { } } } - return nullptr; + return UnwindPlanSP(); } -std::shared_ptr<const UnwindPlan> -FuncUnwinders::GetObjectFileUnwindPlan(Target &target) { +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) @@ -134,16 +126,17 @@ FuncUnwinders::GetObjectFileUnwindPlan(Target &target) { if (m_range.GetBaseAddress().IsValid()) { CallFrameInfo *object_file_frame = m_unwind_table.GetObjectFileUnwindInfo(); if (object_file_frame) { - auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric); - if (object_file_frame->GetUnwindPlan(m_range, *plan_sp)) - m_unwind_plan_object_file_sp = std::move(plan_sp); + 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; } -std::shared_ptr<const UnwindPlan> -FuncUnwinders::GetEHFrameUnwindPlan(Target &target) { +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; @@ -152,16 +145,16 @@ FuncUnwinders::GetEHFrameUnwindPlan(Target &target) { if (m_range.GetBaseAddress().IsValid()) { DWARFCallFrameInfo *eh_frame = m_unwind_table.GetEHFrameInfo(); if (eh_frame) { - auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric); - if (eh_frame->GetUnwindPlan(m_range, *plan_sp)) - m_unwind_plan_eh_frame_sp = std::move(plan_sp); + 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; } -std::shared_ptr<const UnwindPlan> -FuncUnwinders::GetDebugFrameUnwindPlan(Target &target) { +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; @@ -170,16 +163,16 @@ FuncUnwinders::GetDebugFrameUnwindPlan(Target &target) { if (m_range.GetBaseAddress().IsValid()) { DWARFCallFrameInfo *debug_frame = m_unwind_table.GetDebugFrameInfo(); if (debug_frame) { - auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric); - if (debug_frame->GetUnwindPlan(m_range, *plan_sp)) - m_unwind_plan_debug_frame_sp = std::move(plan_sp); + 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; } -std::shared_ptr<const UnwindPlan> -FuncUnwinders::GetArmUnwindUnwindPlan(Target &target) { +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; @@ -189,9 +182,11 @@ FuncUnwinders::GetArmUnwindUnwindPlan(Target &target) { Address current_pc(m_range.GetBaseAddress()); ArmUnwindInfo *arm_unwind_info = m_unwind_table.GetArmUnwindInfo(); if (arm_unwind_info) { - auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric); - if (arm_unwind_info->GetUnwindPlan(target, current_pc, *plan_sp)) - m_unwind_plan_arm_unwind_sp = std::move(plan_sp); + 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; @@ -215,8 +210,7 @@ class RegisterContextToInfo: public SymbolFile::RegisterInfoResolver { }; } // namespace -std::shared_ptr<const UnwindPlan> -FuncUnwinders::GetSymbolFileUnwindPlan(Thread &thread) { +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; @@ -230,9 +224,9 @@ FuncUnwinders::GetSymbolFileUnwindPlan(Thread &thread) { return m_unwind_plan_symbol_file_sp; } -std::shared_ptr<const UnwindPlan> +UnwindPlanSP FuncUnwinders::GetObjectFileAugmentedUnwindPlan(Target &target, - Thread &thread) { + 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) @@ -240,27 +234,30 @@ FuncUnwinders::GetObjectFileAugmentedUnwindPlan(Target &target, m_tried_unwind_plan_object_file_augmented = true; - std::shared_ptr<const UnwindPlan> object_file_unwind_plan = - GetObjectFileUnwindPlan(target); + 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) { - auto plan_sp = std::make_shared<UnwindPlan>(*object_file_unwind_plan); - - if (assembly_profiler_sp->AugmentUnwindPlanFromCallSite(m_range, thread, - *plan_sp)) - m_unwind_plan_object_file_augmented_sp = std::move(plan_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; } -std::shared_ptr<const UnwindPlan> -FuncUnwinders::GetEHFrameAugmentedUnwindPlan(Target &target, Thread &thread) { +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) @@ -278,27 +275,30 @@ FuncUnwinders::GetEHFrameAugmentedUnwindPlan(Target &target, Thread &thread) { m_tried_unwind_plan_eh_frame_augmented = true; - std::shared_ptr<const UnwindPlan> eh_frame_plan = - GetEHFrameUnwindPlan(target); + 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) { - auto plan_sp = std::make_shared<UnwindPlan>(*eh_frame_plan); - if (assembly_profiler_sp->AugmentUnwindPlanFromCallSite(m_range, thread, - *plan_sp)) - m_unwind_plan_eh_frame_augmented_sp = std::move(plan_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; } -std::shared_ptr<const UnwindPlan> -FuncUnwinders::GetDebugFrameAugmentedUnwindPlan(Target &target, - Thread &thread) { +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) @@ -316,28 +316,30 @@ FuncUnwinders::GetDebugFrameAugmentedUnwindPlan(Target &target, m_tried_unwind_plan_debug_frame_augmented = true; - std::shared_ptr<const UnwindPlan> debug_frame_plan = - GetDebugFrameUnwindPlan(target); + 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) { - auto plan_sp = std::make_shared<UnwindPlan>(*debug_frame_plan); - - if (assembly_profiler_sp->AugmentUnwindPlanFromCallSite(m_range, thread, - *plan_sp)) - m_unwind_plan_debug_frame_augmented_sp = std::move(plan_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; } -std::shared_ptr<const UnwindPlan> -FuncUnwinders::GetAssemblyUnwindPlan(Target &target, Thread &thread) { +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()) { @@ -358,10 +360,12 @@ FuncUnwinders::GetAssemblyUnwindPlan(Target &target, Thread &thread) { UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target)); if (assembly_profiler_sp) { - auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric); - if (assembly_profiler_sp->GetNonCallSiteUnwindPlanFromAssembly( - range, thread, *plan_sp)) - m_unwind_plan_assembly_sp = std::move(plan_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; } @@ -370,8 +374,7 @@ FuncUnwinders::GetAssemblyUnwindPlan(Target &target, Thread &thread) { // 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 std::shared_ptr<const UnwindPlan> &a, - const std::shared_ptr<const UnwindPlan> &b) { + Thread &thread, const UnwindPlanSP &a, const UnwindPlanSP &b) { LazyBool plans_are_identical = eLazyBoolCalculate; RegisterNumber pc_reg(thread, eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); @@ -401,19 +404,17 @@ LazyBool FuncUnwinders::CompareUnwindPlansForIdenticalInitialPCLocation( return plans_are_identical; } -std::shared_ptr<const UnwindPlan> -FuncUnwinders::GetUnwindPlanAtNonCallSite(Target &target, Thread &thread) { - std::shared_ptr<const UnwindPlan> eh_frame_sp = GetEHFrameUnwindPlan(target); +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); - std::shared_ptr<const UnwindPlan> arch_default_at_entry_sp = + UnwindPlanSP arch_default_at_entry_sp = GetUnwindPlanArchitectureDefaultAtFunctionEntry(thread); - std::shared_ptr<const UnwindPlan> arch_default_sp = - GetUnwindPlanArchitectureDefault(thread); - std::shared_ptr<const UnwindPlan> assembly_sp = - GetAssemblyUnwindPlan(target, 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. @@ -442,24 +443,20 @@ FuncUnwinders::GetUnwindPlanAtNonCallSite(Target &target, Thread &thread) { return eh_frame_sp; } - if (std::shared_ptr<const UnwindPlan> plan_sp = - GetSymbolFileUnwindPlan(thread)) + if (UnwindPlanSP plan_sp = GetSymbolFileUnwindPlan(thread)) return plan_sp; - if (std::shared_ptr<const UnwindPlan> plan_sp = - GetDebugFrameAugmentedUnwindPlan(target, thread)) + if (UnwindPlanSP plan_sp = GetDebugFrameAugmentedUnwindPlan(target, thread)) return plan_sp; - if (std::shared_ptr<const UnwindPlan> plan_sp = - GetEHFrameAugmentedUnwindPlan(target, thread)) + if (UnwindPlanSP plan_sp = GetEHFrameAugmentedUnwindPlan(target, thread)) return plan_sp; - if (std::shared_ptr<const UnwindPlan> plan_sp = - GetObjectFileAugmentedUnwindPlan(target, thread)) + if (UnwindPlanSP plan_sp = GetObjectFileAugmentedUnwindPlan(target, thread)) return plan_sp; return assembly_sp; } -std::shared_ptr<const UnwindPlan> -FuncUnwinders::GetUnwindPlanFastUnwind(Target &target, Thread &thread) { +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; @@ -468,15 +465,17 @@ FuncUnwinders::GetUnwindPlanFastUnwind(Target &target, Thread &thread) { UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target)); if (assembly_profiler_sp) { - auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric); - if (assembly_profiler_sp->GetFastUnwindPlan(m_range, thread, *plan_sp)) - m_unwind_plan_fast_sp = std::move(plan_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; } -std::shared_ptr<const UnwindPlan> -FuncUnwinders::GetUnwindPlanArchitectureDefault(Thread &thread) { +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; @@ -492,7 +491,7 @@ FuncUnwinders::GetUnwindPlanArchitectureDefault(Thread &thread) { return m_unwind_plan_arch_default_sp; } -std::shared_ptr<const UnwindPlan> +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() || @@ -541,8 +540,7 @@ FuncUnwinders::GetUnwindAssemblyProfiler(Target &target) { Address FuncUnwinders::GetLSDAAddress(Target &target) { Address lsda_addr; - std::shared_ptr<const UnwindPlan> unwind_plan_sp = - GetEHFrameUnwindPlan(target); + UnwindPlanSP unwind_plan_sp = GetEHFrameUnwindPlan(target); if (unwind_plan_sp.get() == nullptr) { unwind_plan_sp = GetCompactUnwindUnwindPlan(target); } @@ -558,8 +556,7 @@ Address FuncUnwinders::GetLSDAAddress(Target &target) { Address FuncUnwinders::GetPersonalityRoutinePtrAddress(Target &target) { Address personality_addr; - std::shared_ptr<const UnwindPlan> unwind_plan_sp = - GetEHFrameUnwindPlan(target); + UnwindPlanSP unwind_plan_sp = GetEHFrameUnwindPlan(target); if (unwind_plan_sp.get() == nullptr) { unwind_plan_sp = GetCompactUnwindUnwindPlan(target); } diff --git a/lldb/source/Symbol/UnwindPlan.cpp b/lldb/source/Symbol/UnwindPlan.cpp index cfa8eefaa55bb..f2846eb927bf8 100644 --- a/lldb/source/Symbol/UnwindPlan.cpp +++ b/lldb/source/Symbol/UnwindPlan.cpp @@ -451,7 +451,7 @@ const UnwindPlan::Row *UnwindPlan::GetLastRow() const { return m_row_list.back().get(); } -bool UnwindPlan::PlanValidAtAddress(Address addr) const { +bool UnwindPlan::PlanValidAtAddress(Address addr) { // If this UnwindPlan has no rows, it is an invalid UnwindPlan. if (GetRowCount() == 0) { Log *log = GetLog(LLDBLog::Unwind); diff --git a/lldb/source/Target/RegisterContextUnwind.cpp b/lldb/source/Target/RegisterContextUnwind.cpp index b6a4a71bc3356..cb3d7ee479890 100644 --- a/lldb/source/Target/RegisterContextUnwind.cpp +++ b/lldb/source/Target/RegisterContextUnwind.cpp @@ -84,7 +84,7 @@ RegisterContextUnwind::RegisterContextUnwind(Thread &thread, } bool RegisterContextUnwind::IsUnwindPlanValidForCurrentPC( - std::shared_ptr<const UnwindPlan> unwind_plan_sp) { + lldb::UnwindPlanSP unwind_plan_sp) { if (!unwind_plan_sp) return false; @@ -141,9 +141,8 @@ void RegisterContextUnwind::InitializeZerothFrame() { if (ABISP abi_sp = process->GetABI()) current_pc = abi_sp->FixCodeAddress(current_pc); - std::shared_ptr<const UnwindPlan> lang_runtime_plan_sp = - LanguageRuntime::GetRuntimeUnwindPlan(m_thread, this, - m_behaves_like_zeroth_frame); + 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"); } @@ -266,7 +265,7 @@ void RegisterContextUnwind::InitializeZerothFrame() { // Try the fall back unwind plan since the // full unwind plan failed. FuncUnwindersSP func_unwinders_sp; - std::shared_ptr<const UnwindPlan> call_site_unwind_plan; + UnwindPlanSP call_site_unwind_plan; bool cfa_status = false; if (m_sym_ctx_valid) { @@ -341,9 +340,8 @@ void RegisterContextUnwind::InitializeNonZerothFrame() { // 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. - std::shared_ptr<const UnwindPlan> lang_runtime_plan_sp = - LanguageRuntime::GetRuntimeUnwindPlan(m_thread, this, - m_behaves_like_zeroth_frame); + 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"); } @@ -751,37 +749,39 @@ bool RegisterContextUnwind::BehavesLikeZerothFrame() const { // 4. m_current_offset_backed_up_one should have the current byte offset into // the function, maybe backed up by 1, std::nullopt if unknown -std::shared_ptr<const UnwindPlan> -RegisterContextUnwind::GetFastUnwindPlanForFrame() { +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 nullptr; + return unwind_plan_sp; if (IsFrameZero()) - return nullptr; + return unwind_plan_sp; FuncUnwindersSP func_unwinders_sp( pc_module_sp->GetUnwindTable().GetFuncUnwindersContainingAddress( m_current_pc, m_sym_ctx)); if (!func_unwinders_sp) - return nullptr; + 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 nullptr; + return unwind_plan_sp; - if (std::shared_ptr<const UnwindPlan> unwind_plan_sp = - func_unwinders_sp->GetUnwindPlanFastUnwind( - *m_thread.CalculateTarget(), m_thread)) { + 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 nullptr; + return unwind_plan_sp; } // On entry to this method, @@ -793,9 +793,9 @@ RegisterContextUnwind::GetFastUnwindPlanForFrame() { // 4. m_current_offset_backed_up_one should have the current byte offset into // the function, maybe backed up by 1, std::nullopt if unknown -std::shared_ptr<const UnwindPlan> -RegisterContextUnwind::GetFullUnwindPlanForFrame() { - std::shared_ptr<const UnwindPlan> arch_default_unwind_plan_sp; +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; @@ -833,8 +833,9 @@ RegisterContextUnwind::GetFullUnwindPlanForFrame() { process->GetLoadAddressPermissions(current_pc_addr, permissions) && (permissions & ePermissionsExecutable) == 0)) { if (abi) { + unwind_plan_sp = abi->CreateFunctionEntryUnwindPlan(); m_frame_type = eNormalFrame; - return abi->CreateFunctionEntryUnwindPlan(); + return unwind_plan_sp; } } } @@ -871,29 +872,32 @@ RegisterContextUnwind::GetFullUnwindPlanForFrame() { DWARFCallFrameInfo *eh_frame = pc_module_sp->GetUnwindTable().GetEHFrameInfo(); if (eh_frame) { - auto unwind_plan_sp = - std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric); + 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) { - auto unwind_plan_sp = - std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric); + 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) { - auto unwind_plan_sp = - std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric); + 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; @@ -907,13 +911,15 @@ RegisterContextUnwind::GetFullUnwindPlanForFrame() { // substitute plan. Otherwise, use eh_frame. if (m_sym_ctx_valid) { lldb::PlatformSP platform = process->GetTarget().GetPlatform(); - if (auto unwind_plan_sp = platform->GetTrapHandlerUnwindPlan( - process->GetTarget().GetArchitecture().GetTriple(), - GetSymbolOrFunctionName(m_sym_ctx))) + unwind_plan_sp = platform->GetTrapHandlerUnwindPlan( + process->GetTarget().GetArchitecture().GetTriple(), + GetSymbolOrFunctionName(m_sym_ctx)); + + if (unwind_plan_sp) return unwind_plan_sp; } - auto unwind_plan_sp = + unwind_plan_sp = func_unwinders_sp->GetEHFrameUnwindPlan(process->GetTarget()); if (!unwind_plan_sp) unwind_plan_sp = @@ -938,7 +944,7 @@ RegisterContextUnwind::GetFullUnwindPlanForFrame() { // 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) - auto unwind_plan_sp = + unwind_plan_sp = func_unwinders_sp->GetEHFrameUnwindPlan(process->GetTarget()); if (!unwind_plan_sp) unwind_plan_sp = @@ -954,7 +960,7 @@ RegisterContextUnwind::GetFullUnwindPlanForFrame() { // Typically the NonCallSite UnwindPlan is the unwind created by inspecting // the assembly language instructions if (m_behaves_like_zeroth_frame && process) { - auto unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite( + 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) { @@ -969,7 +975,7 @@ RegisterContextUnwind::GetFullUnwindPlanForFrame() { // 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. - std::shared_ptr<const UnwindPlan> call_site_unwind_plan = + UnwindPlanSP call_site_unwind_plan = func_unwinders_sp->GetUnwindPlanAtCallSite(process->GetTarget(), m_thread); if (call_site_unwind_plan && @@ -1004,7 +1010,6 @@ RegisterContextUnwind::GetFullUnwindPlanForFrame() { } } - std::shared_ptr<const UnwindPlan> unwind_plan_sp; // Typically this is unwind info from an eh_frame section intended for // exception handling; only valid at call sites if (process) { @@ -1037,7 +1042,7 @@ RegisterContextUnwind::GetFullUnwindPlanForFrame() { // 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. - std::shared_ptr<const UnwindPlan> call_site_unwind_plan = + UnwindPlanSP call_site_unwind_plan = func_unwinders_sp->GetUnwindPlanAtCallSite(process->GetTarget(), m_thread); if (call_site_unwind_plan && @@ -1781,8 +1786,7 @@ bool RegisterContextUnwind::TryFallbackUnwindPlan() { // 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'. - std::shared_ptr<const UnwindPlan> original_full_unwind_plan_sp = - m_full_unwind_plan_sp; + UnwindPlanSP original_full_unwind_plan_sp = m_full_unwind_plan_sp; addr_t old_cfa = m_cfa; addr_t old_afa = m_afa; @@ -1911,7 +1915,7 @@ bool RegisterContextUnwind::ForceSwitchToFallbackUnwindPlan() { } void RegisterContextUnwind::PropagateTrapHandlerFlagFromUnwindPlan( - std::shared_ptr<const UnwindPlan> unwind_plan) { + 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 _______________________________________________ lldb-commits mailing list lldb-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
