Parametrize scripted ThreadPlans using SBStructuredData

[jingham]

Summary

It is trivial to write a ScriptedThreadPlan to do "step until the variable 'foo' changes value". It is equally easy to write one that does "step until the variable 'bar' changes value". But you would have to write a different Python class for each of these tasks, since there's no way to pass parameters into the ThreadPlan on creation.

This patch adds that ability. You can say:

(lldb) thread step-scripted -C Module.ThreadPlan -k variable_name -v foo

lldb will package the key and value into an SBStructuredData dictionary, and pass that to the init method of the ThreadPlan class. Then the ThreadPlan can fetch the value for that key from the dictionary and watch that variable.

I also added an SB API that allows you to pass any SBStructuredData to SBThread.StepUsingScriptedThreadPlan, if you need to pass in something more complex than a simple key/value dictionary.

This revision depends on:

https://reviews.llvm.org/D68363

Not sure who to put on to review this, most of the folks who worked actively on the PythonObjects aren't really active anymore... I added folks who touched some of the relevant files recently...

[jingham]

Missed a bit that removed m_class_name from the old command options (and didn't use the new option.)

[aprantl]

From a purely mechanical point of view, this lgtm.

[JDevlieghere]

lldb/include/lldb/Target/ThreadPlanPython.h

35 ↗

(On Diff #222952)

Why do we need the StructuredDataImpl and not the StructuredData?

lldb/source/API/SBThread.cpp

985 ↗

(On Diff #222952)

It appears this is missing a corresponding LLDB_REGISTER macro.

lldb/source/API/SBThreadPlan.cpp

78 ↗

(On Diff #222952)

Same here

404 ↗

(On Diff #222952)

This one is fine it seems.

409 ↗

(On Diff #222952)

Swap this and have an early return?

[jingham]

Added the missing REGISTER macros

[jingham]

lldb/include/lldb/Target/ThreadPlanPython.h

35 ↗

(On Diff #222952)

I figured out that I had to do it this way when I implemented the same feature as part of the ScriptedBreakpointResolvers. This change is largely copied from that. But I don't remember why now.

I'll go back and figure that out again if you are really curious, but since this is following a successful precedent, I'd rather not do that right now...

lldb/source/API/SBThreadPlan.cpp

409 ↗

(On Diff #222952)

Every other function in this file is written this way. I don't want to fix them piecemeal, and doing them all here would make this commit too hard to read.

lldb/trunk/include/lldb/API/SBStructuredData.h

public:
   ///     Returns the byte size needed to completely write the string value at
   ///     \a dst in all cases.
   size_t GetStringValue(char *dst, size_t dst_len) const;
 
 protected:
   friend class SBTraceOptions;
   friend class SBDebugger;
   friend class SBTarget;
+  friend class SBThread;
+  friend class SBThreadPlan;
 
   StructuredDataImplUP m_impl_up;
 };
 } // namespace lldb
 
 #endif /* SBStructuredData_h */

lldb/trunk/include/lldb/API/SBThread.h

public:
   SBError StepOverUntil(lldb::SBFrame &frame, lldb::SBFileSpec &file_spec,
                         uint32_t line);
 
   SBError StepUsingScriptedThreadPlan(const char *script_class_name);
 
   SBError StepUsingScriptedThreadPlan(const char *script_class_name,
                                       bool resume_immediately);
 
+  SBError StepUsingScriptedThreadPlan(const char *script_class_name,
+                                      lldb::SBStructuredData &args_data,
+                                      bool resume_immediately);
+
   SBError JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line);
 
   void RunToAddress(lldb::addr_t addr);
 
   void RunToAddress(lldb::addr_t addr, SBError &error);
 
   SBError ReturnFromFrame(SBFrame &frame, SBValue &return_value);
 

lldb/trunk/include/lldb/API/SBThreadPlan.h

public:
   SBThreadPlan();
 
   SBThreadPlan(const lldb::SBThreadPlan &threadPlan);
 
   SBThreadPlan(const lldb::ThreadPlanSP &lldb_object_sp);
 
   SBThreadPlan(lldb::SBThread &thread, const char *class_name);
 
+  SBThreadPlan(lldb::SBThread &thread, const char *class_name, 
+               lldb::SBStructuredData &args_data);
+
   ~SBThreadPlan();
 
   explicit operator bool() const;
 
   bool IsValid() const;
 
   void Clear();
 
public:
 
   SBThreadPlan QueueThreadPlanForRunToAddress(SBAddress address);
   SBThreadPlan QueueThreadPlanForRunToAddress(SBAddress address,
                                               SBError &error);
 
   SBThreadPlan QueueThreadPlanForStepScripted(const char *script_class_name);
   SBThreadPlan QueueThreadPlanForStepScripted(const char *script_class_name,
                                               SBError &error);
+  SBThreadPlan QueueThreadPlanForStepScripted(const char *script_class_name,
+                                              lldb::SBStructuredData &args_data,
+                                              SBError &error);
 
 private:
   friend class SBBreakpoint;
   friend class SBBreakpointLocation;
   friend class SBFrame;
   friend class SBProcess;
   friend class SBDebugger;
   friend class SBValue;

lldb/trunk/include/lldb/Interpreter/ScriptInterpreter.h

public:
   virtual StructuredData::DictionarySP
   OSPlugin_CreateThread(StructuredData::ObjectSP os_plugin_object_sp,
                         lldb::tid_t tid, lldb::addr_t context) {
     return StructuredData::DictionarySP();
   }
 
   virtual StructuredData::ObjectSP
   CreateScriptedThreadPlan(const char *class_name,
+                           StructuredDataImpl *args_data,
                            std::string &error_str,
                            lldb::ThreadPlanSP thread_plan_sp) {
     return StructuredData::ObjectSP();
   }
 
   virtual bool
   ScriptedThreadPlanExplainsStop(StructuredData::ObjectSP implementor_sp,
                                  Event *event, bool &script_error) {

lldb/trunk/include/lldb/Target/Thread.h

QueueThreadPlanForRunToAddress(bool abort_other_plans, Address &target_addr,
                                  bool stop_other_threads, Status &status);
 
   virtual lldb::ThreadPlanSP QueueThreadPlanForStepUntil(
       bool abort_other_plans, lldb::addr_t *address_list, size_t num_addresses,
       bool stop_others, uint32_t frame_idx, Status &status);
 
   virtual lldb::ThreadPlanSP
   QueueThreadPlanForStepScripted(bool abort_other_plans, const char *class_name,
+                                 StructuredData::ObjectSP extra_args_sp,  
                                  bool stop_other_threads, Status &status);
 
   // Thread Plan accessors:
 
   /// Gets the plan which will execute next on the plan stack.
   ///
   /// \return
   ///     A pointer to the next executed plan.

lldb/trunk/include/lldb/Target/ThreadPlanPython.h

 //===-- ThreadPlanPython.h --------------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ThreadPlan_Python_h_
 #define liblldb_ThreadPlan_Python_h_
 
 #include <string>
 
+#include "lldb/lldb-forward.h"
+
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanTracer.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 //  ThreadPlanPython:
 //
 
 class ThreadPlanPython : public ThreadPlan {
 public:
-  ThreadPlanPython(Thread &thread, const char *class_name);
+  ThreadPlanPython(Thread &thread, const char *class_name, 
+                   StructuredDataImpl *args_data);
   ~ThreadPlanPython() override;
 
   void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
 
   bool ValidatePlan(Stream *error) override;
 
   bool ShouldStop(Event *event_ptr) override;
 

 
 protected:
   bool DoPlanExplainsStop(Event *event_ptr) override;
 
   lldb::StateType GetPlanRunState() override;
 
 private:
   std::string m_class_name;
+  StructuredDataImpl *m_args_data; // We own this, but the implementation
+                                   // has to manage the UP (since that is
+                                   // how it gets stored in the
+                                   // SBStructuredData).
   std::string m_error_str;
   StructuredData::ObjectSP m_implementation_sp;
   bool m_did_push;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadPlanPython);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ThreadPlan_Python_h_

lldb/trunk/packages/Python/lldbsuite/test/commands/help/TestHelp.py

def test_help_run_hides_options(self):
         """Test that 'help run' does not show all the options for process launch"""
         self.expect("help run",
                     substrs=['--arch', '--environment'], matching=False)
 
     @no_debug_info_test
     def test_help_next_shows_options(self):
         """Test that 'help next' shows all the options for thread step-over"""
         self.expect("help next",
-                    substrs=['--python-class', '--run-mode'], matching=True)
+                    substrs=['--step-out-avoids-no-debug', '--run-mode'], matching=True)
 
     @no_debug_info_test
     def test_help_provides_alternatives(self):
         """Test that help on commands that don't exist provides information on additional help avenues"""
         self.expect(
             "help thisisnotadebuggercommand",
             substrs=[
                 "'thisisnotadebuggercommand' is not a known command.",

lldb/trunk/packages/Python/lldbsuite/test/functionalities/step_scripted/Steps.py

class StepScripted(StepWithChild):
     def __init__(self, thread_plan, dict):
         StepWithChild.__init__(self, thread_plan)
 
     def queue_child_thread_plan(self):
         return self.thread_plan.QueueThreadPlanForStepScripted("Steps.StepOut")
 
 # This plan does a step-over until a variable changes value.
 class StepUntil(StepWithChild):
-    def __init__(self, thread_plan, dict):
+    def __init__(self, thread_plan, args_data, dict):
         self.frame = thread_plan.GetThread().frames[0]
         self.target = thread_plan.GetThread().GetProcess().GetTarget()
-        self.value = self.frame.FindVariable("foo")
+        func_entry = args_data.GetValueForKey("variable_name")
+        
+        if not func_entry.IsValid():
+            print("Did not get a valid entry for variable_name")
+        func_name = func_entry.GetStringValue(100)
+
+        self.value = self.frame.FindVariable(func_name)
+        if self.value.GetError().Fail():
+            print("Failed to get foo value: %s"%(self.value.GetError().GetCString()))
+        else:
+            print("'foo' value: %d"%(self.value.GetValueAsUnsigned()))
+
         StepWithChild.__init__(self, thread_plan)
 
+
     def queue_child_thread_plan(self):
         le = self.frame.GetLineEntry()
         start_addr = le.GetStartAddress() 
         start = start_addr.GetLoadAddress(self.target)
         end = le.GetEndAddress().GetLoadAddress(self.target)
-        print("Stepping from 0x%x to 0x%x (0x%x)"%(start, end, end - start))
         return self.thread_plan.QueueThreadPlanForStepOverRange(start_addr,
                                                                 end - start)
 
     def should_stop(self, event):
         if not self.child_thread_plan.IsPlanComplete():
             return False
 
         # If we've stepped out of this frame, stop.

lldb/trunk/packages/Python/lldbsuite/test/functionalities/step_scripted/TestStepScripted.py

def test_misspelled_plan_name(self):
         self.assertTrue(err.Fail(), "We got a failure state")
         msg = err.GetCString()
         self.assertTrue("NoSuchModule.NoSuchPlan" in msg, "Mentioned missing class")
         
         # Make sure we didn't let the process run:
         self.assertEqual(stop_id, process.GetStopID(), "Process didn't run")
         
     def test_checking_variable(self):
-        """Test that we can call SBValue API's from a scripted thread plan"""
+        """Test that we can call SBValue API's from a scripted thread plan - using SBAPI's to step"""
+        self.do_test_checking_variable(False)
+        
+    def test_checking_variable_cli(self):
+        """Test that we can call SBValue API's from a scripted thread plan - using cli to step"""
+        self.do_test_checking_variable(True)
+        
+    def do_test_checking_variable(self, use_cli):
         self.build()
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                                                             "Set a breakpoint here",
                                                                             self.main_source_file)
 
         frame = thread.GetFrameAtIndex(0)
         self.assertEqual("foo", frame.GetFunctionName())
         foo_val = frame.FindVariable("foo")
         self.assertTrue(foo_val.GetError().Success(), "Got the foo variable")
         self.assertEqual(foo_val.GetValueAsUnsigned(), 10, "foo starts at 10")
 
-        err = thread.StepUsingScriptedThreadPlan("Steps.StepUntil")
+        if use_cli:
+            result = lldb.SBCommandReturnObject()
+            self.dbg.GetCommandInterpreter().HandleCommand(
+                "thread step-scripted -C Steps.StepUntil -k variable_name -v foo",
+                result)
+            self.assertTrue(result.Succeeded())
+        else:
+            args_data = lldb.SBStructuredData()
+            data = lldb.SBStream()
+            data.Print('{"variable_name" : "foo"}')
+            error = args_data.SetFromJSON(data)
+            self.assertTrue(error.Success(), "Made the args_data correctly")
+
+            err = thread.StepUsingScriptedThreadPlan("Steps.StepUntil", args_data, True)
             self.assertTrue(err.Success(), err.GetCString())
 
         # We should not have exited:
         self.assertEqual(process.GetState(), lldb.eStateStopped, "We are stopped")
         
         # We should still be in foo:
         self.assertEqual("foo", frame.GetFunctionName())
 
         # And foo should have changed:
         self.assertTrue(foo_val.GetValueDidChange(), "Foo changed")

lldb/trunk/scripts/Python/python-wrapper.swig

)
     Py_RETURN_NONE;
 }
 
 SWIGEXPORT void*
 LLDBSwigPythonCreateScriptedThreadPlan
 (
     const char *python_class_name,
     const char *session_dictionary_name,
+    lldb_private::StructuredDataImpl *args_impl,
     std::string &error_string,
     const lldb::ThreadPlanSP& thread_plan_sp
 )
 {
     using namespace lldb_private;
 
     if (python_class_name == NULL || python_class_name[0] == '\0' || !session_dictionary_name)
         Py_RETURN_NONE;
if (!pfunc.IsAllocated()) {
         return nullptr;
     }
 
     PythonObject tp_arg(PyRefType::Owned, SBTypeToSWIGWrapper(tp_value));
 
     if (!tp_arg.IsAllocated())
         Py_RETURN_NONE;
 
-    PythonObject result = pfunc(tp_arg, dict);
+    PythonObject result = {};
+    size_t init_num_args = pfunc.GetNumInitArguments().count;
+    if (init_num_args == 3) {
+        if (args_impl != nullptr) {
+           error_string.assign("args passed, but __init__ does not take an args dictionary");
+           Py_RETURN_NONE;
+        }
+        result = pfunc(tp_arg, dict);
+    } else if (init_num_args = 4) {
+        lldb::SBStructuredData *args_value = new lldb::SBStructuredData(args_impl);
+        PythonObject args_arg(PyRefType::Owned, SBTypeToSWIGWrapper(args_value));
+        result = pfunc(tp_arg, args_arg, dict);
+    } else {
+        error_string.assign("wrong number of arguments in __init__, should be 1 or 2 (not including self & dict)");
+        Py_RETURN_NONE;
+    }
+
     // FIXME: At this point we should check that the class we found supports all the methods
     // that we need.
 
     if (result.IsAllocated())
         return result.release();
     Py_RETURN_NONE;
 }
 

lldb/trunk/scripts/interface/SBThread.i

~SBThread();
 
     SBError
     StepUsingScriptedThreadPlan (const char *script_class_name);
 
     SBError
     StepUsingScriptedThreadPlan (const char *script_class_name, bool resume_immediately);
 
     SBError
+    StepUsingScriptedThreadPlan(const char *script_class_name,
+                                lldb::SBStructuredData &args_data,
+                                bool resume_immediately);
+
+    SBError
     JumpToLine (lldb::SBFileSpec &file_spec, uint32_t line);
 
     void
     RunToAddress (lldb::addr_t addr);
 
     void
     RunToAddress (lldb::addr_t addr, SBError &error);
 

lldb/trunk/scripts/interface/SBThreadPlan.i

~SBThreadPlan ();
     QueueThreadPlanForStepOut (uint32_t frame_idx_to_step_to, bool first_insn = false);
 
     SBThreadPlan
     QueueThreadPlanForRunToAddress (SBAddress address);
 
     SBThreadPlan
     QueueThreadPlanForStepScripted(const char *script_class_name);
 
+    SBThreadPlan
+    QueueThreadPlanForStepScripted(const char *script_class_name,
+                                   SBError &error);
+    SBThreadPlan
+    QueueThreadPlanForStepScripted(const char *script_class_name,
+                                   SBStructuredData &args_data,
+                                   SBError &error);
+
 
 protected:
     friend class SBBreakpoint;
     friend class SBBreakpointLocation;
     friend class SBFrame;
     friend class SBProcess;
     friend class SBDebugger;
     friend class SBValue;

lldb/trunk/source/API/SBThread.cpp

 #include "Utils.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStream.h"
+#include "lldb/API/SBStructuredData.h"
 #include "lldb/API/SBSymbolContext.h"
 #include "lldb/API/SBThreadCollection.h"
 #include "lldb/API/SBThreadPlan.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/StreamFile.h"
+#include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Queue.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/SystemRuntime.h"
SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name) {
   LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
                      (const char *), script_class_name);
 
   return LLDB_RECORD_RESULT(
       StepUsingScriptedThreadPlan(script_class_name, true));
 }
 
 SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
-                                              bool resume_immediately) {
   LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
-                     (const char *, bool), script_class_name,
+                     (const char *, bool), script_class_name, 
                      resume_immediately);
 
+  lldb::SBStructuredData no_data;
+  return LLDB_RECORD_RESULT(
+      StepUsingScriptedThreadPlan(script_class_name, 
+                                  no_data, 
+                                  resume_immediately));
+}
+
+SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
+                                              SBStructuredData &args_data,
+                                              bool resume_immediately) {
+  LLDB_RECORD_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
+                     (const char *, lldb::SBStructuredData &, bool), 
+                     script_class_name, args_data,
+                     resume_immediately);
+
   SBError error;
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (!exe_ctx.HasThreadScope()) {
     error.SetErrorString("this SBThread object is invalid");
     return LLDB_RECORD_RESULT(error);
   }
 
   Thread *thread = exe_ctx.GetThreadPtr();
   Status new_plan_status;
