[lldb/Commands] Add command options for ScriptedProcess to ProcessLaunch

[mib]

Summary

This patch adds a new command options to the CommandObjectProecessLaunch
for scripted processes.

Among the options, the user need to specify the class name managing the
scripted process. The user can also use a key-value dictionary holding
arbitrary data that will be passed to the managing class.

rdar://65508855

Signed-off-by: Med Ismail Bennani <[e-mail]>

[lldb/Interpreter] Add ScriptInterpreter Wrapper for ScriptedProcess

This patch adds a ScriptedProcess interface to the ScriptInterpreter and
more specifically, to the ScriptInterpreterPython.

This interface will be used in the C++ ScriptProcess Process Plugin to
call the script methods.

At the moment, not all methods are implemented, they will upstreamed in
upcoming patches.

rdar://65508855

Signed-off-by: Med Ismail Bennani <[e-mail]>

[lldb/bindings] Add Python ScriptedProcess base class to lldb module

In order to facilitate the writting of Scripted Processes, this patch
introduces a ScriptedProcess python base class in the lldb module.

The base class holds the python interface with all the - abstract -
methods that need to be implemented by the inherited class but also some
methods that can be overwritten.

This patch also provides an example of a Scripted Process with the
ScriptedMachCoreProcess class.

rdar://65508855

Signed-off-by: Med Ismail Bennani <[e-mail]>

[lldb/Plugins] Add ScriptedProcess Process Plugin

This patch introduces Scripted Processes to lldb.

The goal, here, is to be able to attach to fake processes in the debugger
that are backed my scripts (Python, Lua, Swift, etc ...) and inspect
them statically.

Scripted Processes can be used in cooperative multithreading environments
like the XNU Kernel or other real-time operating systems, but it can
also help us improve the debugger testing infrastructure by writting
synthetic tests that simulates hard-to-reproduce process/thread states.

Although ScriptedProcess is not feature-complete at the moment, it has
basic execution capabilities and will improve in the following patches.

rdar://65508855

Signed-off-by: Med Ismail Bennani <[e-mail]>

[mib]

It seems arc grouped all commits into a single differential. I'll split them in separate diffs.

lldb/bindings/python/python-scripted-process.swig

+%pythoncode %{
+from abc import ABC, abstractmethod
+from typing import List
+
+import lldb
+
+class ScriptedProcess(ABC):
+    @abstractmethod
+    def __init__(self, target: lldb.SBTarget, args : lldb.SBStructuredData):
+        self.process_id = 0
+        self.memory_regions = []
+        self.threads = []
+        self.loaded_images = []
+        self.stops = []
+        self.target = None
+        self.args = None
+        if isinstance(target, lldb.SBTarget) and target.IsValid():
+            self.target = target
+        if isinstance(args, lldb.SBStructuredData) and args.IsValid():
+            self.args = args
+
+    ### Main funcitonnalities
+    @abstractmethod
+    def get_num_memory_regions(self) -> int:
+        pass
+
+    @abstractmethod
+    def get_memory_region_at_index(self, idx: int) -> lldb.SBMemoryRegionInfo:
+        pass
+
+    @abstractmethod
+    def get_num_threads(self):
+        pass
+
+    @abstractmethod
+    def get_thread_at_index(self, idx: int) -> lldb.SBThread:
+        pass
+
+    @abstractmethod
+    def get_register_for_thread(self, tid:int):
+        pass
+
+    @abstractmethod
+    def read_memory_at_address(self, addr:int) -> lldb.SBData:
+        pass
+
+    @abstractmethod
+    def get_loaded_images(self) -> List[str]: # -> List[lldb.SBModule]:
+        pass
+
+    def get_process_id(self) -> int
+        return self.process_id
+
+    ### Process state
+    def launch(self) -> lldb.SBError:
+        return lldb.SBError()
+
+    @abstractmethod
+    def can_debug(self) -> bool:
+        pass
+
+    @abstractmethod
+    def is_alive(self) -> bool:
+        pass
+%}

lldb/bindings/python/python-wrapper.swig

)
 
     if (result.IsAllocated())
         return result.release();
 
     Py_RETURN_NONE;
 }
 
 SWIGEXPORT void*
+LLDBSwigPythonCreateScriptedProcess
+(
+    const char *python_class_name,
+    const char *session_dictionary_name,
+    const lldb::TargetSP& target_sp,
+    lldb_private::StructuredDataImpl *args_impl,
+    std::string &error_string
+)
+{
+    if (python_class_name == NULL || python_class_name[0] == '\0' || !session_dictionary_name)
+        Py_RETURN_NONE;
+
+
+    PyErr_Cleaner py_err_cleaner(true);
+
+    auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
+    auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_class_name, dict);
+
+    if (!pfunc.IsAllocated()) {
+        error_string.append("could not find script class: ");
+        error_string.append(python_class_name);
+        return nullptr;
+    }
+
+    // I do not want the SBTarget to be deallocated when going out of scope
+    // because python has ownership of it and will manage memory for this
+    // object by itself
+    PythonObject target_arg(PyRefType::Owned, SBTypeToSWIGWrapper(new lldb::SBTarget(target_sp)));
+
+    if (!target_arg.IsAllocated())
+        Py_RETURN_NONE;
+
+    llvm::Expected<PythonCallable::ArgInfo> arg_info = pfunc.GetArgInfo();
+    if (!arg_info) {
+        llvm::handleAllErrors(
+            arg_info.takeError(),
+            [&](PythonException &E) {
+                error_string.append(E.ReadBacktrace());
+            },
+            [&](const llvm::ErrorInfoBase &E) {
+                error_string.append(E.message());
+            });
+        Py_RETURN_NONE;
+    }
+
+    PythonObject result = {};
+    if (arg_info.get().max_positional_args == 2) {
+        if (args_impl != nullptr) {
+           error_string.assign("args passed, but __init__ does not take an args dictionary");
+           Py_RETURN_NONE;
+        }
+        result = pfunc(target_arg, dict);
+    } else if (arg_info.get().max_positional_args >= 3) {
+        PythonObject args_arg(PyRefType::Owned, SBTypeToSWIGWrapper(new lldb::SBStructuredData(args_impl)));
+        result = pfunc(target_arg, args_arg, dict);
+    } else {
+        error_string.assign("wrong number of arguments in __init__, should be 2 or 3 (not including self)");
+        Py_RETURN_NONE;
+    }
+
+    if (result.IsAllocated())
+        return result.release();
+    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
 )
)
     int valid_cast = SWIG_ConvertPtr(data, (void**)&sb_ptr, SWIGTYPE_p_lldb__SBValue, 0);
 
     if (valid_cast == -1)
         return NULL;
 
     return sb_ptr;
 }
 
