[lldb] Add step target to ThreadPlanStepInRange constructor

[kastiglione]

Summary

QueueThreadPlanForStepInRange accepts a step_into_target, but the constructor for
ThreadPlanStepInRange does not. Instead, a caller would optionally call SetStepInTarget().

This change adds step_into_target as a constructor argument. This simplifies
construction of ThreadPlanSP, by avoiding a subsequent downcast and conditional
assignment. This constructor is already used in downstream repos.

[kastiglione]

Improved wording in summary

[jingham]

I must have thought there would be a case where you wouldn't be able to figure out the target right when you made the plan, but since that possibility never arose, this simplification is fine.

lldb/include/lldb/Target/ThreadPlanStepInRange.h

 
 namespace lldb_private {
 
 class ThreadPlanStepInRange : public ThreadPlanStepRange,
                               public ThreadPlanShouldStopHere {
 public:
   ThreadPlanStepInRange(Thread &thread, const AddressRange &range,
                         const SymbolContext &addr_context,
-                        lldb::RunMode stop_others,
+                        const char *step_into_target, lldb::RunMode stop_others,
                         LazyBool step_in_avoids_code_without_debug_info,
                         LazyBool step_out_avoids_code_without_debug_info);
 
   ~ThreadPlanStepInRange() override;
 
   void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
 
   bool ShouldStop(Event *event_ptr) override;
 
   void SetAvoidRegexp(const char *name);
 
-  void SetStepInTarget(const char *target) {
-    m_step_into_target.SetCString(target);
-  }
-
   static void SetDefaultFlagValue(uint32_t new_value);
 
   bool IsVirtualStep() override;
 
   // Plans that are implementing parts of a step in might need to follow the
   // behavior of this plan w.r.t. StepThrough.  They can get that from here.
   static uint32_t GetDefaultFlagsValue() {
     return s_default_flag_values;

lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.cpp

if (callable_info.callable_case != LibCppStdFunctionCallableCase::Invalid &&
       ret_plan_sp = std::make_shared<ThreadPlanRunToAddress>(
           thread, callable_info.callable_address, stop_others);
       return ret_plan_sp;
     } else {
       // We are in std::function but we could not obtain the callable.
       // We create a ThreadPlan to keep stepping through using the address range
       // of the current function.
       ret_plan_sp = std::make_shared<ThreadPlanStepInRange>(
-          thread, range_of_curr_func, sc, eOnlyThisThread, eLazyBoolYes,
-          eLazyBoolYes);
+          thread, range_of_curr_func, sc, nullptr, eOnlyThisThread,
+          eLazyBoolYes, eLazyBoolYes);
       return ret_plan_sp;
     }
   }
 
   return ret_plan_sp;
 }

lldb/source/Target/Thread.cpp

 }
 
 ThreadPlanSP Thread::QueueThreadPlanForStepInRange(
     bool abort_other_plans, const AddressRange &range,
     const SymbolContext &addr_context, const char *step_in_target,
     lldb::RunMode stop_other_threads, Status &status,
     LazyBool step_in_avoids_code_without_debug_info,
     LazyBool step_out_avoids_code_without_debug_info) {
-  ThreadPlanSP thread_plan_sp(
-      new ThreadPlanStepInRange(*this, range, addr_context, stop_other_threads,
-                                step_in_avoids_code_without_debug_info,
-                                step_out_avoids_code_without_debug_info));
-  ThreadPlanStepInRange *plan =
-      static_cast<ThreadPlanStepInRange *>(thread_plan_sp.get());
-
-  if (step_in_target)
-    plan->SetStepInTarget(step_in_target);
-
+  ThreadPlanSP thread_plan_sp(new ThreadPlanStepInRange(
+      *this, range, addr_context, step_in_target, stop_other_threads,
   status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
   return thread_plan_sp;
 }
 
 // Call the QueueThreadPlanForStepInRange method which takes an address range.
 ThreadPlanSP Thread::QueueThreadPlanForStepInRange(
     bool abort_other_plans, const LineEntry &line_entry,
     const SymbolContext &addr_context, const char *step_in_target,

lldb/source/Target/ThreadPlanStepInRange.cpp

 uint32_t ThreadPlanStepInRange::s_default_flag_values =
     ThreadPlanShouldStopHere::eStepInAvoidNoDebug;
 
 // ThreadPlanStepInRange: Step through a stack range, either stepping over or
 // into based on the value of \a type.
 
 ThreadPlanStepInRange::ThreadPlanStepInRange(
     Thread &thread, const AddressRange &range,
-    const SymbolContext &addr_context, lldb::RunMode stop_others,
-    LazyBool step_in_avoids_code_without_debug_info,
+    const SymbolContext &addr_context, const char *step_into_target,
+    lldb::RunMode stop_others, LazyBool step_in_avoids_code_without_debug_info,
     LazyBool step_out_avoids_code_without_debug_info)
     : ThreadPlanStepRange(ThreadPlan::eKindStepInRange,
                           "Step Range stepping in", thread, range, addr_context,
                           stop_others),
       ThreadPlanShouldStopHere(this), m_step_past_prologue(true),
-      m_virtual_step(false) {
+      m_virtual_step(false), m_step_into_target(step_into_target) {
   SetCallbacks();
   SetFlagsToDefault();
   SetupAvoidNoDebug(step_in_avoids_code_without_debug_info,
                     step_out_avoids_code_without_debug_info);
 }
 
 ThreadPlanStepInRange::~ThreadPlanStepInRange() = default;