+  StructuredData::ObjectSP obj_sp = args_data.m_impl_up->GetObjectSP();
+
   ThreadPlanSP new_plan_sp = thread->QueueThreadPlanForStepScripted(
-      false, script_class_name, false, new_plan_status);
+      false, script_class_name, obj_sp, false, new_plan_status);
 
   if (new_plan_status.Fail()) {
     error.SetErrorString(new_plan_status.AsCString());
     return LLDB_RECORD_RESULT(error);
   }
 
   if (!resume_immediately)
     return LLDB_RECORD_RESULT(error);
void RegisterMethods<SBThread>(Registry &R) {
   LLDB_REGISTER_METHOD(void, SBThread, RunToAddress,
                        (lldb::addr_t, lldb::SBError &));
   LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepOverUntil,
                        (lldb::SBFrame &, lldb::SBFileSpec &, uint32_t));
   LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
                        (const char *));
   LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
                        (const char *, bool));
+  LLDB_REGISTER_METHOD(lldb::SBError, SBThread, StepUsingScriptedThreadPlan,
+                       (const char *, SBStructuredData &, bool));
   LLDB_REGISTER_METHOD(lldb::SBError, SBThread, JumpToLine,
                        (lldb::SBFileSpec &, uint32_t));
   LLDB_REGISTER_METHOD(lldb::SBError, SBThread, ReturnFromFrame,
                        (lldb::SBFrame &, lldb::SBValue &));
   LLDB_REGISTER_METHOD(lldb::SBError, SBThread, UnwindInnermostExpression,
                        ());
   LLDB_REGISTER_METHOD(bool, SBThread, Suspend, ());
   LLDB_REGISTER_METHOD(bool, SBThread, Suspend, (lldb::SBError &));

