FuncUnwinders: Factor out address validity check

[labath]

Summary

Some (but not all) of the unwind plan creation functions were checking
the validity of their address range before they attempted to create the
unwind plan.

Since a FuncUnwinders object cannot do anything reasonable with an
invalid address range, in this patch I remove the checks in from the
creation functions, and instead make it's validity a class invariant.
This makes it the responsibility of whoever's creating the FuncUnwinders
to ensure it does that with a valid address range, which is easy to
achieve as there is only one place we are doing that.

include/lldb/Symbol/FuncUnwinders.h

public:
   //      limited set of registers necessary to walk the stack
   //   4. An architectural default unwind plan when none of the above are
   //      available for some reason.
 
   // Additionally, FuncUnwinds object can be asked where the prologue
   // instructions are finished for migrating breakpoints past the stack frame
   // setup instructions when we don't have line table information.
 
+  /// Create the FuncUnwinders object for the given address range. The object
+  /// will use the data from the given UnwindTable for UnwindPlan generation.
+  /// The input address range must be valid.
   FuncUnwinders(lldb_private::UnwindTable &unwind_table, AddressRange range);
 
   ~FuncUnwinders();
 
   lldb::UnwindPlanSP GetUnwindPlanAtCallSite(Target &target);
 
   lldb::UnwindPlanSP GetUnwindPlanAtNonCallSite(Target &target,
                                                 lldb_private::Thread &thread);

source/Symbol/FuncUnwinders.cpp

: m_unwind_table(unwind_table), m_range(range), m_mutex(),
       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_fast(false),
       m_tried_unwind_arch_default(false),
       m_tried_unwind_arch_default_at_func_entry(false),
-      m_first_non_prologue_insn() {}
+      m_first_non_prologue_insn() {
+  assert(range.GetBaseAddress().IsValid());
+}
 
 /// destructor
 
 FuncUnwinders::~FuncUnwinders() {}
 
 UnwindPlanSP FuncUnwinders::GetUnwindPlanAtCallSite(Target &target) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
UnwindPlanSP FuncUnwinders::GetCompactUnwindUnwindPlan(Target &target) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_unwind_plan_compact_unwind.size() > 0)
     return m_unwind_plan_compact_unwind[0]; // FIXME support multiple compact
                                             // unwind plans for one func
   if (m_tried_unwind_plan_compact_unwind)
     return UnwindPlanSP();
 
   m_tried_unwind_plan_compact_unwind = true;
-  if (m_range.GetBaseAddress().IsValid()) {
-    Address current_pc(m_range.GetBaseAddress());
-    CompactUnwindInfo *compact_unwind = m_unwind_table.GetCompactUnwindInfo();
-    if (compact_unwind) {
-      UnwindPlanSP unwind_plan_sp(new UnwindPlan(lldb::eRegisterKindGeneric));
-      if (compact_unwind->GetUnwindPlan(target, current_pc, *unwind_plan_sp)) {
-        m_unwind_plan_compact_unwind.push_back(unwind_plan_sp);
-        return m_unwind_plan_compact_unwind[0]; // FIXME support multiple
-                                                // compact unwind plans for one
-                                                // func
-      }
-    }
-  }
   return UnwindPlanSP();
 }
 
 UnwindPlanSP FuncUnwinders::GetEHFrameUnwindPlan(Target &target) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_unwind_plan_eh_frame_sp.get() || m_tried_unwind_plan_eh_frame)
     return m_unwind_plan_eh_frame_sp;
 
   m_tried_unwind_plan_eh_frame = true;
-  if (m_range.GetBaseAddress().IsValid()) {
-    DWARFCallFrameInfo *eh_frame = m_unwind_table.GetEHFrameInfo();
-    if (eh_frame) {
-      m_unwind_plan_eh_frame_sp =
-          std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
-      if (!eh_frame->GetUnwindPlan(m_range, *m_unwind_plan_eh_frame_sp))
-        m_unwind_plan_eh_frame_sp.reset();
-    }
-  }
   return m_unwind_plan_eh_frame_sp;
 }
 
 UnwindPlanSP FuncUnwinders::GetDebugFrameUnwindPlan(Target &target) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_unwind_plan_debug_frame_sp || m_tried_unwind_plan_debug_frame)
     return m_unwind_plan_debug_frame_sp;
 
   m_tried_unwind_plan_debug_frame = true;
-  if (m_range.GetBaseAddress().IsValid()) {
-    DWARFCallFrameInfo *debug_frame = m_unwind_table.GetDebugFrameInfo();
-    if (debug_frame) {
-      m_unwind_plan_debug_frame_sp =
-          std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
-      if (!debug_frame->GetUnwindPlan(m_range, *m_unwind_plan_debug_frame_sp))
-        m_unwind_plan_debug_frame_sp.reset();
-    }
-  }
+    if (!debug_frame->GetUnwindPlan(m_range,
+                                    *m_unwind_plan_debug_frame_sp))
   return m_unwind_plan_debug_frame_sp;
 }
 
 UnwindPlanSP FuncUnwinders::GetArmUnwindUnwindPlan(Target &target) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_unwind_plan_arm_unwind_sp.get() || m_tried_unwind_plan_arm_unwind)
     return m_unwind_plan_arm_unwind_sp;
 
   m_tried_unwind_plan_arm_unwind = true;
-  if (m_range.GetBaseAddress().IsValid()) {
-    Address current_pc(m_range.GetBaseAddress());
-    ArmUnwindInfo *arm_unwind_info = m_unwind_table.GetArmUnwindInfo();
-    if (arm_unwind_info) {
-      m_unwind_plan_arm_unwind_sp =
-          std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
-      if (!arm_unwind_info->GetUnwindPlan(target, current_pc,
-                                          *m_unwind_plan_arm_unwind_sp))
-        m_unwind_plan_arm_unwind_sp.reset();
-    }
-  }
   return m_unwind_plan_arm_unwind_sp;
 }
 
 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)

source/Symbol/UnwindTable.cpp

llvm::Optional<AddressRange> UnwindTable::GetAddressRange(const Address &addr,
 
   // First check the symbol context
   if (sc.GetAddressRange(eSymbolContextFunction | eSymbolContextSymbol, 0,
                          false, range) &&
       range.GetBaseAddress().IsValid())
     return range;
 
   // Does the eh_frame unwind info has a function bounds for this addr?
-  if (m_eh_frame_up && m_eh_frame_up->GetAddressRange(addr, range))
+  if (m_eh_frame_up && m_eh_frame_up->GetAddressRange(addr, range) &&
+      range.GetBaseAddress().IsValid())
     return range;
 
   // Try debug_frame as well
-  if (m_debug_frame_up && m_debug_frame_up->GetAddressRange(addr, range))
+  if (m_debug_frame_up && m_debug_frame_up->GetAddressRange(addr, range) &&
+      range.GetBaseAddress().IsValid())
     return range;
 
   return llvm::None;
 }
 
 FuncUnwindersSP
 UnwindTable::GetFuncUnwindersContainingAddress(const Address &addr,
                                                SymbolContext &sc) {