[lldb] Add scripted process launch/attach option to {,platform }process commands

[mib]

Summary

This patch does several things:

First, it refactors the CommandObject{,Platform}ProcessObject command
option class into a separate CommandOptionsProcessAttach option group.

This will make sure both the platform process attach and process attach
command options will always stay in sync without having with duplicate
them each time. But more importantly, making this class an OptionGroup
allows us to combine with a OptionGroupPythonClassWithDict to add
support for the scripted process managing class name and user-provided
dictionary options.

This patch also improves feature parity between ProcessLaunchInfo and
ProcessAttachInfo with regard to ScriptedProcesses, by exposing the
various getters and setters necessary to use them through the SBAPI.

This is foundation work for adding support to "attach" to a process from
the scripted platform.

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

[labath]

For a "plugin", the scripted process is sure getting a lot of special handling in generic code. (I know this isn't being introduced here, but I wasn't involved in the previous review -- and I'm not actually sure I want to be involved here). I don't think that's necessarily a bad thing in this case, but maybe we should not be calling it a plugin in that case? We already have a couple of precedents for putting implementations of "pluggable" classes into generic code -- ProcessTrace for instance. And just like in the case of ProcessTrace (where the real plugin is the thing which handles the trace file format), here the real plugin would the the scripting language backing the scripted process?

(Apart from that, this patch seems fine.)

[JDevlieghere]

In D139945#3999351, @labath wrote:

For a "plugin", the scripted process is sure getting a lot of special handling in generic code. (I know this isn't being introduced here, but I wasn't involved in the previous review -- and I'm not actually sure I want to be involved here). I don't think that's necessarily a bad thing in this case, but maybe we should not be calling it a plugin in that case? We already have a couple of precedents for putting implementations of "pluggable" classes into generic code -- ProcessTrace for instance. And just like in the case of ProcessTrace (where the real plugin is the thing which handles the trace file format), here the real plugin would the the scripting language backing the scripted process?

(Apart from that, this patch seems fine.)

Maybe one way around this is to have some generic metadata that gets passed to the plugin, that can be different per plugin?

[labath]

In D139945#4009427, @JDevlieghere wrote:

In D139945#3999351, @labath wrote:

For a "plugin", the scripted process is sure getting a lot of special handling in generic code. (I know this isn't being introduced here, but I wasn't involved in the previous review -- and I'm not actually sure I want to be involved here). I don't think that's necessarily a bad thing in this case, but maybe we should not be calling it a plugin in that case? We already have a couple of precedents for putting implementations of "pluggable" classes into generic code -- ProcessTrace for instance. And just like in the case of ProcessTrace (where the real plugin is the thing which handles the trace file format), here the real plugin would the the scripting language backing the scripted process?

(Apart from that, this patch seems fine.)

Maybe one way around this is to have some generic metadata that gets passed to the plugin, that can be different per plugin?

That might work, but I don't think it's really necessary. My only issue is one of nomenclature. I don't see a problem with having a concrete Process subclass in the lldb core. My problem is with calling that class a "plugin", and pretending it's pluggable, but then introducing backdoor dependencies to it (usually by referring to with via its (string) plugin name). You could try to solve that by making it genuinely pluggable, but that could be overkill, given that it already contains *is* pluggable, only in a different way -- one can plugin a different scripting language to implement the bindings (and then obviously the user can plug in to implement those bindings).

[mib]

In D139945#4011466, @labath wrote:

In D139945#4009427, @JDevlieghere wrote:

In D139945#3999351, @labath wrote:

For a "plugin", the scripted process is sure getting a lot of special handling in generic code. (I know this isn't being introduced here, but I wasn't involved in the previous review -- and I'm not actually sure I want to be involved here). I don't think that's necessarily a bad thing in this case, but maybe we should not be calling it a plugin in that case? We already have a couple of precedents for putting implementations of "pluggable" classes into generic code -- ProcessTrace for instance. And just like in the case of ProcessTrace (where the real plugin is the thing which handles the trace file format), here the real plugin would the the scripting language backing the scripted process?

(Apart from that, this patch seems fine.)

Maybe one way around this is to have some generic metadata that gets passed to the plugin, that can be different per plugin?

That might work, but I don't think it's really necessary. My only issue is one of nomenclature. I don't see a problem with having a concrete Process subclass in the lldb core. My problem is with calling that class a "plugin", and pretending it's pluggable, but then introducing backdoor dependencies to it (usually by referring to with via its (string) plugin name). You could try to solve that by making it genuinely pluggable, but that could be overkill, given that it already contains *is* pluggable, only in a different way -- one can plugin a different scripting language to implement the bindings (and then obviously the user can plug in to implement those bindings).

@labath I'm taking note of your comment but as you said it's the pluggable design of scripted processes is not introduced in this patch. I also have some plans for Scripted Processes that may involve rethinking its pluggable design, so I'll keep your feedback in mind for when I implement those changes :)

[mib]

Rebase

[mib]

Fix build failures after rebase

[JDevlieghere]

LGTM modulo inline comments.

lldb/include/lldb/Target/Process.h

235–239

I know you're just doing this for consistency but please use Doxygen style comments /// on the line before. Bonus points if you fix the ones above as well.

lldb/source/Commands/CommandOptionsProcessAttach.h

18

Let's stop cargo culting these frankly useless comments.

41

Remove

44

lldb/include/lldb/API/SBAttachInfo.h

public:
 
   /// Set the listener that will be used to receive process events.
   ///
   /// By default the SBDebugger, which has a listener, that the SBTarget
   /// belongs to will listen for the process events. Calling this function
   /// allows a different listener to be used to listen for process events.
   void SetListener(SBListener &listener);
 
+  const char *GetScriptedProcessClassName() const;
+
+  void SetScriptedProcessClassName(const char *class_name);
+
+  lldb::SBStructuredData GetScriptedProcessDictionary() const;
+
+  void SetScriptedProcessDictionary(lldb::SBStructuredData dict);
+
 protected:
   friend class SBTarget;
 
   lldb_private::ProcessAttachInfo &ref();
 
   ProcessAttachInfoSP m_opaque_sp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBATTACHINFO_H

lldb/include/lldb/API/SBStructuredData.h

#endif
   ///     string value will be written at \a dst followed by a null character.
   ///
   /// \return
   ///     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 SBAttachInfo;
   friend class SBLaunchInfo;
   friend class SBDebugger;
   friend class SBTarget;
   friend class SBProcess;
   friend class SBThread;
   friend class SBThreadPlan;
   friend class SBBreakpoint;
   friend class SBBreakpointLocation;
   friend class SBBreakpointName;
   friend class SBTrace;
 
   StructuredDataImplUP m_impl_up;
 };
 } // namespace lldb
 
 #endif // LLDB_API_SBSTRUCTUREDDATA_H

lldb/include/lldb/Target/Process.h

public:
   lldb::ListenerSP GetListener() const { return m_listener_sp; }
 
   void SetListener(const lldb::ListenerSP &listener_sp) {
     m_listener_sp = listener_sp;
   }
 
   lldb::ListenerSP GetListenerForProcess(Debugger &debugger);
 
+  bool IsScriptedProcess() const {
+    return !m_scripted_process_class_name.empty();
+  }
+
+  std::string GetScriptedProcessClassName() const {
+    return m_scripted_process_class_name;
+  }
+
+  void SetScriptedProcessClassName(std::string 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:
   lldb::ListenerSP m_listener_sp;
   lldb::ListenerSP m_hijack_listener_sp;
   std::string m_plugin_name;
   uint32_t m_resume_count = 0; // How many times do we resume after launching
   bool m_wait_for_launch = false;
   bool m_ignore_existing = true;
   bool m_continue_once_attached = false; // Supports the use-case scenario of
                                          // immediately continuing the process
                                          // once attached.
   bool m_detach_on_error =
       true; // If we are debugging remotely, instruct the stub to
             // detach rather than killing the target on error.
   bool m_async =
       false; // Use an async attach where we start the attach and return
              // immediately (used by GUI programs with --waitfor so they can
              // call SBProcess::Stop() to cancel attach)
+  std::string m_scripted_process_class_name; // The name of the class that will
+                                             // manage a scripted process.
+  StructuredData::DictionarySP
+      m_scripted_process_dictionary_sp; // A dictionary that holds key/value
+                                        // pairs passed to the scripted process.
 };
 
 // This class tracks the Modification state of the process.  Things that can
 // currently modify the program are running the program (which will up the
 // StopID) and writing memory (which will up the MemoryID.)
 // FIXME: Should we also include modification of register states?
 
 class ProcessModID {

lldb/source/API/SBAttachInfo.cpp

 //===-- SBAttachInfo.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/API/SBAttachInfo.h"
 #include "Utils.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBListener.h"
+#include "lldb/API/SBStructuredData.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/Instrumentation.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBAttachInfo::SBAttachInfo() : m_opaque_sp(new ProcessAttachInfo()) {
   LLDB_INSTRUMENT_VA(this);
SBListener SBAttachInfo::GetListener() {
   return SBListener(m_opaque_sp->GetListener());
 }
 
 void SBAttachInfo::SetListener(SBListener &listener) {
   LLDB_INSTRUMENT_VA(this, listener);
 
   m_opaque_sp->SetListener(listener.GetSP());
 }
+
+const char *SBAttachInfo::GetScriptedProcessClassName() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  // Constify this string so that it is saved in the string pool.  Otherwise it
+  // would be freed when this function goes out of scope.
+  ConstString class_name(m_opaque_sp->GetScriptedProcessClassName().c_str());
+  return class_name.AsCString();
+}
+
+void SBAttachInfo::SetScriptedProcessClassName(const char *class_name) {
+  LLDB_INSTRUMENT_VA(this, class_name);
+
+  m_opaque_sp->SetScriptedProcessClassName(class_name);
+}
+
+lldb::SBStructuredData SBAttachInfo::GetScriptedProcessDictionary() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  lldb_private::StructuredData::DictionarySP dict_sp =
+      m_opaque_sp->GetScriptedProcessDictionarySP();
+
+  SBStructuredData data;
+  data.m_impl_up->SetObjectSP(dict_sp);
+
+  return data;
+}
+
+void SBAttachInfo::SetScriptedProcessDictionary(lldb::SBStructuredData dict) {
+  LLDB_INSTRUMENT_VA(this, dict);
+  if (!dict.IsValid() || !dict.m_impl_up)
+    return;
+
+  StructuredData::ObjectSP obj_sp = dict.m_impl_up->GetObjectSP();
+
+  if (!obj_sp)
+    return;
+
+  StructuredData::DictionarySP dict_sp =
+      std::make_shared<StructuredData::Dictionary>(obj_sp);
+  if (!dict_sp || dict_sp->GetType() == lldb::eStructuredDataTypeInvalid)
+    return;
+
+  m_opaque_sp->SetScriptedProcessDictionarySP(dict_sp);
+}

lldb/source/Commands/CMakeLists.txt

add_lldb_library(lldbCommands
   CommandObjectThread.cpp
   CommandObjectThreadUtil.cpp
   CommandObjectTrace.cpp
   CommandObjectType.cpp
   CommandObjectVersion.cpp
   CommandObjectWatchpoint.cpp
   CommandObjectWatchpointCommand.cpp
   CommandOptionArgumentTable.cpp
+  CommandOptionsProcessAttach.cpp
   CommandOptionsProcessLaunch.cpp
 
   LINK_LIBS
     lldbBreakpoint
     lldbCore
     lldbDataFormatters
     lldbExpression
     lldbHost

lldb/source/Commands/CommandObjectPlatform.cpp

 //===-- CommandObjectPlatform.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 "CommandObjectPlatform.h"
+#include "CommandOptionsProcessAttach.h"
 #include "CommandOptionsProcessLaunch.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandOptionArgumentTable.h"
 #include "lldb/Interpreter/CommandOptionValidators.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionGroupFile.h"
 #include "lldb/Interpreter/OptionGroupPlatform.h"
+#include "lldb/Interpreter/OptionGroupPythonClassWithDict.h"
+#include "lldb/Interpreter/ScriptedMetadata.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/Args.h"
 
 #include "llvm/ADT/SmallString.h"
 
 using namespace lldb;

 
 // "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) {
+                            eCommandRequiresTarget | eCommandTryTargetAPILock),
+        m_class_options("scripted process", true, 'C', 'k', 'v', 0) {
     m_all_options.Append(&m_options);
+    m_all_options.Append(&m_class_options, LLDB_OPT_SET_1 | LLDB_OPT_SET_2,
+                         LLDB_OPT_SET_ALL);
     m_all_options.Finalize();
     CommandArgumentData run_arg_arg{eArgTypeRunArgs, eArgRepeatStar};
     m_arguments.push_back({run_arg_arg});
   }
 
   ~CommandObjectPlatformProcessLaunch() override = default;
 
   Options *GetOptions() override { return &m_all_options; }
if (platform_sp) {
         m_options.launch_info.GetExecutableFile() = exe_module->GetFileSpec();
         llvm::SmallString<128> exe_path;
         m_options.launch_info.GetExecutableFile().GetPath(exe_path);
         if (!exe_path.empty())
           m_options.launch_info.GetArguments().AppendArgument(exe_path);
         m_options.launch_info.GetArchitecture() = exe_module->GetArchitecture();
       }
 
+      if (!m_class_options.GetName().empty()) {
+        m_options.launch_info.SetProcessPluginName("ScriptedProcess");
+        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 (argc > 0) {
         if (m_options.launch_info.GetExecutableFile()) {
           // We already have an executable file, so we will use this and all
           // arguments to this function are extra arguments
           m_options.launch_info.GetArguments().AppendArguments(args);
         } else {
           // We don't have any file yet, so the first argument is our
           // executable, and the rest are program arguments
if (platform_sp) {
       }
     } else {
       result.AppendError("no platform is selected\n");
     }
     return result.Succeeded();
   }
 
   CommandOptionsProcessLaunch m_options;
+  OptionGroupPythonClassWithDict m_class_options;
   OptionGroupOptions m_all_options;
 };
 
 // "platform process list"
 
 static PosixPlatformCommandOptionValidator posix_validator;
 #define LLDB_OPTIONS_platform_process_list
 #include "CommandOptions.inc"
protected:
   }
 };
 
 #define LLDB_OPTIONS_platform_process_attach
 #include "CommandOptions.inc"
 
 class CommandObjectPlatformProcessAttach : public CommandObjectParsed {
 public:
-  class CommandOptions : public Options {
-  public:
-    CommandOptions() {
-      // Keep default values of all options in one place: OptionParsingStarting
-      // ()
-      OptionParsingStarting(nullptr);
-    }
-
-    ~CommandOptions() override = default;
-
-    Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
-                          ExecutionContext *execution_context) override {
-      Status error;
-      char short_option = (char)m_getopt_table[option_idx].val;
-      switch (short_option) {
-      case 'p': {
-        lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
-        if (option_arg.getAsInteger(0, pid)) {
-          error.SetErrorStringWithFormat("invalid process ID '%s'",
-                                         option_arg.str().c_str());
-        } else {
-          attach_info.SetProcessID(pid);
-        }
-      } break;
-
-      case 'P':
-        attach_info.SetProcessPluginName(option_arg);
-        break;
-
-      case 'n':
-        attach_info.GetExecutableFile().SetFile(option_arg,
-                                                FileSpec::Style::native);
-        break;
-
-      case 'w':
-        attach_info.SetWaitForLaunch(true);
-        break;
-
-      default:
-        llvm_unreachable("Unimplemented option");
-      }
-      return error;
-    }
-
-    void OptionParsingStarting(ExecutionContext *execution_context) override {
-      attach_info.Clear();
-    }
-
-    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
-      return llvm::ArrayRef(g_platform_process_attach_options);
-    }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
-
-    // Instance variables to hold the values for command options.
-
-    ProcessAttachInfo attach_info;
-  };
-
   CommandObjectPlatformProcessAttach(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "platform process attach",
                             "Attach to a process.",
-                            "platform process attach <cmd-options>") {}
+                            "platform process attach <cmd-options>"),
+        m_class_options("scripted process", true, 'C', 'k', 'v', 0) {
+    m_all_options.Append(&m_options);
+    m_all_options.Append(&m_class_options, LLDB_OPT_SET_1 | LLDB_OPT_SET_2,
+                         LLDB_OPT_SET_ALL);
+    m_all_options.Finalize();
+  }
 
   ~CommandObjectPlatformProcessAttach() override = default;
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     PlatformSP platform_sp(
         GetDebugger().GetPlatformList().GetSelectedPlatform());
     if (platform_sp) {
+
+      if (!m_class_options.GetName().empty()) {
+        m_options.attach_info.SetProcessPluginName("ScriptedProcess");
+        m_options.attach_info.SetScriptedProcessClassName(
+            m_class_options.GetName());
+        m_options.attach_info.SetScriptedProcessDictionarySP(
+            m_class_options.GetStructuredData());
+      }
+
       Status err;
       ProcessSP remote_process_sp = platform_sp->Attach(
           m_options.attach_info, GetDebugger(), nullptr, err);
       if (err.Fail()) {
         result.AppendError(err.AsCString());
       } else if (!remote_process_sp) {
         result.AppendError("could not attach: unknown reason");
       } else
         result.SetStatus(eReturnStatusSuccessFinishResult);
     } else {
       result.AppendError("no platform is currently selected");
     }
     return result.Succeeded();
   }
 
