FuncUnwinders: General clean up and optimization

[labath]

Summary

A large chunk of this file was dealing with the caching of unwind plans.
In this patch I create a helper class to encapsulate this behavior and
leave the functions to deal with the actual work, which is to compute
the actual plan.

Since the caching now is handled by a separate class, it is also
possible to optimize it better without hampering readability. The way I
achieve that is by using a special shared_ptr value to mean "not
initialized" which means we can avoid having a special bool flag for
that purpose. This results in a net decrease of the size of the
FuncUnwinders object.

[clayborg]

include/lldb/Symbol/FuncUnwinders.h

117

maybe use:

llvm::Optional<lldb::UnwindPlanSP> m_plan_sp;

Then just check if it has no value, and if so compute and set it either to a valid shared pointer or an empty one?

[labath]

include/lldb/Symbol/FuncUnwinders.h

117

That would work, but it would increase the size of the FuncUnwinders struct by about 80 bytes (8 bytes for each LazyPlan object). I can do that, but given that "uncomputed value" trick is internal to the class and does not leak out or affect the implementation, it seemed like a worthwhile optimization to me.

[clayborg]

include/lldb/Symbol/FuncUnwinders.h

117

Actually isn't there a pointer union class that can steal bool bits from the aligned values and not increase the size?

[clayborg]

include/lldb/Symbol/FuncUnwinders.h

117

I believe the clang type system steals 3 bits from a Type * to encode "const" and a few other type qualifiers

[labath]

include/lldb/Symbol/FuncUnwinders.h

117

Yes, there is a llvm::PointerIntPair, but AFAICT that only works with a raw pointer, not a shared_ptr. I believe implementing a similar trick for shared_ptr would be possible, but it would definitely be tricky. Way more trickier than this..

include/lldb/Symbol/FuncUnwinders.h

private:
   lldb_private::LazyBool CompareUnwindPlansForIdenticalInitialPCLocation(
       Thread &thread, const lldb::UnwindPlanSP &a, const lldb::UnwindPlanSP &b);
 
   UnwindTable &m_unwind_table;
   AddressRange m_range;
 
   std::recursive_mutex m_mutex;
 
-  lldb::UnwindPlanSP m_unwind_plan_assembly_sp;
-  lldb::UnwindPlanSP m_unwind_plan_eh_frame_sp;
-  lldb::UnwindPlanSP m_unwind_plan_debug_frame_sp;
+  /// A helper class encapsulating the lazy construction of an unwind plan.
+  class LazyPlan {
+    lldb::UnwindPlanSP m_plan_sp;
+
+  public:
+    LazyPlan();
+
+    /// Return the cached unwind plan or call the provided function to compute
+    /// it if we don't have a cached plan yet (and then return it).
+    lldb::UnwindPlanSP Get(llvm::function_ref<lldb::UnwindPlanSP()> compute);
+  };
+
+  LazyPlan m_unwind_plan_assembly;
+  LazyPlan m_unwind_plan_eh_frame;
+  LazyPlan m_unwind_plan_debug_frame;
 
   // augmented by assembly inspection so it's valid everywhere
-  lldb::UnwindPlanSP m_unwind_plan_eh_frame_augmented_sp;
-  lldb::UnwindPlanSP m_unwind_plan_debug_frame_augmented_sp;
+  LazyPlan m_unwind_plan_eh_frame_augmented;
+  LazyPlan m_unwind_plan_debug_frame_augmented;
 
-  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.
-  bool m_tried_unwind_plan_assembly : 1, m_tried_unwind_plan_eh_frame : 1,
-      m_tried_unwind_plan_debug_frame : 1,
-      m_tried_unwind_plan_eh_frame_augmented : 1,
-      m_tried_unwind_plan_debug_frame_augmented : 1,
-      m_tried_unwind_plan_compact_unwind : 1,
-      m_tried_unwind_plan_arm_unwind : 1, m_tried_unwind_plan_symbol_file : 1,
-      m_tried_unwind_fast : 1, m_tried_unwind_arch_default : 1,
-      m_tried_unwind_arch_default_at_func_entry : 1;
+  LazyPlan m_unwind_plan_compact_unwind;
+  LazyPlan m_unwind_plan_arm_unwind;
+  LazyPlan m_unwind_plan_symbol_file;
+  LazyPlan m_unwind_plan_fast;
+  LazyPlan m_unwind_plan_arch_default;
+  LazyPlan m_unwind_plan_arch_default_at_func_entry;
 
   Address m_first_non_prologue_insn;
 
   DISALLOW_COPY_AND_ASSIGN(FuncUnwinders);
 
 }; // class FuncUnwinders
 
 } // namespace lldb_private
 
 #endif // liblldb_FuncUnwinders_h