lldb/trunk/source/API/SBThreadPlan.cpp

 //===-- SBThreadPlan.cpp ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SBReproducerPrivate.h"
 #include "lldb/API/SBThread.h"
 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBStream.h"
+#include "lldb/API/SBStructuredData.h"
 #include "lldb/API/SBSymbolContext.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/StreamFile.h"
+#include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Queue.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"

 }
 
 SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name) {
   LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *),
                           sb_thread, class_name);
 
   Thread *thread = sb_thread.get();
   if (thread)
-    m_opaque_sp = std::make_shared<ThreadPlanPython>(*thread, class_name);
+    m_opaque_sp = std::make_shared<ThreadPlanPython>(*thread, class_name, 
+                                                     nullptr);
+}
+
+SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name,
+                           lldb::SBStructuredData &args_data) {
+  LLDB_RECORD_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *,
+                                         SBStructuredData &),
+                          sb_thread, class_name, args_data);
+
+  Thread *thread = sb_thread.get();
+  if (thread)
+    m_opaque_sp = std::make_shared<ThreadPlanPython>(*thread, class_name, 
+                                                     args_data.m_impl_up.get());
 }
 
 // Assignment operator
 
 const lldb::SBThreadPlan &SBThreadPlan::operator=(const SBThreadPlan &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBThreadPlan &,
                      SBThreadPlan, operator=,(const lldb::SBThreadPlan &), rhs);
 

 SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name,
                                              SBError &error) {
   LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
                      QueueThreadPlanForStepScripted,
                      (const char *, lldb::SBError &), script_class_name, error);
 
   if (m_opaque_sp) {
     Status plan_status;
+    StructuredData::ObjectSP empty_args;
     SBThreadPlan plan =
         SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepScripted(
-            false, script_class_name, false, plan_status));
+            false, script_class_name, empty_args, false, plan_status));
+
+    if (plan_status.Fail())
+      error.SetErrorString(plan_status.AsCString());
+
+    return LLDB_RECORD_RESULT(plan);
+  } else {
+    return LLDB_RECORD_RESULT(SBThreadPlan());
+  }
+}
+
+SBThreadPlan
+SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name,
+                                             lldb::SBStructuredData &args_data,
+                                             SBError &error) {
+  LLDB_RECORD_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+                     QueueThreadPlanForStepScripted,
+                     (const char *, lldb::SBStructuredData &, lldb::SBError &), 
+                     script_class_name, args_data, error);
+
+  if (m_opaque_sp) {
+    Status plan_status;
+    StructuredData::ObjectSP args_obj = args_data.m_impl_up->GetObjectSP();
+    SBThreadPlan plan =
+        SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepScripted(
+            false, script_class_name, args_obj, false, plan_status));
 
     if (plan_status.Fail())
       error.SetErrorString(plan_status.AsCString());
 
     return LLDB_RECORD_RESULT(plan);
   } else {
     return LLDB_RECORD_RESULT(SBThreadPlan());
   }
 }
 
 namespace lldb_private {
 namespace repro {
 
 template <>
 void RegisterMethods<SBThreadPlan>(Registry &R) {
   LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, ());
   LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &));
   LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &));
   LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *));