+SWIGEXPORT void*
+LLDBSWIGPython_CastPyObjectToSBError
+(
+    PyObject* data
+)
+{
+    lldb::SBError* sb_ptr = nullptr;
+
+    int valid_cast = SWIG_ConvertPtr(data, (void**)&sb_ptr, SWIGTYPE_p_lldb__SBError, 0);
+
+    if (valid_cast == -1)
+        return NULL;
+
+    return sb_ptr;
+}
+
 SWIGEXPORT bool
 LLDBSwigPythonCallCommand
 (
     const char *python_function_name,
     const char *session_dictionary_name,
     lldb::DebuggerSP& debugger,
     const char* args,
     lldb_private::CommandReturnObject& cmd_retobj,

lldb/bindings/python/python.swig

 using namespace lldb_private;
 using namespace lldb_private::python;
 using namespace lldb;
 %}
 
 %include "interfaces.swig"
 %include "python-extensions.swig"
 %include "python-wrapper.swig"
+%include "python-scripted-process.swig"
 
 %pythoncode%{
 _initialize = True
 try:
    import lldbconfig
    _initialize = lldbconfig.INITIALIZE
 except ImportError:
    pass

lldb/examples/python/scripted_process.py

+#!/usr/bin/env python3
+
+from typing import List
+
+import lldb
+from lldb import ScriptedProcess
+
+class ScriptedMachCoreProcess(ScriptedProcess):
+    def __init__(self, target: lldb.SBTarget, args : lldb.SBStructuredData):
+        super().__init__(target, args)
+
+    ### Main functionalities
+    def get_num_memory_regions(self) -> int:
+        return len(self.memory_regions)
+    def get_memory_region_at_index(self, idx: int) -> lldb.SBMemoryRegionInfo:
+        return self.memory_regions[idx]
+    def get_num_threads(self) -> int:
+        return len(self.threads)
+    def get_thread_at_index(self, idx: int) -> lldb.SBThread:
+        return self.threads[idx]
+    def get_register_for_thread(self, tid: int):
+        return tid
+    def read_memory_at_address(self, addr: int) -> lldb.SBData:
+        return addr
+    def get_loaded_images(self) -> List[str]:
+        return self.loaded_images
+    def get_process_id(self) -> int:
+        return 42
+
+    ### Process state
+    def can_debug(self) -> bool:
+        return True
+    def is_alive(self) -> bool:
+        return True
+
+def __lldb_init_module(debugger, dict):
+    debugger.HandleCommand(
+        "process launch -S -C %s.%s" % (__name__,
+                                        ScriptedMachCoreProcess.__name__))
+

lldb/include/lldb/Host/ProcessLaunchInfo.h

 //===-- ProcessLaunchInfo.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 LLDB_HOST_PROCESSLAUNCHINFO_H
 #define LLDB_HOST_PROCESSLAUNCHINFO_H
 
 // C++ Headers
 #include <string>
 
 // LLDB Headers
 #include "lldb/Utility/Flags.h"
 
 #include "lldb/Host/FileAction.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/PseudoTerminal.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/ProcessInfo.h"
+#include "lldb/Utility/StructuredData.h"
 
 namespace lldb_private {
 
 // ProcessLaunchInfo
 //
 // Describes any information that is required to launch a process.
 
 class ProcessLaunchInfo : public ProcessInfo {
public:
   const char *GetLaunchEventData() const { return m_event_data.c_str(); }
 
   void SetDetachOnError(bool enable);
 
   bool GetDetachOnError() const {
     return m_flags.Test(lldb::eLaunchFlagDetachOnError);
   }
 
+  bool IsScriptedProcess() const { return m_scripted_process; }
+
+  void SetScriptedProcess(bool b) { m_scripted_process = b; }
+
+  llvm::StringRef GetScriptedProcessClassName() const {
+    return m_scripted_process_class_name;
+  }
+
+  void SetScriptedProcessClassName(llvm::StringRef name) {
+    m_scripted_process_class_name = name;
+  }
+
+  lldb_private::StructuredData::DictionarySP
+  GetScriptedProcessDictionarySP() const {
+    return m_scripted_process_dictionary_sp;
+  }
+
+  void SetScriptedProcessDictionarySP(
+      lldb_private::StructuredData::DictionarySP dictionary_sp) {
+    m_scripted_process_dictionary_sp = dictionary_sp;
+  }
+
 protected:
   FileSpec m_working_dir;
   std::string m_plugin_name;
   FileSpec m_shell;
   Flags m_flags; // Bitwise OR of bits from lldb::LaunchFlags
   std::vector<FileAction> m_file_actions; // File actions for any other files
   std::shared_ptr<PseudoTerminal> m_pty;
   uint32_t m_resume_count; // How many times do we resume after launching
   Host::MonitorChildProcessCallback m_monitor_callback;
   void *m_monitor_callback_baton;
   bool m_monitor_signals;
   std::string m_event_data; // A string passed to the plugin launch, having no
                             // meaning to the upper levels of lldb.
   lldb::ListenerSP m_listener_sp;
   lldb::ListenerSP m_hijack_listener_sp;
+  bool m_scripted_process;
+  llvm::StringRef m_scripted_process_class_name;
+  StructuredData::DictionarySP m_scripted_process_dictionary_sp;
 };
 }
 
 #endif // LLDB_HOST_PROCESSLAUNCHINFO_H

lldb/include/lldb/Interpreter/ScriptInterpreter.h

 //===-- ScriptInterpreter.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 LLDB_INTERPRETER_SCRIPTINTERPRETER_H
 #define LLDB_INTERPRETER_SCRIPTINTERPRETER_H
 
 #include "lldb/Breakpoint/BreakpointOptions.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/SearchFilter.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/PseudoTerminal.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StructuredData.h"
public:
   }
 
   static std::string LanguageToString(lldb::ScriptLanguage language);
 
   static lldb::ScriptLanguage StringToLanguage(const llvm::StringRef &string);
 
   lldb::ScriptLanguage GetLanguage() { return m_script_lang; }
 