source/Symbol/FuncUnwinders.cpp

 #include "lldb/Target/Thread.h"
 #include "lldb/Target/UnwindAssembly.h"
 
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
+/// Return a special value meaning the unwind plan hasn't been computed yet.
+static lldb::UnwindPlanSP GetUncomputedMarkerValue() {
+  static auto value_sp = std::make_shared<UnwindPlan>(eRegisterKindGeneric);
+  return value_sp;
+}
+
+FuncUnwinders::LazyPlan::LazyPlan() : m_plan_sp(GetUncomputedMarkerValue()) {}
+
+lldb::UnwindPlanSP
+FuncUnwinders::LazyPlan::Get(llvm::function_ref<lldb::UnwindPlanSP()> compute) {
+  if (m_plan_sp == GetUncomputedMarkerValue())
+    m_plan_sp = compute();
+  return m_plan_sp;
+}
+
 /// 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_debug_frame(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() {}
+    : m_unwind_table(unwind_table), m_range(range) {}
 
 /// destructor
 
 FuncUnwinders::~FuncUnwinders() {}
 
 UnwindPlanSP FuncUnwinders::GetUnwindPlanAtCallSite(Target &target) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
   if (UnwindPlanSP plan_sp = GetEHFrameUnwindPlan(target))
     return plan_sp;
   if (UnwindPlanSP plan_sp = GetDebugFrameUnwindPlan(target))
     return plan_sp;
   if (UnwindPlanSP plan_sp = GetCompactUnwindUnwindPlan(target))
     return plan_sp;
   if (UnwindPlanSP plan_sp = GetArmUnwindUnwindPlan(target))
     return plan_sp;
 
   return nullptr;
 }
 
 UnwindPlanSP FuncUnwinders::GetCompactUnwindUnwindPlan(Target &target) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  if (m_unwind_plan_compact_unwind.size() > 0)
-    return m_unwind_plan_compact_unwind[0]; // FIXME support multiple compact
-                                            // unwind plans for one func
-  if (m_tried_unwind_plan_compact_unwind)
-    return UnwindPlanSP();
 
-  m_tried_unwind_plan_compact_unwind = true;
+  // FIXME support multiple compact unwind plans for one func
+  return m_unwind_plan_compact_unwind.Get([&] {
     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
+        if (compact_unwind->GetUnwindPlan(target, current_pc,
+                                          *unwind_plan_sp)) {
+          return unwind_plan_sp;
         }
       }
     }
     return UnwindPlanSP();
+  });
 }
 
 UnwindPlanSP FuncUnwinders::GetEHFrameUnwindPlan(Target &target) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  if (m_unwind_plan_eh_frame_sp.get() || m_tried_unwind_plan_eh_frame)
-    return m_unwind_plan_eh_frame_sp;
-
-  m_tried_unwind_plan_eh_frame = true;
+  return m_unwind_plan_eh_frame.Get([&] {
     if (m_range.GetBaseAddress().IsValid()) {
-    DWARFCallFrameInfo *eh_frame = m_unwind_table.GetEHFrameInfo();
-    if (eh_frame) {
-      m_unwind_plan_eh_frame_sp =
-          std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
-      if (!eh_frame->GetUnwindPlan(m_range, *m_unwind_plan_eh_frame_sp))
-        m_unwind_plan_eh_frame_sp.reset();
+      if (DWARFCallFrameInfo *eh_frame = m_unwind_table.GetEHFrameInfo()) {
+        auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
+        if (eh_frame->GetUnwindPlan(m_range, *plan_sp))
+          return plan_sp;
       }
     }
-  return m_unwind_plan_eh_frame_sp;
+    return UnwindPlanSP();
+  });
 }
 
 UnwindPlanSP FuncUnwinders::GetDebugFrameUnwindPlan(Target &target) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  if (m_unwind_plan_debug_frame_sp || m_tried_unwind_plan_debug_frame)
