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

[mib]

Summary

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

This patch adds a new command options to the CommandObjectProcessLaunch
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.

This patch also adds getters and setters to SBLaunchInfo for the
class name managing the scripted process and the dictionary.

rdar://65508855

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

[vsk]

lldb/include/lldb/Host/ProcessLaunchInfo.h

188

Might be best to use a std::string here, to avoid tying the lifetime of m_scripted_process_class_name to the lifetime of the string stored in m_class_options.

[jingham]

I'm not quite sure why we need the extra m_scripted_process boolean. Seems like you could key off whether we had a non-empty class_name. Is there any case where you would want to boolean set w/o having a class name yet?

lldb/include/lldb/Host/ProcessLaunchInfo.h

188

Agreed. You seldom want to use a StringRef as an ivar, since it doesn't manage lifetimes at all.

[mib]

Address @jingham and @vsk comments.

[JDevlieghere]

LGTM with a few nits.

lldb/include/lldb/Host/ProcessLaunchInfo.h

187

Can you add a Doxygen comment explaining what they're used for?

lldb/source/Host/common/ProcessLaunchInfo.cpp

178

Let's call clear for consistency with m_plugin_name which is also a string.

[mib]

Address @JDevlieghere comments.

[mib]

Add getters and setters for scripted process managing class name and dictionary in SBLaunchInfo.

[mib]

Landed in 3e0ad115439622b9c3e6ca9fd64c7fb07a679f1a

[labath]

Sorry for grave digging, but my compiler just became smart enough to start complaining about this.

lldb/source/API/SBLaunchInfo.cpp

392 ↗

(On Diff #323911)

you're dereferencing a null pointer here.

[mib]

In D95710#3118346, @labath wrote:

Sorry for grave digging, but my compiler just became smart enough to start complaining about this.

Haha, not at all! This wasn't called when I implemented it, but I stumbled into it in following patches and fixed it in D112109.

The fix hasn't landed yet because I'm still trying to understand why would the python-initialized SBStructuredData be pointing the corrupted memory when trying accessing it in C++, instead of deserializing it into a std::string, and serializing it back, which is more a workaround that an actual fix.

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/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;
 }