-  Options *GetOptions() override { return &m_options; }
+  Options *GetOptions() override { return &m_all_options; }
 
 protected:
-  CommandOptions m_options;
+  CommandOptionsProcessAttach m_options;
+  OptionGroupPythonClassWithDict m_class_options;
+  OptionGroupOptions m_all_options;
 };
 
 class CommandObjectPlatformProcess : public CommandObjectMultiword {
 public:
   // Constructors and Destructors
   CommandObjectPlatformProcess(CommandInterpreter &interpreter)
       : CommandObjectMultiword(interpreter, "platform process",
                                "Commands to query, launch and attach to "

lldb/source/Commands/CommandObjectProcess.cpp

 //===-- CommandObjectProcess.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 "CommandObjectProcess.h"
 #include "CommandObjectBreakpoint.h"
 #include "CommandObjectTrace.h"
+#include "CommandOptionsProcessAttach.h"
 #include "CommandOptionsProcessLaunch.h"
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointIDList.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/BreakpointName.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/CommandOptionArgumentTable.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupPythonClassWithDict.h"
 #include "lldb/Interpreter/Options.h"
+#include "lldb/Interpreter/ScriptedMetadata.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"
 #include "lldb/Utility/State.h"

 };
 
 #define LLDB_OPTIONS_process_attach
 #include "CommandOptions.inc"
 
 #pragma mark CommandObjectProcessAttach
 class CommandObjectProcessAttach : public CommandObjectProcessLaunchOrAttach {
 public:
-  class CommandOptions : public Options {
-  public:
-    CommandOptions() {
-      // Keep default values of all options in one place: OptionParsingStarting
-      // ()
-      OptionParsingStarting(nullptr);
-    }
-
-    ~CommandOptions() override = default;
-
-    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;
-      switch (short_option) {
-      case 'c':
-        attach_info.SetContinueOnceAttached(true);
-        break;
-
-      case 'p': {
-        lldb::pid_t pid;
-        if (option_arg.getAsInteger(0, pid)) {
-          error.SetErrorStringWithFormat("invalid process ID '%s'",
-                                         option_arg.str().c_str());
-        } else {
-          attach_info.SetProcessID(pid);
-        }
-      } break;
-
-      case 'P':
-        attach_info.SetProcessPluginName(option_arg);
-        break;
-
-      case 'n':
-        attach_info.GetExecutableFile().SetFile(option_arg,
-                                                FileSpec::Style::native);
-        break;
-
-      case 'w':
-        attach_info.SetWaitForLaunch(true);
-        break;
-
-      case 'i':
-        attach_info.SetIgnoreExisting(false);
-        break;
-
-      default:
-        llvm_unreachable("Unimplemented option");
-      }
-      return error;
-    }
-
-    void OptionParsingStarting(ExecutionContext *execution_context) override {
-      attach_info.Clear();
-    }
-
-    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
-      return llvm::ArrayRef(g_process_attach_options);
-    }
-
-    ProcessAttachInfo attach_info;
-  };
-
   CommandObjectProcessAttach(CommandInterpreter &interpreter)
       : CommandObjectProcessLaunchOrAttach(
             interpreter, "process attach", "Attach to a process.",
-            "process attach <cmd-options>", 0, "attach") {}
+            "process attach <cmd-options>", 0, "attach"),
+        m_class_options("scripted process", true, 'C', 'k', 'v', 0) {
+    m_all_options.Append(&m_options);
+    m_all_options.Append(&m_class_options, LLDB_OPT_SET_1 | LLDB_OPT_SET_2,
+                         LLDB_OPT_SET_ALL);
+    m_all_options.Finalize();
+  }
 
   ~CommandObjectProcessAttach() override = default;
 