-    return m_unwind_plan_debug_frame_sp;
-
-  m_tried_unwind_plan_debug_frame = true;
+  return m_unwind_plan_debug_frame.Get([&] {
     if (m_range.GetBaseAddress().IsValid()) {
-    DWARFCallFrameInfo *debug_frame = m_unwind_table.GetDebugFrameInfo();
-    if (debug_frame) {
-      m_unwind_plan_debug_frame_sp =
-          std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
-      if (!debug_frame->GetUnwindPlan(m_range, *m_unwind_plan_debug_frame_sp))
-        m_unwind_plan_debug_frame_sp.reset();
+      if (DWARFCallFrameInfo *debug_frame =
+              m_unwind_table.GetDebugFrameInfo()) {
+        auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
+        if (debug_frame->GetUnwindPlan(m_range, *plan_sp))
+          return plan_sp;
       }
     }
-  return m_unwind_plan_debug_frame_sp;
+    return UnwindPlanSP();
+  });
 }
 
 UnwindPlanSP FuncUnwinders::GetArmUnwindUnwindPlan(Target &target) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  if (m_unwind_plan_arm_unwind_sp.get() || m_tried_unwind_plan_arm_unwind)
-    return m_unwind_plan_arm_unwind_sp;
-
-  m_tried_unwind_plan_arm_unwind = true;
+  return m_unwind_plan_arm_unwind.Get([&] {
     if (m_range.GetBaseAddress().IsValid()) {
       Address current_pc(m_range.GetBaseAddress());
-    ArmUnwindInfo *arm_unwind_info = m_unwind_table.GetArmUnwindInfo();
-    if (arm_unwind_info) {
-      m_unwind_plan_arm_unwind_sp =
-          std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
-      if (!arm_unwind_info->GetUnwindPlan(target, current_pc,
-                                          *m_unwind_plan_arm_unwind_sp))
-        m_unwind_plan_arm_unwind_sp.reset();
+      if (ArmUnwindInfo *arm_unwind_info = m_unwind_table.GetArmUnwindInfo()) {
+        auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
+        if (arm_unwind_info->GetUnwindPlan(target, current_pc, *plan_sp))
+          return plan_sp;
       }
     }
-  return m_unwind_plan_arm_unwind_sp;
+    return UnwindPlanSP();
+  });
 }
 
 namespace {
 class RegisterContextToInfo: public SymbolFile::RegisterInfoResolver {
 public:
   RegisterContextToInfo(RegisterContext &ctx) : m_ctx(ctx) {}
 
   const RegisterInfo *ResolveName(llvm::StringRef name) const {
     return m_ctx.GetRegisterInfoByName(name);
   }
   const RegisterInfo *ResolveNumber(lldb::RegisterKind kind,
                                     uint32_t number) const {
     return m_ctx.GetRegisterInfo(kind, number);
   }
 
 private:
   RegisterContext &m_ctx;
 };
 } // namespace
 
 UnwindPlanSP FuncUnwinders::GetSymbolFileUnwindPlan(Thread &thread) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  if (m_unwind_plan_symbol_file_sp.get() || m_tried_unwind_plan_symbol_file)
