[Lldb-commits] [lldb] 0949043 - Revert "[lldb] Return *const* UnwindPlan pointers from FuncUnwinders (#133247)"
Vladislav Dzhidzhoev via lldb-commits
lldb-commits at lists.llvm.org
Thu Apr 3 02:34:00 PDT 2025
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
More information about the lldb-commits
mailing list