+  LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *,
+                       lldb::SBStructuredData &));
   LLDB_REGISTER_METHOD(const lldb::SBThreadPlan &,
                        SBThreadPlan, operator=,(const lldb::SBThreadPlan &));
   LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, IsValid, ());
   LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, operator bool, ());
   LLDB_REGISTER_METHOD(void, SBThreadPlan, Clear, ());
   LLDB_REGISTER_METHOD(lldb::StopReason, SBThreadPlan, GetStopReason, ());
   LLDB_REGISTER_METHOD(size_t, SBThreadPlan, GetStopReasonDataCount, ());
   LLDB_REGISTER_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex,
void RegisterMethods<SBThreadPlan>(Registry &R) {
   LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
                        QueueThreadPlanForRunToAddress,
                        (lldb::SBAddress, lldb::SBError &));
   LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
                        QueueThreadPlanForStepScripted, (const char *));
   LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
                        QueueThreadPlanForStepScripted,
                        (const char *, lldb::SBError &));
+  LLDB_REGISTER_METHOD(lldb::SBThreadPlan, SBThreadPlan,
+                       QueueThreadPlanForStepScripted,
+                       (const char *, lldb::SBStructuredData &,
+                       lldb::SBError &));
 }
 
 }
 }

lldb/trunk/source/Commands/CommandObjectThread.cpp

 #include "lldb/Core/SourceManager.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