-    return m_unwind_plan_symbol_file_sp;
-
-  m_tried_unwind_plan_symbol_file = true;
+  return m_unwind_plan_symbol_file.Get([&] {
     if (SymbolFile *symfile = m_unwind_table.GetSymbolFile()) {
-    m_unwind_plan_symbol_file_sp = symfile->GetUnwindPlan(
+      return symfile->GetUnwindPlan(
           m_range.GetBaseAddress(),
           RegisterContextToInfo(*thread.GetRegisterContext()));
     }
-  return m_unwind_plan_symbol_file_sp;
+    return UnwindPlanSP();
+  });
 }
 
 UnwindPlanSP FuncUnwinders::GetEHFrameAugmentedUnwindPlan(Target &target,
                                                           Thread &thread) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  if (m_unwind_plan_eh_frame_augmented_sp.get() ||
-      m_tried_unwind_plan_eh_frame_augmented)
-    return m_unwind_plan_eh_frame_augmented_sp;
-
+  return m_unwind_plan_eh_frame_augmented.Get([&] {
     // 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.
+    // 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;
+      return UnwindPlanSP();
     }
 
-  m_tried_unwind_plan_eh_frame_augmented = true;
-
     UnwindPlanSP eh_frame_plan = GetEHFrameUnwindPlan(target);
     if (!eh_frame_plan)
-    return m_unwind_plan_eh_frame_augmented_sp;
-
-  m_unwind_plan_eh_frame_augmented_sp =
-      std::make_shared<UnwindPlan>(*eh_frame_plan);
+      return UnwindPlanSP();
 
     // 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();
+      auto plan_sp = std::make_shared<UnwindPlan>(*eh_frame_plan);
+      if (assembly_profiler_sp->AugmentUnwindPlanFromCallSite(m_range, thread,
+                                                              *plan_sp)) {
+        return plan_sp;
       }
-  } else {
-    m_unwind_plan_eh_frame_augmented_sp.reset();
     }
-  return m_unwind_plan_eh_frame_augmented_sp;
+    return UnwindPlanSP();
+  });
 }
 
 UnwindPlanSP FuncUnwinders::GetDebugFrameAugmentedUnwindPlan(Target &target,
                                                              Thread &thread) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  if (m_unwind_plan_debug_frame_augmented_sp.get() ||
-      m_tried_unwind_plan_debug_frame_augmented)
-    return m_unwind_plan_debug_frame_augmented_sp;
-
+  return m_unwind_plan_debug_frame.Get([&] {
     // 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.
+    // 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;
+      return UnwindPlanSP();
     }
 
-  m_tried_unwind_plan_debug_frame_augmented = true;
-
     UnwindPlanSP debug_frame_plan = GetDebugFrameUnwindPlan(target);
     if (!debug_frame_plan)
-    return m_unwind_plan_debug_frame_augmented_sp;
-
-  m_unwind_plan_debug_frame_augmented_sp =
-      std::make_shared<UnwindPlan>(*debug_frame_plan);
+      return UnwindPlanSP();
 
     // 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;
+      auto plan_sp = std::make_shared<UnwindPlan>(*debug_frame_plan);
+      if (assembly_profiler_sp->AugmentUnwindPlanFromCallSite(m_range, thread,
+                                                              *plan_sp)) {
+        return plan_sp;
+      }
+    }
+    return UnwindPlanSP();
+  });
 }
 
 UnwindPlanSP FuncUnwinders::GetAssemblyUnwindPlan(Target &target,
                                                   Thread &thread) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  if (m_unwind_plan_assembly_sp.get() || m_tried_unwind_plan_assembly ||
-      !m_unwind_table.GetAllowAssemblyEmulationUnwindPlans()) {
-    return m_unwind_plan_assembly_sp;
-  }
-
-  m_tried_unwind_plan_assembly = true;
+  return m_unwind_plan_assembly.Get([&] {
+    if (!m_unwind_table.GetAllowAssemblyEmulationUnwindPlans())
+      return UnwindPlanSP();
 
     UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
     if (assembly_profiler_sp) {
-    m_unwind_plan_assembly_sp =
-        std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
-    if (!assembly_profiler_sp->GetNonCallSiteUnwindPlanFromAssembly(
-            m_range, thread, *m_unwind_plan_assembly_sp)) {
-      m_unwind_plan_assembly_sp.reset();
+      auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
+      if (assembly_profiler_sp->GetNonCallSiteUnwindPlanFromAssembly(
+              m_range, thread, *plan_sp)) {
+        return plan_sp;
       }
     }
-  return m_unwind_plan_assembly_sp;
+    return lldb::UnwindPlanSP();
+  });
 }
 
 // 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;