+#pragma mark ScriptedProcessInterface
+
+  virtual StructuredData::GenericSP
+  ScriptedProcess_CreatePluginObject(const char *class_name,
+                                     lldb::TargetSP target_sp,
+                                     StructuredData::DictionarySP args_sp) {
+    return nullptr;
+  }
+
+  virtual Status
+  ScriptedProcess_Launch(StructuredData::ObjectSP scripted_process_object_sp) {
+    return Status("ScriptedProcess did not launch");
+  }
+
+  virtual size_t ScriptedProcess_GetNumMemoryRegions(
+      StructuredData::ObjectSP scripted_process_object_sp) {
+    return LLDB_INVALID_ADDRESS;
+  }
+
+  virtual lldb::MemoryRegionInfoSP ScriptedProcess_GetMemoryRegionAtIndex(
+      StructuredData::ObjectSP scripted_process_object_sp, size_t index) {
+    return nullptr;
+  }
+
+  virtual size_t ScriptedProcess_GetNumThreads(
+      StructuredData::ObjectSP scripted_process_object_sp) {
+    return LLDB_INVALID_ADDRESS;
+  }
+
+  virtual lldb::ThreadSP ScriptedProcess_GetThreadAtIndex(
+      StructuredData::ObjectSP scripted_process_object_sp, size_t index) {
+    return nullptr;
+  }
+
+  virtual StructuredData::DictionarySP ScriptedProcess_GetRegisterForThread(
+      StructuredData::ObjectSP scripted_process_object_sp) {
+    return nullptr;
+  }
+
+  virtual size_t ScriptedProcess_ReadMemoryAtAddress(
+      StructuredData::ObjectSP scripted_process_object_sp, lldb::addr_t address,
+      size_t size) {
+    return LLDB_INVALID_ADDRESS;
+  }
+
+  virtual StructuredData::DictionarySP ScriptedProcess_GetLoadedImages(
+      StructuredData::ObjectSP scripted_process_object_sp) {
+    return nullptr;
+  }
+
+  virtual lldb::pid_t ScriptedProcess_GetProcessID(
+      StructuredData::ObjectSP scripted_process_object_sp) {
+    return LLDB_INVALID_PROCESS_ID;
+  }
+
+  virtual bool ScriptedProcess_CanDebug(
+      StructuredData::ObjectSP scripted_process_object_sp) {
+    return true;
+  }
+
+  virtual bool
+  ScriptedProcess_IsAlive(StructuredData::ObjectSP scripted_process_object_sp) {
+    return true;
+  }
+
 protected:
   Debugger &m_debugger;
   lldb::ScriptLanguage m_script_lang;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_SCRIPTINTERPRETER_H

lldb/include/lldb/lldb-forward.h

 typedef std::shared_ptr<lldb_private::LanguageRuntime> LanguageRuntimeSP;
 typedef std::shared_ptr<lldb_private::SystemRuntime> SystemRuntimeSP;
 typedef std::unique_ptr<lldb_private::SystemRuntime> SystemRuntimeUP;
 typedef std::shared_ptr<lldb_private::LineTable> LineTableSP;
 typedef std::shared_ptr<lldb_private::Listener> ListenerSP;
 typedef std::weak_ptr<lldb_private::Listener> ListenerWP;
 typedef std::shared_ptr<lldb_private::MemoryHistory> MemoryHistorySP;
 typedef std::unique_ptr<lldb_private::MemoryRegionInfo> MemoryRegionInfoUP;
+typedef std::shared_ptr<lldb_private::MemoryRegionInfo> MemoryRegionInfoSP;
 typedef std::shared_ptr<lldb_private::Module> ModuleSP;
 typedef std::weak_ptr<lldb_private::Module> ModuleWP;
 typedef std::shared_ptr<lldb_private::ObjectFile> ObjectFileSP;
 typedef std::weak_ptr<lldb_private::ObjectFile> ObjectFileWP;
 typedef std::shared_ptr<lldb_private::ObjectFileJITDelegate>
     ObjectFileJITDelegateSP;
 typedef std::weak_ptr<lldb_private::ObjectFileJITDelegate>
     ObjectFileJITDelegateWP;

lldb/source/Commands/CommandObjectPlatform.cpp

 // "platform process launch"
 class CommandObjectPlatformProcessLaunch : public CommandObjectParsed {
 public:
   CommandObjectPlatformProcessLaunch(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "platform process launch",
                             "Launch a new process on a remote platform.",
                             "platform process launch program",
                             eCommandRequiresTarget | eCommandTryTargetAPILock),
-        m_options() {}
+        m_options(), m_all_options() {
+    m_all_options.Append(&m_options);
+    m_all_options.Finalize();
+  }
 
   ~CommandObjectPlatformProcessLaunch() override = default;
 
-  Options *GetOptions() override { return &m_options; }
+  Options *GetOptions() override { return &m_all_options; }
 
 protected:
   bool DoExecute(Args &args, CommandReturnObject &result) override {
     Target *target = GetDebugger().GetSelectedTarget().get();
     PlatformSP platform_sp;
     if (target) {
       platform_sp = target->GetPlatform();
     }
if (platform_sp) {
       }
     } else {
       result.AppendError("no platform is selected\n");
     }
     return result.Succeeded();
   }
 
   CommandOptionsProcessLaunch m_options;
+  OptionGroupOptions m_all_options;
 };
 
 // "platform process list"
 
 static PosixPlatformCommandOptionValidator posix_validator;
 #define LLDB_OPTIONS_platform_process_list
 #include "CommandOptions.inc"
 

lldb/source/Commands/CommandObjectProcess.cpp

 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/BreakpointSite.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/OptionParser.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/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/Args.h"

 #pragma mark CommandObjectProcessLaunch
 class CommandObjectProcessLaunch : public CommandObjectProcessLaunchOrAttach {
 public:
   CommandObjectProcessLaunch(CommandInterpreter &interpreter)
       : CommandObjectProcessLaunchOrAttach(
             interpreter, "process launch",
             "Launch the executable in the debugger.", nullptr,
             eCommandRequiresTarget, "restart"),
-        m_options() {
+        m_options(), m_class_options("scripted process (use with --Scripted)"),
+        m_all_options() {
+    m_all_options.Append(&m_options);
+    m_all_options.Append(&m_class_options, LLDB_OPT_SET_1 | LLDB_OPT_SET_2,
+                         LLDB_OPT_SET_1);
+    m_all_options.Finalize();
+
     CommandArgumentEntry arg;
     CommandArgumentData run_args_arg;
 
     // Define the first (and only) variant of this arg.
     run_args_arg.arg_type = eArgTypeRunArgs;
     run_args_arg.arg_repetition = eArgRepeatOptional;
 
     // There is only one variant this argument could be; put it into the
public:
   HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
 
     CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
         request, nullptr);
   }
 
-  Options *GetOptions() override { return &m_options; }
+  Options *GetOptions() override { return &m_all_options; }
 
   const char *GetRepeatCommand(Args &current_command_args,
                                uint32_t index) override {
     // No repeat for "process launch"...
     return "";
   }
 
 protected:
if (m_options.disable_aslr != eLazyBoolCalculate) {
       // Use it.
       disable_aslr = (m_options.disable_aslr == eLazyBoolYes);
     } else {
       // The user did not explicitly specify whether to disable ASLR.  Fall
       // back to the target.disable-aslr setting.
       disable_aslr = target->GetDisableASLR();
     }
 
+    if (m_options.launch_info.IsScriptedProcess()) {
+      m_options.launch_info.SetScriptedProcessClassName(
+          m_class_options.GetName());
+      m_options.launch_info.SetScriptedProcessDictionarySP(
+          m_class_options.GetStructuredData());
+      target->SetProcessLaunchInfo(m_options.launch_info);
+    }
+
     if (disable_aslr)
       m_options.launch_info.GetFlags().Set(eLaunchFlagDisableASLR);
     else
       m_options.launch_info.GetFlags().Clear(eLaunchFlagDisableASLR);
 
     if (target->GetInheritTCC())
       m_options.launch_info.GetFlags().Set(eLaunchFlagInheritTCCFromParent);
 
bool DoExecute(Args &launch_args, CommandReturnObject &result) override {
     } else {
       result.AppendError(error.AsCString());
       result.SetStatus(eReturnStatusFailed);
     }
     return result.Succeeded();
   }
 
   CommandOptionsProcessLaunch m_options;