+#include "lldb/Interpreter/OptionGroupPythonClassWithDict.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SystemRuntime.h"

 
 static constexpr OptionEnumValues TriRunningModes() {
   return OptionEnumValues(g_tri_running_mode);
 }
 
 #define LLDB_OPTIONS_thread_step_scope
 #include "CommandOptions.inc"
 
-class CommandObjectThreadStepWithTypeAndScope : public CommandObjectParsed {
-public:
-  class CommandOptions : public Options {
-  public:
-    CommandOptions() : Options() {
-      // Keep default values of all options in one place: OptionParsingStarting
-      // ()
-      OptionParsingStarting(nullptr);
-    }
+class ThreadStepScopeOptionGroup : public OptionGroup {
+  ThreadStepScopeOptionGroup() : OptionGroup() {
 
-    ~CommandOptions() override = default;
+  ~ThreadStepScopeOptionGroup() override = default;
+
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+    return llvm::makeArrayRef(g_thread_step_scope_options);
+  }
 
-    Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
-                          ExecutionContext *execution_context) override {
-      Status error;
-      const int short_option = m_getopt_table[option_idx].val;
+    const int short_option 
+        = g_thread_step_scope_options[option_idx].short_option;
 
-      switch (short_option) {
-      case 'a': {
-        bool success;
-        bool avoid_no_debug =
-            OptionArgParser::ToBoolean(option_arg, true, &success);
-        if (!success)
-          error.SetErrorStringWithFormat(
-              "invalid boolean value for option '%c'", short_option);
-        else {
-          m_step_in_avoid_no_debug =
-              avoid_no_debug ? eLazyBoolYes : eLazyBoolNo;
-        }
-      } break;
 
-      case 'A': {
-        bool success;
-        bool avoid_no_debug =
-            OptionArgParser::ToBoolean(option_arg, true, &success);
-        if (!success)
-          error.SetErrorStringWithFormat(
-              "invalid boolean value for option '%c'", short_option);
-        else {
-          m_step_out_avoid_no_debug =
-              avoid_no_debug ? eLazyBoolYes : eLazyBoolNo;
-        }
-      } break;
 
-      case 'c':
-        if (option_arg.getAsInteger(0, m_step_count))
-          error.SetErrorStringWithFormat("invalid step count '%s'",
-                                         option_arg.str().c_str());
-        break;
 
-      case 'C':
-        m_class_name.clear();
-        m_class_name.assign(option_arg);
-        break;
-
-      case 'm': {
-        auto enum_values = GetDefinitions()[option_idx].enum_values;
-        m_run_mode = (lldb::RunMode)OptionArgParser::ToOptionEnum(
-            option_arg, enum_values, eOnlyDuringStepping, error);
-      } break;
 
-      case 'e':
-        if (option_arg == "block") {
-          m_end_line_is_block_end = true;
-          break;
-        }
-        if (option_arg.getAsInteger(0, m_end_line))
-          error.SetErrorStringWithFormat("invalid end line number '%s'",
-                                         option_arg.str().c_str());
-        break;
 
-      case 'r':
-        m_avoid_regexp.clear();
-        m_avoid_regexp.assign(option_arg);
-        break;
 
-      case 't':
-        m_step_in_target.clear();
-        m_step_in_target.assign(option_arg);
-        break;
 
-      default:
-        llvm_unreachable("Unimplemented option");
-      }
-      return error;
-    }
 
-    void OptionParsingStarting(ExecutionContext *execution_context) override {
-      m_step_in_avoid_no_debug = eLazyBoolCalculate;
-      m_step_out_avoid_no_debug = eLazyBoolCalculate;
-      m_run_mode = eOnlyDuringStepping;
 
-      // Check if we are in Non-Stop mode
-      TargetSP target_sp =
-          execution_context ? execution_context->GetTargetSP() : TargetSP();
-      if (target_sp && target_sp->GetNonStopModeEnabled())
-        m_run_mode = eOnlyThisThread;
 
-      m_avoid_regexp.clear();
-      m_step_in_target.clear();
-      m_class_name.clear();
-      m_step_count = 1;
-      m_end_line = LLDB_INVALID_LINE_NUMBER;
-      m_end_line_is_block_end = false;
-    }
 
-    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
-      return llvm::makeArrayRef(g_thread_step_scope_options);
-    }
-
-    // Instance variables to hold the values for command options.
-    LazyBool m_step_in_avoid_no_debug;
-    LazyBool m_step_out_avoid_no_debug;
-    RunMode m_run_mode;
-    std::string m_avoid_regexp;
-    std::string m_step_in_target;
-    std::string m_class_name;
-    uint32_t m_step_count;
-    uint32_t m_end_line;
-    bool m_end_line_is_block_end;
-  };
 