-  Options *GetOptions() override { return &m_options; }
+  Options *GetOptions() override { return &m_all_options; }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     PlatformSP platform_sp(
         GetDebugger().GetPlatformList().GetSelectedPlatform());
 
     Target *target = GetDebugger().GetSelectedTarget().get();
     // N.B. The attach should be synchronous.  It doesn't help much to get the
if (target == nullptr) {
           new_target_sp);
       target = new_target_sp.get();
       if (target == nullptr || error.Fail()) {
         result.AppendError(error.AsCString("Error creating target"));
         return false;
       }
     }
 
+    if (!m_class_options.GetName().empty()) {
+      m_options.attach_info.SetProcessPluginName("ScriptedProcess");
+      m_options.attach_info.SetScriptedProcessClassName(
+          m_class_options.GetName());
+      m_options.attach_info.SetScriptedProcessDictionarySP(
+          m_class_options.GetStructuredData());
+    }
+
     // Record the old executable module, we want to issue a warning if the
     // process of attaching changed the current executable (like somebody said
     // "file foo" then attached to a PID whose executable was bar.)
 
     ModuleSP old_exec_module_sp = target->GetExecutableModule();
     ArchSpec old_arch_spec = target->GetArchitecture();
 
     StreamString stream;
if (m_options.attach_info.GetContinueOnceAttached()) {
       // here:
       ExecutionContext exe_ctx(process_sp);
       m_interpreter.HandleCommand("process continue", eLazyBoolNo, exe_ctx, result);
     }
 
     return result.Succeeded();
   }
 