+  OptionGroupPythonClassWithDict m_class_options;
+  OptionGroupOptions m_all_options;
 };
 
 #define LLDB_OPTIONS_process_attach
 #include "CommandOptions.inc"
 
 #pragma mark CommandObjectProcessAttach
 class CommandObjectProcessAttach : public CommandObjectProcessLaunchOrAttach {
 public:

lldb/source/Commands/CommandOptionsProcessLaunch.h

-//===-- CommandOptionsProcessLaunch.h -------------------------------------===//
+//===-- CommandOptionsProcessLaunch.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 LLDB_SOURCE_COMMANDS_COMMANDOPTIONSPROCESSLAUNCH_H
 #define LLDB_SOURCE_COMMANDS_COMMANDOPTIONSPROCESSLAUNCH_H
 
 #include "lldb/Host/ProcessLaunchInfo.h"
 #include "lldb/Interpreter/Options.h"
 
 namespace lldb_private {
 
 // CommandOptionsProcessLaunch
 
-class CommandOptionsProcessLaunch : public lldb_private::Options {
+class CommandOptionsProcessLaunch : public lldb_private::OptionGroup {
 public:
-  CommandOptionsProcessLaunch() : lldb_private::Options() {
+  CommandOptionsProcessLaunch() : lldb_private::OptionGroup() {
     // Keep default values of all options in one place: OptionParsingStarting
     // ()
     OptionParsingStarting(nullptr);
   }
 
   ~CommandOptionsProcessLaunch() override = default;
 
   lldb_private::Status

lldb/source/Commands/CommandOptionsProcessLaunch.cpp

 
 #define LLDB_OPTIONS_process_launch
 #include "CommandOptions.inc"
 
 Status CommandOptionsProcessLaunch::SetOptionValue(
     uint32_t option_idx, llvm::StringRef option_arg,
     ExecutionContext *execution_context) {
   Status error;
-  const int short_option = m_getopt_table[option_idx].val;
+  const int short_option = g_process_launch_options[option_idx].short_option;
 
   switch (short_option) {
   case 's': // Stop at program entry point
     launch_info.GetFlags().Set(eLaunchFlagStopAtEntry);
     break;
 
   case 'i': // STDIN for read only
   {
case 'c':
     else
       launch_info.SetShell(HostInfo::GetDefaultShell());
     break;
 
   case 'E':
     launch_info.GetEnvironment().insert(option_arg);
     break;
 
+  case 'S':
+    launch_info.SetScriptedProcess(true);
+    launch_info.SetProcessPluginName("ScriptedProcess");
+    break;
+
   default:
     error.SetErrorStringWithFormat("unrecognized short option character '%c'",
                                    short_option);
     break;
   }
   return error;
 }
 
 llvm::ArrayRef<OptionDefinition> CommandOptionsProcessLaunch::GetDefinitions() {
   return llvm::makeArrayRef(g_process_launch_options);
 }

lldb/source/Commands/Options.td

let Command = "process launch" in {
   def process_launch_stderr : Option<"stderr", "e">, Group<1>,
     Arg<"Filename">, Desc<"Redirect stderr for the process to <filename>.">;
   def process_launch_tty : Option<"tty", "t">, Group<2>,
     Desc<"Start the process in a terminal (not supported on all platforms).">;
   def process_launch_no_stdio : Option<"no-stdio", "n">, Group<3>,
     Desc<"Do not set up for terminal I/O to go to running process.">;
   def process_launch_shell_expand_args : Option<"shell-expand-args", "X">, Group<4>,
     Arg<"Boolean">, Desc<"Set whether to shell expand arguments to the process when launching.">;
+  def process_launch_scripted : Option<"scripted", "S">, GroupRange<1,4>,
+    Desc<"Whether the process launched is a scripted process.">;
 }
 
 let Command = "process attach" in {
   def process_attach_continue : Option<"continue", "c">,
     Desc<"Immediately continue the process once attached.">;
   def process_attach_plugin : Option<"plugin", "P">, Arg<"Plugin">,
     Desc<"Name of the process plugin you want to use.">;
   def process_attach_pid : Option<"pid", "p">, Group<1>, Arg<"Pid">,

lldb/source/Host/common/ProcessLaunchInfo.cpp

 //===-- ProcessLaunchInfo.cpp ---------------------------------------------===//
 //
 // 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 <climits>
 
 #include "lldb/Host/Config.h"
 #include "lldb/Host/FileAction.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/ProcessLaunchInfo.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/FileSystem.h"
 
 #if !defined(_WIN32)
 #include <limits.h>
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
 
 // ProcessLaunchInfo member functions
 
 ProcessLaunchInfo::ProcessLaunchInfo()
     : ProcessInfo(), m_working_dir(), m_plugin_name(), m_flags(0),
       m_file_actions(), m_pty(new PseudoTerminal), m_resume_count(0),
       m_monitor_callback(nullptr), m_monitor_callback_baton(nullptr),
-      m_monitor_signals(false), m_listener_sp(), m_hijack_listener_sp() {}
+      m_monitor_signals(false), m_listener_sp(), m_hijack_listener_sp(),
+      m_scripted_process(false), m_scripted_process_class_name(),
+      m_scripted_process_dictionary_sp() {}
 
 ProcessLaunchInfo::ProcessLaunchInfo(const FileSpec &stdin_file_spec,
                                      const FileSpec &stdout_file_spec,
                                      const FileSpec &stderr_file_spec,
                                      const FileSpec &working_directory,
                                      uint32_t launch_flags)
     : ProcessInfo(), m_working_dir(), m_plugin_name(), m_flags(launch_flags),
       m_file_actions(), m_pty(new PseudoTerminal), m_resume_count(0),
       m_monitor_callback(nullptr), m_monitor_callback_baton(nullptr),
-      m_monitor_signals(false), m_listener_sp(), m_hijack_listener_sp() {
+      m_monitor_signals(false), m_listener_sp(), m_hijack_listener_sp(),
+      m_scripted_process(false), m_scripted_process_class_name(),
+      m_scripted_process_dictionary_sp() {
   if (stdin_file_spec) {
     FileAction file_action;
     const bool read = true;
     const bool write = false;
     if (file_action.Open(STDIN_FILENO, stdin_file_spec, read, write))
       AppendFileAction(file_action);
   }
   if (stdout_file_spec) {
void ProcessLaunchInfo::Clear() {
   m_working_dir.Clear();
   m_plugin_name.clear();
   m_shell.Clear();
   m_flags.Clear();
   m_file_actions.clear();
   m_resume_count = 0;
   m_listener_sp.reset();
   m_hijack_listener_sp.reset();
+  m_scripted_process = false;
+  m_scripted_process_class_name = "";
+  m_scripted_process_dictionary_sp.reset();
 }
 
 void ProcessLaunchInfo::SetMonitorProcessCallback(
     const Host::MonitorChildProcessCallback &callback, bool monitor_signals) {
   m_monitor_callback = callback;
   m_monitor_signals = monitor_signals;
 }
 

lldb/source/Plugins/Process/CMakeLists.txt

 if (CMAKE_SYSTEM_NAME MATCHES "Linux|Android")
   add_subdirectory(Linux)
   add_subdirectory(POSIX)
 elseif (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
   add_subdirectory(FreeBSDRemote)
   add_subdirectory(FreeBSD)
   add_subdirectory(POSIX)
 elseif (CMAKE_SYSTEM_NAME MATCHES "NetBSD")
   add_subdirectory(NetBSD)
   add_subdirectory(POSIX)
 elseif (CMAKE_SYSTEM_NAME MATCHES "Windows")
   add_subdirectory(Windows/Common)
 elseif (CMAKE_SYSTEM_NAME MATCHES "Darwin")
   add_subdirectory(MacOSX-Kernel)
 endif()
+add_subdirectory(Scripted)
 add_subdirectory(gdb-remote)
 add_subdirectory(Utility)
 add_subdirectory(elf-core)
 add_subdirectory(mach-core)
 add_subdirectory(minidump)

lldb/source/Plugins/Process/Scripted/CMakeLists.txt

+add_lldb_library(lldbPluginScriptedProcess PLUGIN
+  ScriptedProcess.cpp
+
+  LINK_LIBS
+    lldbCore
+    lldbTarget
+    lldbUtility
+    lldbPluginProcessUtility
+  LINK_COMPONENTS
+    BinaryFormat
+    Object
+    Support
+  )
 No newline at end of file

lldb/source/Plugins/Process/Scripted/ScriptedProcess.h

+//===-- ScriptedProcess.cpp -----------------------------------------------===//
+//
+// 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 LLDB_SOURCE_PLUGINS_SCRIPTED_PROCESS_H
+#define LLDB_SOURCE_PLUGINS_SCRIPTED_PROCESS_H
+
+#include "lldb/Target/Process.h"
+#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/Status.h"
+
+namespace lldb_private {
+
+class ScriptedProcess : public Process {
+protected:
+  class LaunchInfo {
+  public:
+    LaunchInfo(const ProcessLaunchInfo &launch_info) {
+      m_class_name = launch_info.GetScriptedProcessClassName();
+      m_dictionary_sp = launch_info.GetScriptedProcessDictionarySP();
+    }
+
+    llvm::StringRef GetClassName() const { return m_class_name; }
+    StructuredData::DictionarySP GetDictionarySP() const {
+      return m_dictionary_sp;
+    }
+
+  private:
+    llvm::StringRef m_class_name;
+    StructuredData::DictionarySP m_dictionary_sp;
+  };
+
+public:
+  static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp,
+                                        lldb::ListenerSP listener_sp,
+                                        const FileSpec *crash_file_path,
+                                        bool can_connect);
+
+  static void Initialize();
+
+  static void Terminate();
+
+  static ConstString GetPluginNameStatic();
+
+  static const char *GetPluginDescriptionStatic();
+
+  ScriptedProcess(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
+                  const ScriptedProcess::LaunchInfo &launch_info);
+
+  ~ScriptedProcess() override;
+
+  bool CanDebug(lldb::TargetSP target_sp,
+                bool plugin_specified_by_name) override;
+
+  DynamicLoader *GetDynamicLoader() override { return nullptr; }
+
+  ConstString GetPluginName() override;
+
+  uint32_t GetPluginVersion() override;
+
+  SystemRuntime *GetSystemRuntime() override { return nullptr; }
+
+  Status DoLaunch(Module *exe_module, ProcessLaunchInfo &launch_info) override;
+
+  Status DoResume() override;
+
+  Status DoDestroy() override;
+
+  void RefreshStateAfterStop() override {};
+
+  bool IsAlive() override;
+
+  size_t ReadMemory(lldb::addr_t addr, void *buf, size_t size,
+                    Status &error) override;
+
+  size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
+                      Status &error) override;
+
+  ArchSpec GetArchitecture();
+
+  Status GetMemoryRegionInfo(lldb::addr_t load_addr,
+                             MemoryRegionInfo &range_info) override;
+
+  Status
+  GetMemoryRegions(lldb_private::MemoryRegionInfos &region_list) override;
+
+  bool GetProcessInfo(ProcessInstanceInfo &info) override;
+
+protected:
+  void Clear();
+
+  bool DoUpdateThreadList(ThreadList &old_thread_list,
+                          ThreadList &new_thread_list) override;
+
+private:
+  const LaunchInfo &m_launch_info;
+  lldb_private::ScriptInterpreter *m_interpreter;
+  lldb_private::StructuredData::ObjectSP m_python_object_sp;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_SOURCE_PLUGINS_SCRIPTED_PROCESS_H

lldb/source/Plugins/Process/Scripted/ScriptedProcess.cpp

+//===-- ScriptedProcess.cpp -------------------------------------------===//
+//
+// 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 "ScriptedProcess.h"
+
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/PluginManager.h"
+
+#include "lldb/Host/OptionParser.h"
+
+#include "lldb/Interpreter/OptionArgParser.h"
+#include "lldb/Interpreter/OptionGroupBoolean.h"
+#include "lldb/Interpreter/ScriptInterpreter.h"
+
+#include "lldb/Target/MemoryRegionInfo.h"
+
+LLDB_PLUGIN_DEFINE(ScriptedProcess)
+
+using namespace lldb;
+using namespace lldb_private;
+
+ConstString ScriptedProcess::GetPluginNameStatic() {
+  static ConstString g_name("ScriptedProcess");
+  return g_name;
+}
+
+const char *ScriptedProcess::GetPluginDescriptionStatic() {
+  return "Scripted Process plug-in.";
+}
+
+lldb::ProcessSP ScriptedProcess::CreateInstance(lldb::TargetSP target_sp,
+                                                lldb::ListenerSP listener_sp,
+                                                const FileSpec *file,
+                                                bool can_connect) {
+  LaunchInfo launch_info(target_sp->GetProcessLaunchInfo());
+
+  return std::make_shared<ScriptedProcess>(target_sp, listener_sp, launch_info);
+}
+
+bool ScriptedProcess::CanDebug(lldb::TargetSP target_sp,
+                               bool plugin_specified_by_name) {
+  return true;
+}
+
+ScriptedProcess::ScriptedProcess(lldb::TargetSP target_sp,
+                                 lldb::ListenerSP listener_sp,
+                                 const ScriptedProcess::LaunchInfo &launch_info)
+    : Process(target_sp, listener_sp), m_launch_info(launch_info),
+      m_interpreter(nullptr), m_python_object_sp(nullptr) {
+  if (!target_sp)
+    return;
+
+  m_interpreter = target_sp->GetDebugger().GetScriptInterpreter();
+
+  if (!m_interpreter)
+    return;
+
+  StructuredData::ObjectSP object_sp =
+      m_interpreter->ScriptedProcess_CreatePluginObject(
+          m_launch_info.GetClassName().str().c_str(), target_sp,
+          m_launch_info.GetDictionarySP());
+
+  if (object_sp && object_sp->IsValid())
+    m_python_object_sp = object_sp;
+}
+
+ScriptedProcess::~ScriptedProcess() {
+  Clear();
+  // We need to call finalize on the process before destroying ourselves to
+  // make sure all of the broadcaster cleanup goes as planned. If we destruct
+  // this class, then Process::~Process() might have problems trying to fully
+  // destroy the broadcaster.
+  Finalize();
+}
+
+void ScriptedProcess::Initialize() {
+  static llvm::once_flag g_once_flag;
+
+  llvm::call_once(g_once_flag, []() {
+    PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                  GetPluginDescriptionStatic(), CreateInstance);
+  });
+}
+
+void ScriptedProcess::Terminate() {
+  PluginManager::UnregisterPlugin(ScriptedProcess::CreateInstance);
+}
+
+ConstString ScriptedProcess::GetPluginName() { return GetPluginNameStatic(); }
+
+uint32_t ScriptedProcess::GetPluginVersion() { return 1; }
+
+Status ScriptedProcess::DoLaunch(Module *exe_module,
+                                 ProcessLaunchInfo &launch_info) {
+  if (!m_interpreter)
+    return Status("No interpreter.");
+
+  if (!m_python_object_sp)
+    return Status("No python object.");
+
+  Status status = m_interpreter->ScriptedProcess_Launch(m_python_object_sp);
+
+  if (status.Success())
+    this->SetPrivateState(eStateStopped);
+
+  return status;
+};
+
+Status ScriptedProcess::DoResume() { return Status(); }
+
+Status ScriptedProcess::DoDestroy() { return Status(); }
+
+bool ScriptedProcess::IsAlive() { return true; }
+
+size_t ScriptedProcess::ReadMemory(lldb::addr_t addr, void *buf, size_t size,
+                                   Status &error) {
+  // Don't allow the caching that lldb_private::Process::ReadMemory does since
+  // we have it all cached in our dump file anyway.
+
+  return DoReadMemory(addr, buf, size, error);
+}
+
+size_t ScriptedProcess::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
+                                     Status &error) {
+
+  m_interpreter->ScriptedProcess_ReadMemoryAtAddress(m_python_object_sp, addr,
+                                                     size);
+  return size;
+}
+
+ArchSpec ScriptedProcess::GetArchitecture() {
+  return GetTarget().GetArchitecture();
+}
+
+Status ScriptedProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
+                                            MemoryRegionInfo &region) {
+  //  BuildMemoryRegions();
+  //  region = MinidumpParser::GetMemoryRegionInfo(*m_memory_regions,
+  //  load_addr);
+  return Status();
+}
+
+Status ScriptedProcess::GetMemoryRegions(MemoryRegionInfos &region_list) {
+  Status error;
+  auto size =
+      m_interpreter->ScriptedProcess_GetNumMemoryRegions(m_python_object_sp);
+
+  if (size == LLDB_INVALID_ADDRESS) {
+    error.SetErrorString("ScriptedProcess: Invalid number of memory region!");
+    return error;
+  }
+
+  for (uint64_t i = 0; i < size; i++) {
+    // FIXME: Update interface method to handle extra arg (index)
+    MemoryRegionInfoSP mem_region_sp =
+        m_interpreter->ScriptedProcess_GetMemoryRegionAtIndex(
+            m_python_object_sp, i);
+
+    if (!mem_region_sp) {
+      // FIXME: Interpolate index in error string
+      error.SetErrorString(
+          "ScriptedProcess: Couldn't fetch memory region at index BLA");
+      return error;
+    }
+    region_list.push_back(*mem_region_sp.get());
+  }
+
+  return error;
+}
+
+void ScriptedProcess::Clear() { Process::m_thread_list.Clear(); }
+
+bool ScriptedProcess::DoUpdateThreadList(ThreadList &old_thread_list,
+                                         ThreadList &new_thread_list) {
+  return new_thread_list.GetSize(false) > 0;
+}
+
+bool ScriptedProcess::GetProcessInfo(ProcessInstanceInfo &info) {
+  info.Clear();
+  info.SetProcessID(GetID());
+  info.SetArchitecture(GetArchitecture());
+  lldb::ModuleSP module_sp = GetTarget().GetExecutableModule();
+  if (module_sp) {
+    const bool add_exe_file_as_first_arg = false;
+    info.SetExecutableFile(GetTarget().GetExecutableModule()->GetFileSpec(),
+                           add_exe_file_as_first_arg);
+  }
+  return true;
+}

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

 //===-- ScriptInterpreterPython.cpp ---------------------------------------===//
 //
 // 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/Host/Config.h"
 #include "lldb/lldb-enumerations.h"
 
 #if LLDB_ENABLE_PYTHON
 
 // LLDB Python header must be included first
 #include "lldb-python.h"
 
 #include "PythonDataObjects.h"
 #include "PythonReadline.h"
 #include "ScriptInterpreterPythonImpl.h"
+#include "lldb/API/SBError.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Breakpoint/WatchpointOptions.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/ValueObject.h"
LLDBSwigPythonCreateSyntheticProvider(const char *python_class_name,
                                       const char *session_dictionary_name,
                                       const lldb::ValueObjectSP &valobj_sp);
 
 extern "C" void *
 LLDBSwigPythonCreateCommandObject(const char *python_class_name,
                                   const char *session_dictionary_name,
                                   const lldb::DebuggerSP debugger_sp);
 
+extern "C" void *LLDBSwigPythonCreateScriptedProcess(
+    const char *python_class_name, const char *session_dictionary_name,
+    const lldb::TargetSP &target_sp, StructuredDataImpl *args_impl,
+    std::string &error_string);
+
 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,

 extern "C" void *LLDBSwigPython_GetChildAtIndex(void *implementor,
                                                 uint32_t idx);
 
 extern "C" int LLDBSwigPython_GetIndexOfChildWithName(void *implementor,
                                                       const char *child_name);
 
 extern "C" void *LLDBSWIGPython_CastPyObjectToSBValue(void *data);
 
+extern "C" void *LLDBSWIGPython_CastPyObjectToSBError(void *data);
+
 extern lldb::ValueObjectSP
 LLDBSWIGPython_GetValueObjectSPFromSBValue(void *data);
 
 extern "C" bool LLDBSwigPython_UpdateSynthProviderInstance(void *implementor);
 
 extern "C" bool
 LLDBSwigPython_MightHaveChildrenSynthProviderInstance(void *implementor);
 
Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     ret_val = LLDBSwigPythonCreateCommandObject(
         class_name, m_dictionary_name.c_str(), debugger_sp);
   }
 
   return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
 }
 
+#pragma mark ScriptedProcessInterface
+
+StructuredData::GenericSP
+ScriptInterpreterPythonImpl::ScriptedProcess_CreatePluginObject(
+    const char *class_name, lldb::TargetSP target_sp,
+    StructuredData::DictionarySP args_sp) {
+  if (class_name == nullptr || class_name[0] == '\0')
+    return {};
+
+  std::string error_string;
+  StructuredDataImpl *args_impl = nullptr;
+  if (args_sp) {
+    args_impl = new StructuredDataImpl();
+    args_impl->SetObjectSP(args_sp);
+  }
+
+  void *ret_val;
+
+  {
+    Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN,
+                   Locker::FreeLock);
+
+    ret_val = LLDBSwigPythonCreateScriptedProcess(
+        class_name, m_dictionary_name.c_str(), target_sp, args_impl,
+        error_string);
+  }
+
+  return StructuredData::GenericSP(new StructuredPythonObject(ret_val));
+}
+
+Status ScriptInterpreterPythonImpl::ScriptedProcess_Launch(
+    StructuredData::ObjectSP scripted_process_object_sp) {
+  Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
+
+  static char callee_name[] = "launch";
+
+  if (!scripted_process_object_sp)
+    return Status("Python object ill-formed.");
+
+  StructuredData::Generic *generic = scripted_process_object_sp->GetAsGeneric();
+  if (!generic)
+    return Status("Cannot convert Python object to StructuredData::Generic.");
+  PythonObject implementor(PyRefType::Borrowed,
+                           (PyObject *)generic->GetValue());
+
+  if (!implementor.IsAllocated())
+    return Status("Python implementor not allocated.");
+
+  PythonObject pmeth(PyRefType::Owned,
+                     PyObject_GetAttrString(implementor.get(), callee_name));
+
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  if (!pmeth.IsAllocated())
+    return Status("Python method not allocated.");
+
+  if (PyCallable_Check(pmeth.get()) == 0) {
+    if (PyErr_Occurred())
+      PyErr_Clear();
+    return Status("Python method not callable.");
+  }
+
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  // right now we know this function exists and is callable..
+  PythonObject py_return(
+      PyRefType::Owned,
+      PyObject_CallMethod(implementor.get(), callee_name, nullptr));
+
+  // if it fails, print the error but otherwise go on
+  if (PyErr_Occurred()) {
+    PyErr_Print();
+    PyErr_Clear();
+  }
+
+  if (PyObject *py_ret_ptr = py_return.get()) {
+    lldb::SBError *sb_error =
+        (lldb::SBError *)LLDBSWIGPython_CastPyObjectToSBError(py_ret_ptr);
+
+    if (!sb_error)
+      return Status("Couldn't cast lldb::SBError to lldb::Status.");
+
+    if (sb_error->Fail())
+      return Status("error: %s", sb_error->GetCString());
+
+    return Status();
+  }
+
+  return Status("Returned object is null.");
+}
+
+size_t ScriptInterpreterPythonImpl::ScriptedProcess_GetNumMemoryRegions(
+    StructuredData::ObjectSP scripted_process_object_sp) {
+  Locker py_lock(this, Locker::AcquireLock | Locker::NoSTDIN, Locker::FreeLock);
+
+  static char callee_name[] = "get_num_memory_regions";
+
+  if (!scripted_process_object_sp)
+    return LLDB_INVALID_ADDRESS;
+
+  StructuredData::Generic *generic = scripted_process_object_sp->GetAsGeneric();
+  if (!generic)
+    return LLDB_INVALID_ADDRESS;
+  PythonObject implementor(PyRefType::Borrowed,
+                           (PyObject *)generic->GetValue());
+
+  if (!implementor.IsAllocated())
+    return LLDB_INVALID_ADDRESS;
+
+  PythonObject pmeth(PyRefType::Owned,
+                     PyObject_GetAttrString(implementor.get(), callee_name));
+
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  if (!pmeth.IsAllocated())
+    return LLDB_INVALID_ADDRESS;
+
+  if (PyCallable_Check(pmeth.get()) == 0) {
+    if (PyErr_Occurred())
+      PyErr_Clear();
+    return LLDB_INVALID_ADDRESS;
+  }
+
+  if (PyErr_Occurred())
+    PyErr_Clear();
+
+  // right now we know this function exists and is callable..
+  PythonObject py_return(
+      PyRefType::Owned,
+      PyObject_CallMethod(implementor.get(), callee_name, nullptr));
+
+  // if it fails, print the error but otherwise go on
+  if (PyErr_Occurred()) {
+    PyErr_Print();
+    PyErr_Clear();
+  }
+
+  if (py_return.get()) {
+    PythonDictionary result(PyRefType::Borrowed, py_return.get());
+    auto size = result.AsUnsignedLongLong();
+    return (size) ? *size : LLDB_INVALID_ADDRESS;
+  }
+  return LLDB_INVALID_ADDRESS;
+}
+
+lldb::MemoryRegionInfoSP
+ScriptInterpreterPythonImpl::ScriptedProcess_GetMemoryRegionAtIndex(
+    StructuredData::ObjectSP scripted_process_object_sp, size_t index) {
+  // TODO: Implement
+  return nullptr;
+}
+
+size_t ScriptInterpreterPythonImpl::ScriptedProcess_GetNumThreads(
+    StructuredData::ObjectSP scripted_process_object_sp) {
+  // TODO: Implement
+  return LLDB_INVALID_ADDRESS;
+}
+
+lldb::ThreadSP ScriptInterpreterPythonImpl::ScriptedProcess_GetThreadAtIndex(
+    StructuredData::ObjectSP scripted_process_object_sp, size_t index) {
+  // TODO: Implement
+  return nullptr;
+}
+
+StructuredData::DictionarySP
+ScriptInterpreterPythonImpl::ScriptedProcess_GetRegisterForThread(
+    StructuredData::ObjectSP scripted_process_object_sp) {
+  // TODO: Implement
+  return nullptr;
+}
+
+size_t ScriptInterpreterPythonImpl::ScriptedProcess_ReadMemoryAtAddress(
+    StructuredData::ObjectSP scripted_process_object_sp, lldb::addr_t address,
+    size_t size) {
+  // TODO: Implement
+  return LLDB_INVALID_ADDRESS;
+}
+
+StructuredData::DictionarySP
+ScriptInterpreterPythonImpl::ScriptedProcess_GetLoadedImages(
+    StructuredData::ObjectSP scripted_process_object_sp) {
+  // TODO: Implement
+  return nullptr;
+}
+
+lldb::pid_t ScriptInterpreterPythonImpl::ScriptedProcess_GetProcessID(
+    StructuredData::ObjectSP scripted_process_object_sp) {
+  // TODO: Implement
+  return LLDB_INVALID_PROCESS_ID;
+}
+
+bool ScriptInterpreterPythonImpl::ScriptedProcess_CanDebug(
+    StructuredData::ObjectSP scripted_process_object_sp) {
+  // TODO: Implement
+  return true;
+}
+
+bool ScriptInterpreterPythonImpl::ScriptedProcess_IsAlive(
+    StructuredData::ObjectSP scripted_process_object_sp) {
+  // TODO: Implement
+  return true;
+}
+
 bool ScriptInterpreterPythonImpl::GenerateTypeScriptFunction(
     const char *oneliner, std::string &output, const void *name_token) {
   StringList input;
   input.SplitIntoLines(oneliner, strlen(oneliner));
   return GenerateTypeScriptFunction(input, output, name_token);
 }
 
 bool ScriptInterpreterPythonImpl::GenerateTypeSynthClass(

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

 //===-- ScriptInterpreterPythonImpl.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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/Config.h"
 
 #if LLDB_ENABLE_PYTHON
 
 #include "lldb-python.h"
 
 #include "PythonDataObjects.h"
 #include "ScriptInterpreterPython.h"
 
public:
 
   StructuredData::ObjectSP
   CreateSyntheticScriptedProvider(const char *class_name,
                                   lldb::ValueObjectSP valobj) override;
 
   StructuredData::GenericSP
   CreateScriptCommandObject(const char *class_name) override;
 
+  StructuredData::GenericSP ScriptedProcess_CreatePluginObject(
+      const char *class_name, lldb::TargetSP target_sp,
+      StructuredData::DictionarySP args_sp) override;
+
+  Status ScriptedProcess_Launch(
+      StructuredData::ObjectSP scripted_process_object_sp) override;
+
+  size_t ScriptedProcess_GetNumMemoryRegions(
+      StructuredData::ObjectSP scripted_process_object_sp) override;
+
+  lldb::MemoryRegionInfoSP ScriptedProcess_GetMemoryRegionAtIndex(
+      StructuredData::ObjectSP scripted_process_object_sp,
+      size_t index) override;
+
+  size_t ScriptedProcess_GetNumThreads(
+      StructuredData::ObjectSP scripted_process_object_sp) override;
+
+  lldb::ThreadSP ScriptedProcess_GetThreadAtIndex(
+      StructuredData::ObjectSP scripted_process_object_sp,
+      size_t index) override;
+
+  StructuredData::DictionarySP ScriptedProcess_GetRegisterForThread(
+      StructuredData::ObjectSP scripted_process_object_sp) override;
+
+  size_t ScriptedProcess_ReadMemoryAtAddress(
+      StructuredData::ObjectSP scripted_process_object_sp, lldb::addr_t address,
+      size_t size) override;
+
+  StructuredData::DictionarySP ScriptedProcess_GetLoadedImages(
+      StructuredData::ObjectSP scripted_process_object_sp) override;
+
+  lldb::pid_t ScriptedProcess_GetProcessID(
+      StructuredData::ObjectSP scripted_process_object_sp) override;
+
+  bool ScriptedProcess_CanDebug(
+      StructuredData::ObjectSP scripted_process_object_sp) override;
+
+  bool ScriptedProcess_IsAlive(
+      StructuredData::ObjectSP scripted_process_object_sp) 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,

lldb/source/Target/Target.cpp

 //===-- Target.cpp --------------------------------------------------------===//
 //
 // 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/Target.h"
 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
 #include "lldb/Breakpoint/BreakpointIDList.h"
 #include "lldb/Breakpoint/BreakpointPrecondition.h"
 #include "lldb/Breakpoint/BreakpointResolver.h"
 #include "lldb/Breakpoint/BreakpointResolverAddress.h"
 #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
 #include "lldb/Breakpoint/BreakpointResolverFileRegex.h"
 #include "lldb/Breakpoint/BreakpointResolverName.h"
Status Target::Launch(ProcessLaunchInfo &launch_info, Stream *stream) {
   }
 
   if (!launch_info.GetArchitecture().IsValid())
     launch_info.GetArchitecture() = GetArchitecture();
 
   // If we're not already connected to the process, and if we have a platform
   // that can launch a process for debugging, go ahead and do that here.
   if (state != eStateConnected && platform_sp &&
-      platform_sp->CanDebugProcess()) {
+      platform_sp->CanDebugProcess() && !launch_info.IsScriptedProcess()) {
     LLDB_LOGF(log, "Target::%s asking the platform to debug the process",
               __FUNCTION__);
 
     // If there was a previous process, delete it before we make the new one.
     // One subtle point, we delete the process before we release the reference
     // to m_process_sp.  That way even if we are the last owner, the process
     // will get Finalized before it gets destroyed.
     DeleteCurrentProcess();

lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp

 //===-- PythonTestSuite.cpp -----------------------------------------------===//
 //
 // 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 "gtest/gtest.h"
 
 #include "Plugins/ScriptInterpreter/Python/lldb-python.h"
 
 #include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h"
 #include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPythonImpl.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 
extern "C" int LLDBSwigPython_GetIndexOfChildWithName(void *implementor,
                                                       const char *child_name) {
   return 0;
 }
 
 extern "C" void *LLDBSWIGPython_CastPyObjectToSBValue(void *data) {
   return nullptr;
 }
 
+extern "C" void *LLDBSWIGPython_CastPyObjectToSBError(void *data) {
+  return nullptr;
+}
+
 extern lldb::ValueObjectSP
 LLDBSWIGPython_GetValueObjectSPFromSBValue(void *data) {
   return nullptr;
 }
 
 extern "C" bool LLDBSwigPython_UpdateSynthProviderInstance(void *implementor) {
   return false;
 }