+class CommandObjectThreadStepWithTypeAndScope : public CommandObjectParsed {
+public:
+
   CommandObjectThreadStepWithTypeAndScope(CommandInterpreter &interpreter,
                                           const char *name, const char *help,
                                           const char *syntax,
                                           StepType step_type,
                                           StepScope step_scope)
       : CommandObjectParsed(interpreter, name, help, syntax,
                             eCommandRequiresProcess | eCommandRequiresThread |
                                 eCommandTryTargetAPILock |
                                 eCommandProcessMustBeLaunched |
                                 eCommandProcessMustBePaused),
-        m_step_type(step_type), m_step_scope(step_scope), m_options() {
+        m_step_type(step_type), m_step_scope(step_scope), m_options(),
+        m_class_options("scripted step", 'C') {
     CommandArgumentEntry arg;
     CommandArgumentData thread_id_arg;
 
     // Define the first (and only) variant of this arg.
     thread_id_arg.arg_type = eArgTypeThreadID;
     thread_id_arg.arg_repetition = eArgRepeatOptional;
 
     // There is only one variant this argument could be; put it into the
     // argument entry.
     arg.push_back(thread_id_arg);
 
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg);
+    
+    if (step_type == eStepTypeScripted) {
+      m_all_options.Append(&m_class_options, LLDB_OPT_SET_1, LLDB_OPT_SET_1);
+    }
+    m_all_options.Append(&m_options);
+    m_all_options.Finalize();
   }
 
   ~CommandObjectThreadStepWithTypeAndScope() override = default;
 
-  Options *GetOptions() override { return &m_options; }
+  Options *GetOptions() override { 
+      return &m_all_options;
+  }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Process *process = m_exe_ctx.GetProcessPtr();
     bool synchronous_execution = m_interpreter.GetSynchronous();
 
     const uint32_t num_threads = process->GetThreadList().GetSize();
     Thread *thread = nullptr;
if (command.GetArgumentCount() == 0) {
             "Thread index %u is out of range (valid values are 0 - %u).\n",
             step_thread_idx, num_threads);
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
     }
 
     if (m_step_type == eStepTypeScripted) {
-      if (m_options.m_class_name.empty()) {
+      if (m_class_options.GetClassName().empty()) {
         result.AppendErrorWithFormat("empty class name for scripted step.");
         result.SetStatus(eReturnStatusFailed);
         return false;
       } else if (!GetDebugger().GetScriptInterpreter()->CheckObjectExists(
-                     m_options.m_class_name.c_str())) {
+                     m_class_options.GetClassName().c_str())) {
         result.AppendErrorWithFormat(
             "class for scripted step: \"%s\" does not exist.",
-            m_options.m_class_name.c_str());
+            m_class_options.GetClassName().c_str());
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
     }
 
     if (m_options.m_end_line != LLDB_INVALID_LINE_NUMBER &&
         m_step_type != eStepTypeInto) {
       result.AppendErrorWithFormat(
if (m_step_type == eStepTypeInto) {
           true, abort_other_plans, bool_stop_other_threads, new_plan_status);
     } else if (m_step_type == eStepTypeOut) {
       new_plan_sp = thread->QueueThreadPlanForStepOut(
           abort_other_plans, nullptr, false, bool_stop_other_threads, eVoteYes,
           eVoteNoOpinion, thread->GetSelectedFrameIndex(), new_plan_status,
           m_options.m_step_out_avoid_no_debug);
     } else if (m_step_type == eStepTypeScripted) {
       new_plan_sp = thread->QueueThreadPlanForStepScripted(
-          abort_other_plans, m_options.m_class_name.c_str(),
+          abort_other_plans, m_class_options.GetClassName().c_str(), 
+          m_class_options.GetStructuredData(),
           bool_stop_other_threads, new_plan_status);
     } else {
       result.AppendError("step type is not supported");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     // If we got a new plan, then set it to be a master plan (User level Plans
if (new_plan_sp) {
       result.SetStatus(eReturnStatusFailed);
     }
     return result.Succeeded();
   }
 
 protected:
   StepType m_step_type;
   StepScope m_step_scope;
-  CommandOptions m_options;
+  ThreadStepScopeOptionGroup m_options;
+  OptionGroupPythonClassWithDict m_class_options;
+  OptionGroupOptions m_all_options;
 };
 
 // CommandObjectThreadContinue
 
 class CommandObjectThreadContinue : public CommandObjectParsed {
 public:
   CommandObjectThreadContinue(CommandInterpreter &interpreter)
       : CommandObjectParsed(
LoadSubCommand("step-inst-over",
                      "Instruction level single step, stepping over calls.  "
                      "Defaults to current thread unless specified.",
                      nullptr, eStepTypeTraceOver, eStepScopeInstruction)));
 
   LoadSubCommand(
       "step-scripted",
       CommandObjectSP(new CommandObjectThreadStepWithTypeAndScope(
           interpreter, "thread step-scripted",
-          "Step as instructed by the script class passed in the -C option.",
+          "Step as instructed by the script class passed in the -C option.  "
+          "You can also specify a dictionary of key (-k) and value (-v) pairs "
+          "that will be used to populate an SBStructuredData Dictionary, which "
+          "will be passed to the constructor of the class implementing the "
+          "scripted step.  See the Python Reference for more details.",
           nullptr, eStepTypeScripted, eStepScopeSource)));
 
   LoadSubCommand("plan", CommandObjectSP(new CommandObjectMultiwordThreadPlan(
                              interpreter)));
 }
 
 CommandObjectMultiwordThread::~CommandObjectMultiwordThread() = default;