-  CommandOptions m_options;
+  CommandOptionsProcessAttach m_options;
+  OptionGroupPythonClassWithDict m_class_options;
+  OptionGroupOptions m_all_options;
 };
 
 // CommandObjectProcessContinue
 
 #define LLDB_OPTIONS_process_continue
 #include "CommandOptions.inc"
 
 #pragma mark CommandObjectProcessContinue

lldb/source/Commands/CommandOptionsProcessAttach.h

+//===-- CommandOptionsProcessAttach.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_COMMANDOPTIONSPROCESSATTACH_H
+#define LLDB_SOURCE_COMMANDS_COMMANDOPTIONSPROCESSATTACH_H
+
+#include "lldb/Interpreter/Options.h"
+#include "lldb/Target/Process.h"
+
+namespace lldb_private {
+
+// CommandOptionsProcessAttach
+
+class CommandOptionsProcessAttach : public lldb_private::OptionGroup {
+public:
+  CommandOptionsProcessAttach() {
+    // Keep default values of all options in one place: OptionParsingStarting
+    // ()
+    OptionParsingStarting(nullptr);
+  }
+
+  ~CommandOptionsProcessAttach() override = default;
+
+  lldb_private::Status
+  SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
+                 lldb_private::ExecutionContext *execution_context) override;
+
+  void OptionParsingStarting(
+      lldb_private::ExecutionContext *execution_context) override {
+    attach_info.Clear();
+  }
+
+  llvm::ArrayRef<lldb_private::OptionDefinition> GetDefinitions() override;
+
+  // Instance variables to hold the values for command options.
+
+  lldb_private::ProcessAttachInfo attach_info;
+}; // CommandOptionsProcessAttach
+
+} // namespace lldb_private
+
+#endif // LLDB_SOURCE_COMMANDS_COMMANDOPTIONSPROCESSATTACH_H