if (UnwindPlanSP plan_sp = GetDebugFrameAugmentedUnwindPlan(target, thread))
     return plan_sp;
 
   return assembly_sp;
 }
 
 UnwindPlanSP FuncUnwinders::GetUnwindPlanFastUnwind(Target &target,
                                                     Thread &thread) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  if (m_unwind_plan_fast_sp.get() || m_tried_unwind_fast)
-    return m_unwind_plan_fast_sp;
-
-  m_tried_unwind_fast = true;
-
+  return m_unwind_plan_fast.Get([&] {
     UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
     if (assembly_profiler_sp) {
-    m_unwind_plan_fast_sp =
-        std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
-    if (!assembly_profiler_sp->GetFastUnwindPlan(m_range, thread,
-                                                 *m_unwind_plan_fast_sp)) {
-      m_unwind_plan_fast_sp.reset();
-    }
+      auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
+      if (assembly_profiler_sp->GetFastUnwindPlan(m_range, thread, *plan_sp))
+        return plan_sp;
     }
-  return m_unwind_plan_fast_sp;
+    return UnwindPlanSP();
+  });
 }
 
 UnwindPlanSP FuncUnwinders::GetUnwindPlanArchitectureDefault(Thread &thread) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  if (m_unwind_plan_arch_default_sp.get() || m_tried_unwind_arch_default)
-    return m_unwind_plan_arch_default_sp;
-
-  m_tried_unwind_arch_default = true;
-
-  Address current_pc;
-  ProcessSP process_sp(thread.CalculateProcess());
-  if (process_sp) {
-    ABI *abi = process_sp->GetABI().get();
-    if (abi) {
-      m_unwind_plan_arch_default_sp =
-          std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
-      if (!abi->CreateDefaultUnwindPlan(*m_unwind_plan_arch_default_sp)) {
-        m_unwind_plan_arch_default_sp.reset();
-      }
+  return m_unwind_plan_arch_default.Get([&] {
+    if (ProcessSP process_sp = thread.CalculateProcess()) {
+      if (ABI *abi = process_sp->GetABI().get()) {
+        auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
+        if (abi->CreateDefaultUnwindPlan(*plan_sp))
+          return plan_sp;
       }
     }
-
-  return m_unwind_plan_arch_default_sp;
+    return UnwindPlanSP();
+  });
 }
 
 UnwindPlanSP
 FuncUnwinders::GetUnwindPlanArchitectureDefaultAtFunctionEntry(Thread &thread) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  if (m_unwind_plan_arch_default_at_func_entry_sp.get() ||
-      m_tried_unwind_arch_default_at_func_entry)
-    return m_unwind_plan_arch_default_at_func_entry_sp;
-
-  m_tried_unwind_arch_default_at_func_entry = true;
-
-  Address current_pc;
-  ProcessSP process_sp(thread.CalculateProcess());
-  if (process_sp) {
-    ABI *abi = process_sp->GetABI().get();
-    if (abi) {
-      m_unwind_plan_arch_default_at_func_entry_sp =
-          std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
-      if (!abi->CreateFunctionEntryUnwindPlan(
-              *m_unwind_plan_arch_default_at_func_entry_sp)) {
-        m_unwind_plan_arch_default_at_func_entry_sp.reset();
-      }
+  return m_unwind_plan_arch_default_at_func_entry.Get([&] {
+    if (ProcessSP process_sp = thread.CalculateProcess()) {
+      if (ABI *abi = process_sp->GetABI().get()) {
+        auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
+        if (abi->CreateFunctionEntryUnwindPlan(*plan_sp))
+          return plan_sp;
       }
     }
-
-  return m_unwind_plan_arch_default_at_func_entry_sp;
+    return UnwindPlanSP();
+  });
 }
 
 Address &FuncUnwinders::GetFirstNonPrologueInsn(Target &target) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_first_non_prologue_insn.IsValid())
     return m_first_non_prologue_insn;
 
   ExecutionContext exe_ctx(target.shared_from_this(), false);