lldb/trunk/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h

public:
   static bool Check(PyObject *py_obj);
 
   // Bring in the no-argument base class version
   using PythonObject::Reset;
 
   void Reset(PyRefType type, PyObject *py_obj) override;
 
   ArgInfo GetNumArguments() const;
   
+  // If the callable is a Py_Class, then find the number of arguments
+  // of the __init__ method.
+  ArgInfo GetNumInitArguments() const;
+
   PythonObject operator()();
 
   PythonObject operator()(std::initializer_list<PyObject *> args);
 
   PythonObject operator()(std::initializer_list<PythonObject> args);
 
   template <typename Arg, typename... Args>
   PythonObject operator()(const Arg &arg, Args... args) {

lldb/trunk/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp

if (!PythonCallable::Check(py_obj)) {
     return;
   }
 
   // Calling PythonObject::Reset(const PythonObject&) will lead to stack
   // overflow since it calls back into the virtual implementation.
   PythonObject::Reset(PyRefType::Borrowed, result.get());
 }
 
+PythonCallable::ArgInfo PythonCallable::GetNumInitArguments() const {
+  ArgInfo result = {0, false, false, false};
+  if (!IsValid())
+    return result;
+  PyObject *py_func_obj = m_py_obj;
+  if (!PyClass_Check(m_py_obj))
+    return result;
+
+  PythonObject __init__ = GetAttributeValue("__init__");
+  if (__init__.IsValid() ) {
+    auto __init_callable__ = __init__.AsType<PythonCallable>();
+    if (__init_callable__.IsValid())
+      return __init_callable__.GetNumArguments();
+  }
+  return result;
+}
+
 PythonCallable::ArgInfo PythonCallable::GetNumArguments() const {
   ArgInfo result = {0, false, false, false};
   if (!IsValid())
     return result;
 
   PyObject *py_func_obj = m_py_obj;
   if (PyMethod_Check(py_func_obj)) {
     py_func_obj = PyMethod_GET_FUNCTION(py_func_obj);

lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

 
 extern "C" void *
 LLDBSwigPythonCreateCommandObject(const char *python_class_name,
                                   const char *session_dictionary_name,
                                   const lldb::DebuggerSP debugger_sp);
 
 extern "C" void *LLDBSwigPythonCreateScriptedThreadPlan(
     const char *python_class_name, const char *session_dictionary_name,
+    StructuredDataImpl *args_data,
     std::string &error_string,
     const lldb::ThreadPlanSP &thread_plan_sp);
 
 extern "C" bool LLDBSWIGPythonCallThreadPlan(void *implementor,
                                              const char *method_name,
                                              Event *event_sp, bool &got_error);
 
 extern "C" void *LLDBSwigPythonCreateScriptedBreakpointResolver(
StructuredData::DictionarySP ScriptInterpreterPythonImpl::OSPlugin_CreateThread(
   if (py_return.get()) {
     PythonDictionary result_dict(PyRefType::Borrowed, py_return.get());
     return result_dict.CreateStructuredDictionary();
   }
   return StructuredData::DictionarySP();
 }
 
 StructuredData::ObjectSP ScriptInterpreterPythonImpl::CreateScriptedThreadPlan(
-    const char *class_name, std::string &error_str, 
+    const char *class_name, StructuredDataImpl *args_data,
+    std::string &error_str, 
     lldb::ThreadPlanSP thread_plan_sp) {
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::ObjectSP();
 
   if (!thread_plan_sp.get())
     return {};
 
   Debugger &debugger = thread_plan_sp->GetTarget().GetDebugger();
   ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
   ScriptInterpreterPythonImpl *python_interpreter =
       static_cast<ScriptInterpreterPythonImpl *>(script_interpreter);
 
   if (!script_interpreter)
     return {};
 
   void *ret_val;
 
   {
     Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     ret_val = LLDBSwigPythonCreateScriptedThreadPlan(
         class_name, python_interpreter->m_dictionary_name.c_str(),
-        error_str, thread_plan_sp);
+        args_data, error_str, thread_plan_sp);
     if (!ret_val)
       return {};
   }
 
   return StructuredData::ObjectSP(new StructuredPythonObject(ret_val));
 }
 
 bool ScriptInterpreterPythonImpl::ScriptedThreadPlanExplainsStop(

lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPythonImpl.h

public:
   CreateSyntheticScriptedProvider(const char *class_name,
                                   lldb::ValueObjectSP valobj) override;
 
   StructuredData::GenericSP
   CreateScriptCommandObject(const char *class_name) override;
 
   StructuredData::ObjectSP
   CreateScriptedThreadPlan(const char *class_name,
+                           StructuredDataImpl *args_data,
                            std::string &error_str,
                            lldb::ThreadPlanSP thread_plan) override;
 
   bool ScriptedThreadPlanExplainsStop(StructuredData::ObjectSP implementor_sp,
                                       Event *event,
                                       bool &script_error) override;
 
   bool ScriptedThreadPlanShouldStop(StructuredData::ObjectSP implementor_sp,

lldb/trunk/source/Target/Thread.cpp

 //===-- Thread.cpp ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/Thread.h"
 #include "Plugins/Process/Utility/UnwindLLDB.h"
 #include "Plugins/Process/Utility/UnwindMacOSXFrameBackchain.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/Module.h"
+#include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Interpreter/OptionValueFileSpecList.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/DynamicLoader.h"
ThreadPlanSP Thread::QueueThreadPlanForStepUntil(
   ThreadPlanSP thread_plan_sp(new ThreadPlanStepUntil(
       *this, address_list, num_addresses, stop_other_threads, frame_idx));
 
   status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
   return thread_plan_sp;
 }
 
 lldb::ThreadPlanSP Thread::QueueThreadPlanForStepScripted(
-    bool abort_other_plans, const char *class_name, bool stop_other_threads,
+    bool abort_other_plans, const char *class_name, 
+    StructuredData::ObjectSP extra_args_sp,  bool stop_other_threads,
     Status &status) {
-  ThreadPlanSP thread_plan_sp(new ThreadPlanPython(*this, class_name));
+    
+  StructuredDataImpl *extra_args_impl = nullptr; 
+  if (extra_args_sp) {
+    extra_args_impl = new StructuredDataImpl();
+    extra_args_impl->SetObjectSP(extra_args_sp);
+  }
+
+  ThreadPlanSP thread_plan_sp(new ThreadPlanPython(*this, class_name, 
+                                                   extra_args_impl));
 
   status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
   return thread_plan_sp;
 }
 
 uint32_t Thread::GetIndexID() const { return m_index_id; }
 
 static void PrintPlanElement(Stream *s, const ThreadPlanSP &plan,

lldb/trunk/source/Target/ThreadPlanPython.cpp

 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // ThreadPlanPython
 
-ThreadPlanPython::ThreadPlanPython(Thread &thread, const char *class_name)
+ThreadPlanPython::ThreadPlanPython(Thread &thread, const char *class_name, 
+                                   StructuredDataImpl *args_data)
     : ThreadPlan(ThreadPlan::eKindPython, "Python based Thread Plan", thread,
                  eVoteNoOpinion, eVoteNoOpinion),
-      m_class_name(class_name), m_did_push(false) {
+      m_class_name(class_name), m_args_data(args_data), m_did_push(false) {
   SetIsMasterPlan(true);
   SetOkayToDiscard(true);
   SetPrivate(false);
 }
 
 ThreadPlanPython::~ThreadPlanPython() {
   // FIXME, do I need to decrement the ref count on this implementation object
   // to make it go away?
void ThreadPlanPython::DidPush() {
   m_did_push = true;
   if (!m_class_name.empty()) {
     ScriptInterpreter *script_interp = m_thread.GetProcess()
                                            ->GetTarget()
                                            .GetDebugger()
                                            .GetScriptInterpreter();
     if (script_interp) {
       m_implementation_sp = script_interp->CreateScriptedThreadPlan(
-          m_class_name.c_str(), m_error_str, this->shared_from_this());
+          m_class_name.c_str(), m_args_data, m_error_str, 
+          this->shared_from_this());
     }
   }
 }
 
 bool ThreadPlanPython::ShouldStop(Event *event_ptr) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
   LLDB_LOGF(log, "%s called on Python Thread Plan: %s )", LLVM_PRETTY_FUNCTION,
             m_class_name.c_str());

lldb/trunk/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp

 LLDBSwigPythonCreateCommandObject(const char *python_class_name,
                                   const char *session_dictionary_name,
                                   const lldb::DebuggerSP debugger_sp) {
   return nullptr;
 }
 
 extern "C" void *LLDBSwigPythonCreateScriptedThreadPlan(
     const char *python_class_name, const char *session_dictionary_name,
+    StructuredDataImpl *args_data,
     std::string &error_string,
     const lldb::ThreadPlanSP &thread_plan_sp) {
   return nullptr;
 }
 
 extern "C" bool LLDBSWIGPythonCallThreadPlan(void *implementor,
                                              const char *method_name,
                                              Event *event_sp, bool &got_error) {