lldb/source/Commands/CommandOptionsProcessAttach.cpp

+//===-- CommandOptionsProcessAttach.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 "CommandOptionsProcessAttach.h"
+
+#include "lldb/Host/FileSystem.h"
+#include "lldb/Host/HostInfo.h"
+#include "lldb/Host/OptionParser.h"
+#include "lldb/Interpreter/CommandCompletions.h"
+#include "lldb/Interpreter/CommandObject.h"
+#include "lldb/Interpreter/CommandOptionArgumentTable.h"
+#include "lldb/Interpreter/OptionArgParser.h"
+#include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/Platform.h"
+#include "lldb/Target/Target.h"
+
+#include "llvm/ADT/ArrayRef.h"
+
+using namespace llvm;
+using namespace lldb;
+using namespace lldb_private;
+
+#define LLDB_OPTIONS_process_attach
+#include "CommandOptions.inc"
+
+Status CommandOptionsProcessAttach::SetOptionValue(
+    uint32_t option_idx, llvm::StringRef option_arg,
+    ExecutionContext *execution_context) {
+  Status error;
+  const int short_option = g_process_attach_options[option_idx].short_option;
+  switch (short_option) {
+  case 'c':
+    attach_info.SetContinueOnceAttached(true);
+    break;
+
+  case 'p': {
+    lldb::pid_t pid;
+    if (option_arg.getAsInteger(0, pid)) {
+      error.SetErrorStringWithFormat("invalid process ID '%s'",
+                                     option_arg.str().c_str());
+    } else {
+      attach_info.SetProcessID(pid);
+    }
+  } break;
+
+  case 'P':
+    attach_info.SetProcessPluginName(option_arg);
+    break;
+
+  case 'n':
+    attach_info.GetExecutableFile().SetFile(option_arg,
+                                            FileSpec::Style::native);
+    break;
+
+  case 'w':
+    attach_info.SetWaitForLaunch(true);
+    break;
+
+  case 'i':
+    attach_info.SetIgnoreExisting(false);
+    break;
+
+  default:
+    llvm_unreachable("Unimplemented option");
+  }
+  return error;
+}
+
+llvm::ArrayRef<OptionDefinition> CommandOptionsProcessAttach::GetDefinitions() {
+  return llvm::makeArrayRef(g_process_attach_options);
+}