[lldb/Plugins] Add Attach capabilities to ScriptedProcess

[mib]

Summary

This patch adds process attach capabilities to the ScriptedProcess
plugin. This doesn't really expects a PID or process name, since the
process state is already script, however, this allows to create a
scripted process without requiring to have an executuble in the target.

In order to do so, this patch also turns the scripted process related
getters and setters from the ProcessLaunchInfo and
ProcessAttachInfo classes to a ScriptedMetadata instance and moves
it in the ProcessInfo class, so it can be accessed interchangeably.

This also adds the necessary SWIG wrappers to convert the internal
Process{Attach,Launch}InfoSP into a SB{Attach,Launch}Info to pass it
as argument the scripted process python implementation and convert it
back to the internal representation.

rdar://104577406

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

[bulbazord]

Makes sense to me. It does seem a little weird that you can specify a name or a pid for attaching to a scripted process but I suppose that's just a part of the interface.

[JDevlieghere]

lldb/include/lldb/Utility/ProcessInfo.h

90–110

What's the relationship between this an the ScriptedMetadata? It seems like this is storing the same stuff. Also IsScriptedProcess is a pretty blatant violation of the scripted process being a plugin...

[mib]

lldb/include/lldb/Utility/ProcessInfo.h

90–110

I think you have a misunderstanding here: This is addition is not made in a process plugin, but rather in the ProcessInfo class, the base class for ProcessLaunchInfo and ProcessAttachInfo, so I don't think this violates in any way the plugin architecture.

Regarding the relationship with ScriptedMetadata: I guess we could replace m_scripted_process_class_name & m_scripted_process_dictionary_sp by a m_scripted_metadata object, but I didn't want to process info hold scripted process specific stuff. I don't have a strong opinion against it, either.

[JDevlieghere]

lldb/include/lldb/Utility/ProcessInfo.h

90–110

I think you have a misunderstanding here: This is addition is not made in a process plugin, but rather in the ProcessInfo class, the base class for ProcessLaunchInfo and ProcessAttachInfo, so I don't think this violates in any way the plugin architecture.

I know, but I would argue that the distinction between those two is pretty much irrelevant. That said, I do understand the need to pass this information, especially as more things become more scriptable (process, platform, etc). That's why I suggested using the ScriptedMetadata here because it's more generic.

Concretely my suggestion would be to have {Set,Get}ScriptedMetadata and if you think you really need it, maybe an IsScripted method that checks if the metadata is set (either by storing an optional ScriptedMetadata in the ProcessInfo or maybe through calling an operator bool on the ScriptedMetadata (which would check the name being empty like you do here).

but I didn't want to process info hold scripted process specific stuff.

I totally agree, as of now ScriptedMetadata contains the exact two fields that you have here. If other patches are extending that for the scripted processes or platforms, we could keep the common stuff in a base class and have a ScriptedProcessMetadata and ScriptedPlatformMetadata respectively. WDYT?

[mib]

lldb/include/lldb/Utility/ProcessInfo.h

90–110

That sounds fair to me. Let's go with your suggestion.

[mib]

Addressed @JDevlieghere comments.

[JDevlieghere]

lldb/include/lldb/Utility/ProcessInfo.h

90

Can we not ask this from the ScriptedMetadata?

lldb/source/API/SBAttachInfo.cpp

272

Newline after LLDB_INSTRUMENT_VA

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

213–222

Wouldn't you want to at least pass this information down to the scripted process? I could imagine that the PID and the process name, if known, could be pretty interesting to store in the scripted process, even if it always succeeds regardless.

[mib]

lldb/include/lldb/Utility/ProcessInfo.h

90

I think this is fine to ask the ProcessInfo for this.

If we got rid of this, instead of calling IsScriptedProcess, we would need first to get ScriptedMetadata shared pointer and make sure it's not null, then deference it to call the operator bool(). I don't think it's worth it.

[mib]

Address @JDevlieghere feedback.

[bulbazord]

I'm not sure how much this matters but the fact that ScriptedMetadata::IsValid (and the bool operator overload) relies on the class name being empty is a little strange to me. I feel like you could get yourself into a strange situation where you set the ScriptedMetadata class name to "" and then ask for it right back and instead of giving you "" it'll give you nullptr (or None in python). This also "invalidates" the ScriptedMetadata. Not a hard blocker, just a little strange to me.

lldb/source/API/SBAttachInfo.cpp

272

There needs to be a newline after LLDB_INSTRUMENT_VA here I believe.

273–278

Maybe I'm misunderstanding but it seems like this implementation doesn't allow you to actually change the class name more than once? If that's not intentional, then we should be creating a new ScriptedMetadata and calling SetScriptedMetadata every time. If it is intentional, why?

316–325

Same as above: This doesn't actually let you change the arguments if we already have an existing ScriptedMetadata. If its already set, we're just calling SetScriptedMetadata with what already exists and discarding the argument.

lldb/source/API/SBLaunchInfo.cpp

348–352

Needs to be a newline after LLDB_INSTRUMENT_VA

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

200–205

I'm not sure I understand what the point of setting the state to Running is and only setting it to Stopped if the attach failed? Should we be mucking with state at all if the attach failed?

[mib]

lldb/source/API/SBAttachInfo.cpp

273–278

Good catch! I forgot to check-in some code --'

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

200–205

I guess we can do it subsequently

[mib]

• Address @bulbazord comment about only being able to assign the Scripted Metadata attributes once.
• Add necessary SWIG wrappers to convert the internal type into SB counterpart and back.

[bulbazord]

I still think it's a little weird that you can create LaunchInfo or AttachInfo, call SetScriptedProcessDictionary, and still have the ScriptedMetadata be "invalid", but I suppose it makes no sense if there is no class name anyway.

Just a few small things. Everything else looks fine to me.

lldb/source/API/SBAttachInfo.cpp

272

Add a new line after the instrument macro

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

200–205

I'm not sure this was addressed and maybe I don't understand something but why do we check to see if the error failed only after setting the state to running? If we actually did fail to attach, does it make sense to think of the ScriptedProcess as "running"?

[mib]

• Address last feedbacks
• Fix unittest

[JDevlieghere]

LGTM

[labath]

lldb/source/Utility/ProcessInfo.cpp

11

This is a layering violation. Can we restructure this so that it this does not depend on code outside the Utility library? Maybe the ScriptedMetadata thingy could be moved into the Utility library?

[mib]

lldb/source/Utility/ProcessInfo.cpp

11

@labath Thanks for pointing this out! I fixed it in D145414

[stella.stamenova]

Looks like this change broke the windows lldb build: https://lab.llvm.org/buildbot/#/builders/83/builds/29801

[mib]

In D143104#4173574, @stella.stamenova wrote:

Looks like this change broke the windows lldb build: https://lab.llvm.org/buildbot/#/builders/83/builds/29801

Hi @stella.stamenova ! @omjavaid have a fix for this https://reviews.llvm.org/D145446

lldb/bindings/python/python-swigsafecast.swig

return ToSWIGHelper(new lldb::SBTypeSummaryOptions(summary_options),
                       SWIGTYPE_p_lldb__SBTypeSummaryOptions);
 }
 
 PythonObject ToSWIGWrapper(const SymbolContext &sym_ctx) {
   return ToSWIGHelper(new lldb::SBSymbolContext(sym_ctx),
                       SWIGTYPE_p_lldb__SBSymbolContext);
 }
 
+PythonObject ToSWIGWrapper(lldb::ProcessLaunchInfoSP launch_info_sp) {
+   return ToSWIGHelper(new lldb::ProcessLaunchInfoSP(std::move(launch_info_sp)),
+                       SWIGTYPE_p_lldb__SBLaunchInfo);
+ }
+
+ PythonObject ToSWIGWrapper(lldb::ProcessAttachInfoSP attach_info_sp) {
+   return ToSWIGHelper(new lldb::ProcessAttachInfoSP(std::move(attach_info_sp)),
+                       SWIGTYPE_p_lldb__SBAttachInfo);
+ }
+
 ScopedPythonObject<lldb::SBCommandReturnObject>
 ToSWIGWrapper(CommandReturnObject &cmd_retobj) {
   return ScopedPythonObject<lldb::SBCommandReturnObject>(
       new lldb::SBCommandReturnObject(cmd_retobj),
       SWIGTYPE_p_lldb__SBCommandReturnObject);
 }
 
 ScopedPythonObject<lldb::SBEvent> ToSWIGWrapper(Event *event) {
   return ScopedPythonObject<lldb::SBEvent>(new lldb::SBEvent(event),
                                            SWIGTYPE_p_lldb__SBEvent);
 }
 
 } // namespace python
 } // namespace lldb_private

lldb/bindings/python/python-wrapper.swig

int valid_cast =
       SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBData, 0);
 
   if (valid_cast == -1)
     return NULL;
 
   return sb_ptr;
 }
 
+void *lldb_private::LLDBSWIGPython_CastPyObjectToSBAttachInfo(PyObject * data) {
+  lldb::SBAttachInfo *sb_ptr = nullptr;
+
+  int valid_cast =
+      SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBAttachInfo, 0);
+
+  if (valid_cast == -1)
+    return NULL;
+
+  return sb_ptr;
+}
+
+void *lldb_private::LLDBSWIGPython_CastPyObjectToSBLaunchInfo(PyObject * data) {
+  lldb::SBLaunchInfo *sb_ptr = nullptr;
+
+  int valid_cast =
+      SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBLaunchInfo, 0);
+
+  if (valid_cast == -1)
+    return NULL;
+
+  return sb_ptr;
+}
+
 void *lldb_private::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;

lldb/examples/python/scripted_process/scripted_process.py

class ScriptedProcess(metaclass=ABCMeta):
     def launch(self):
         """ Simulate the scripted process launch.
 
         Returns:
             lldb.SBError: An `lldb.SBError` with error code 0.
         """
         return lldb.SBError()
 
+    def attach(self, attach_info):
+        """ Simulate the scripted process attach.
+
+        Args:
+            attach_info (lldb.SBAttachInfo): The information related to the
+            process we're attaching to.
+
+        Returns:
+            lldb.SBError: An `lldb.SBError` with error code 0.
+        """
+        return lldb.SBError()
+
     def resume(self):
         """ Simulate the scripted process resume.
 
         Returns:
             lldb.SBError: An `lldb.SBError` with error code 0.
         """
         return lldb.SBError()
 

lldb/include/lldb/API/SBAttachInfo.h

 //===-- SBAttachInfo.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_API_SBATTACHINFO_H
 #define LLDB_API_SBATTACHINFO_H
 
 #include "lldb/API/SBDefines.h"
 
+namespace lldb_private {
+class ScriptInterpreter;
+}
+
 namespace lldb {
 
 class SBTarget;
 
 class LLDB_API SBAttachInfo {
 public:
   SBAttachInfo();
 
public:
 
   lldb::SBStructuredData GetScriptedProcessDictionary() const;
 
   void SetScriptedProcessDictionary(lldb::SBStructuredData dict);
 
 protected:
   friend class SBTarget;
 
+  friend class lldb_private::ScriptInterpreter;
+
   lldb_private::ProcessAttachInfo &ref();
 
   ProcessAttachInfoSP m_opaque_sp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBATTACHINFO_H

lldb/include/lldb/API/SBLaunchInfo.h

 //===-- SBLaunchInfo.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_API_SBLAUNCHINFO_H
 #define LLDB_API_SBLAUNCHINFO_H
 
 #include "lldb/API/SBDefines.h"
 
 namespace lldb_private {
 class SBLaunchInfoImpl;
+class ScriptInterpreter;
 }
 
 namespace lldb {
 
 class SBPlatform;
 class SBTarget;
 
 class LLDB_API SBLaunchInfo {
#endif
   lldb::SBStructuredData GetScriptedProcessDictionary() const;
 
   void SetScriptedProcessDictionary(lldb::SBStructuredData dict);
 
 protected:
   friend class SBPlatform;
   friend class SBTarget;
 
+  friend class lldb_private::ScriptInterpreter;
+
   const lldb_private::ProcessLaunchInfo &ref() const;
   void set_ref(const lldb_private::ProcessLaunchInfo &info);
 
   std::shared_ptr<lldb_private::SBLaunchInfoImpl> m_opaque_sp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBLAUNCHINFO_H

lldb/include/lldb/Host/ProcessLaunchInfo.h

 // 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_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:
   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 = 0; // How many times do we resume after launching
   Host::MonitorChildProcessCallback m_monitor_callback;
   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;
-  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.
 };
 }
 
 #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/API/SBAttachInfo.h"
 #include "lldb/API/SBData.h"
 #include "lldb/API/SBError.h"
+#include "lldb/API/SBLaunchInfo.h"
 #include "lldb/API/SBMemoryRegionInfo.h"
 #include "lldb/Breakpoint/BreakpointOptions.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/SearchFilter.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ThreadedCommunication.h"
 #include "lldb/Host/PseudoTerminal.h"
 #include "lldb/Interpreter/ScriptedPlatformInterface.h"
ScriptedPlatformInterface &GetScriptedPlatformInterface() {
     return *m_scripted_platform_interface_up;
   }
 
   lldb::DataExtractorSP
   GetDataExtractorFromSBData(const lldb::SBData &data) const;
 
   Status GetStatusFromSBError(const lldb::SBError &error) const;
 
+  lldb::ProcessAttachInfoSP
+  GetOpaqueTypeFromSBAttachInfo(const lldb::SBAttachInfo &attach_info) const;
+
+  lldb::ProcessLaunchInfoSP
+  GetOpaqueTypeFromSBLaunchInfo(const lldb::SBLaunchInfo &launch_info) const;
+
   std::optional<MemoryRegionInfo> GetOpaqueTypeFromSBMemoryRegionInfo(
       const lldb::SBMemoryRegionInfo &mem_region) const;
 
 protected:
   Debugger &m_debugger;
   lldb::ScriptLanguage m_script_lang;
   lldb::ScriptedPlatformInterfaceUP m_scripted_platform_interface_up;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_SCRIPTINTERPRETER_H

lldb/include/lldb/Interpreter/ScriptedMetadata.h

 //===-- ScriptedMetadata.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_SCRIPTEDMETADATA_H
 #define LLDB_INTERPRETER_SCRIPTEDMETADATA_H
 
 #include "OptionGroupPythonClassWithDict.h"
 
 #include "lldb/Host/Host.h"
-#include "lldb/Host/ProcessLaunchInfo.h"
+#include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/StructuredData.h"
 
 namespace lldb_private {
 class ScriptedMetadata {
 public:
   ScriptedMetadata(llvm::StringRef class_name,
                    StructuredData::DictionarySP dict_sp)
       : m_class_name(class_name.data()), m_args_sp(dict_sp) {}
 
-  ScriptedMetadata(const ProcessLaunchInfo &launch_info) {
-    m_class_name = launch_info.GetScriptedProcessClassName();
-    m_args_sp = launch_info.GetScriptedProcessDictionarySP();
+  ScriptedMetadata(const ProcessInfo &process_info) {
+    lldb::ScriptedMetadataSP metadata_sp = process_info.GetScriptedMetadata();
+    if (metadata_sp) {
+      m_class_name = metadata_sp->GetClassName();
+      m_args_sp = metadata_sp->GetArgsSP();
+    }
   }
 
   ScriptedMetadata(const OptionGroupPythonClassWithDict &option_group) {
     auto opt_group = const_cast<OptionGroupPythonClassWithDict &>(option_group);
     m_class_name = opt_group.GetName();
     m_args_sp = opt_group.GetStructuredData();
   }
 
+  explicit operator bool() const { return !m_class_name.empty(); }
+
   llvm::StringRef GetClassName() const { return m_class_name; }
   StructuredData::DictionarySP GetArgsSP() const { return m_args_sp; }
 
 private:
   std::string m_class_name;
   StructuredData::DictionarySP m_args_sp;
 };
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_SCRIPTEDMETADATA_H

lldb/include/lldb/Interpreter/ScriptedProcessInterface.h

public:
   CreatePluginObject(llvm::StringRef class_name, ExecutionContext &exe_ctx,
                      StructuredData::DictionarySP args_sp,
                      StructuredData::Generic *script_obj = nullptr) override {
     return {};
   }
 
   virtual StructuredData::DictionarySP GetCapabilities() { return {}; }
 
+  virtual Status Attach(const ProcessAttachInfo &attach_info) {
+    return Status("ScriptedProcess did not attach");
+  }
+
   virtual Status Launch() { return Status("ScriptedProcess did not launch"); }
 
   virtual Status Resume() { return Status("ScriptedProcess did not resume"); }
 
   virtual bool ShouldStop() { return true; }
 
   virtual Status Stop() { return Status("ScriptedProcess did not stop"); }
 

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/include/lldb/Target/Target.h

lldb::REPLSP GetREPL(Status &err, lldb::LanguageType language,
                        const char *repl_options, bool can_create);
 
   void SetREPL(lldb::LanguageType language, lldb::REPLSP repl_sp);
 
   StackFrameRecognizerManager &GetFrameRecognizerManager() {
     return *m_frame_recognizer_manager_up;
   }
 
+  void SaveScriptedLaunchInfo(lldb_private::ProcessInfo &process_info);
+
   /// Add a signal for the target.  This will get copied over to the process
   /// if the signal exists on that target.  Only the values with Yes and No are
   /// set, Calculate values will be ignored.
 protected:
   struct DummySignalValues {
     LazyBool pass = eLazyBoolCalculate;
     LazyBool notify = eLazyBoolCalculate;
     LazyBool stop = eLazyBoolCalculate;

lldb/include/lldb/Utility/ProcessInfo.h

 //===-- ProcessInfo.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_UTILITY_PROCESSINFO_H
 #define LLDB_UTILITY_PROCESSINFO_H
 
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Environment.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/NameMatches.h"
+#include "lldb/Utility/StructuredData.h"
 #include <vector>
 
 namespace lldb_private {
 
 class UserIDResolver;
 
 // ProcessInfo
 //
public:
 
   void SetArguments(const Args &args, bool first_arg_is_executable);
 
   void SetArguments(char const **argv, bool first_arg_is_executable);
 
   Environment &GetEnvironment() { return m_environment; }
   const Environment &GetEnvironment() const { return m_environment; }
 
+  bool IsScriptedProcess() const;
+
+  lldb::ScriptedMetadataSP GetScriptedMetadata() const {
+    return m_scripted_metadata_sp;
+  }
+
+  void SetScriptedMetadata(lldb::ScriptedMetadataSP metadata_sp) {
+    m_scripted_metadata_sp = metadata_sp;
+  }
+
 protected:
   FileSpec m_executable;
   std::string m_arg0; // argv[0] if supported. If empty, then use m_executable.
   // Not all process plug-ins support specifying an argv[0] that differs from
   // the resolved platform executable (which is in m_executable)
   Args m_arguments; // All program arguments except argv[0]
   Environment m_environment;
   uint32_t m_uid = UINT32_MAX;
   uint32_t m_gid = UINT32_MAX;
   ArchSpec m_arch;
   lldb::pid_t m_pid = LLDB_INVALID_PROCESS_ID;
+  lldb::ScriptedMetadataSP m_scripted_metadata_sp = nullptr;
 };
 
 // ProcessInstanceInfo
 //
 // Describes an existing process and any discoverable information that pertains
 // to that process.
 class ProcessInstanceInfo : public ProcessInfo {
 public:

lldb/include/lldb/lldb-forward.h

 class RegisterCheckpoint;
 class RegisterContext;
 class RegisterValue;
 class RegularExpression;
 class RichManglingContext;
 class Scalar;
 class ScriptInterpreter;
 class ScriptInterpreterLocker;
+class ScriptedMetadata;
 class ScriptedPlatformInterface;
 class ScriptedProcessInterface;
 class ScriptedThreadInterface;
 class ScriptedSyntheticChildren;
 class SearchFilter;
 class Section;
 class SectionList;
 class SectionLoadHistory;

 typedef std::weak_ptr<lldb_private::Queue> QueueWP;
 typedef std::shared_ptr<lldb_private::QueueItem> QueueItemSP;
 typedef std::shared_ptr<lldb_private::REPL> REPLSP;
 typedef std::shared_ptr<lldb_private::RecognizedStackFrame>
     RecognizedStackFrameSP;
 typedef std::shared_ptr<lldb_private::ScriptSummaryFormat>
     ScriptSummaryFormatSP;
 typedef std::shared_ptr<lldb_private::ScriptInterpreter> ScriptInterpreterSP;
+typedef std::shared_ptr<lldb_private::ScriptedMetadata> ScriptedMetadataSP;
 typedef std::unique_ptr<lldb_private::ScriptedPlatformInterface>
     ScriptedPlatformInterfaceUP;
 typedef std::unique_ptr<lldb_private::ScriptedProcessInterface>
     ScriptedProcessInterfaceUP;
 typedef std::shared_ptr<lldb_private::ScriptedThreadInterface>
     ScriptedThreadInterfaceSP;
 typedef std::shared_ptr<lldb_private::Section> SectionSP;
 typedef std::unique_ptr<lldb_private::SectionList> SectionListUP;

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/Interpreter/ScriptedMetadata.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);
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);
 
+  ScriptedMetadataSP metadata_sp = m_opaque_sp->GetScriptedMetadata();
+
+  if (!metadata_sp || !*metadata_sp)
+    return nullptr;
+
   // 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());
+  ConstString class_name(metadata_sp->GetClassName().data());
   return class_name.AsCString();
 }
 
 void SBAttachInfo::SetScriptedProcessClassName(const char *class_name) {
   LLDB_INSTRUMENT_VA(this, class_name);
 
-  m_opaque_sp->SetScriptedProcessClassName(class_name);
+  ScriptedMetadataSP metadata_sp = m_opaque_sp->GetScriptedMetadata();
+
+  if (!metadata_sp)
+    metadata_sp = std::make_shared<ScriptedMetadata>(class_name, nullptr);
+  else
+    metadata_sp = std::make_shared<ScriptedMetadata>(class_name,
+                                                     metadata_sp->GetArgsSP());
+
+  m_opaque_sp->SetScriptedMetadata(metadata_sp);
 }
 
 lldb::SBStructuredData SBAttachInfo::GetScriptedProcessDictionary() const {
   LLDB_INSTRUMENT_VA(this);
 
-  lldb_private::StructuredData::DictionarySP dict_sp =
-      m_opaque_sp->GetScriptedProcessDictionarySP();
+  ScriptedMetadataSP metadata_sp = m_opaque_sp->GetScriptedMetadata();
 
   SBStructuredData data;
+  if (!metadata_sp)
+    return data;
+
+  lldb_private::StructuredData::DictionarySP dict_sp = metadata_sp->GetArgsSP();
   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);
+  ScriptedMetadataSP metadata_sp = m_opaque_sp->GetScriptedMetadata();
+
+  if (!metadata_sp)
+    metadata_sp = std::make_shared<ScriptedMetadata>("", dict_sp);
+  else
+    metadata_sp = std::make_shared<ScriptedMetadata>(
+        metadata_sp->GetClassName(), dict_sp);
+
+  m_opaque_sp->SetScriptedMetadata(metadata_sp);
 }

lldb/source/API/SBLaunchInfo.cpp

 #include "lldb/API/SBEnvironment.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStructuredData.h"
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Host/ProcessLaunchInfo.h"
+#include "lldb/Interpreter/ScriptedMetadata.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 class lldb_private::SBLaunchInfoImpl : public ProcessLaunchInfo {
 public:
   SBLaunchInfoImpl() : m_envp(GetEnvironment().getEnvp()) {}
 
bool SBLaunchInfo::GetDetachOnError() const {
   LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_sp->GetDetachOnError();
 }
 
 const char *SBLaunchInfo::GetScriptedProcessClassName() const {
   LLDB_INSTRUMENT_VA(this);
 
+  ScriptedMetadataSP metadata_sp = m_opaque_sp->GetScriptedMetadata();
+
+  if (!metadata_sp || !*metadata_sp)
+    return nullptr;
+
   // 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());
+  ConstString class_name(metadata_sp->GetClassName().data());
   return class_name.AsCString();
 }
 
 void SBLaunchInfo::SetScriptedProcessClassName(const char *class_name) {
   LLDB_INSTRUMENT_VA(this, class_name);
-
-  m_opaque_sp->SetScriptedProcessClassName(class_name);
+  ScriptedMetadataSP metadata_sp = m_opaque_sp->GetScriptedMetadata();
+  StructuredData::DictionarySP dict_sp =
+      metadata_sp ? metadata_sp->GetArgsSP() : nullptr;
+  metadata_sp = std::make_shared<ScriptedMetadata>(class_name, dict_sp);
+  m_opaque_sp->SetScriptedMetadata(metadata_sp);
 }
 
 lldb::SBStructuredData SBLaunchInfo::GetScriptedProcessDictionary() const {
   LLDB_INSTRUMENT_VA(this);
 
-  lldb_private::StructuredData::DictionarySP dict_sp =
-      m_opaque_sp->GetScriptedProcessDictionarySP();
+  ScriptedMetadataSP metadata_sp = m_opaque_sp->GetScriptedMetadata();
 
   SBStructuredData data;
+  if (!metadata_sp)
+    return data;
+
+  lldb_private::StructuredData::DictionarySP dict_sp = metadata_sp->GetArgsSP();
   data.m_impl_up->SetObjectSP(dict_sp);
 
   return data;
 }
 
 void SBLaunchInfo::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);
+  ScriptedMetadataSP metadata_sp = m_opaque_sp->GetScriptedMetadata();
+  llvm::StringRef class_name = metadata_sp ? metadata_sp->GetClassName() : "";
+  metadata_sp = std::make_shared<ScriptedMetadata>(class_name, dict_sp);
+  m_opaque_sp->SetScriptedMetadata(metadata_sp);
 }

lldb/source/API/SBTarget.cpp

 lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) {
   LLDB_INSTRUMENT_VA(this, sb_attach_info, error);
 
   SBProcess sb_process;
   TargetSP target_sp(GetSP());
 
   if (target_sp) {
     ProcessAttachInfo &attach_info = sb_attach_info.ref();
-    if (attach_info.ProcessIDIsValid() && !attach_info.UserIDIsValid()) {
+    if (attach_info.ProcessIDIsValid() && !attach_info.UserIDIsValid() &&
+        !attach_info.IsScriptedProcess()) {
       PlatformSP platform_sp = target_sp->GetPlatform();
       // See if we can pre-verify if a process exists or not
       if (platform_sp && platform_sp->IsConnected()) {
         lldb::pid_t attach_pid = attach_info.GetProcessID();
         ProcessInstanceInfo instance_info;
         if (platform_sp->GetProcessInfo(attach_pid, instance_info)) {
           attach_info.SetUserID(instance_info.GetEffectiveUserID());
         } else {

lldb/source/Commands/CommandObjectPlatform.cpp

if (platform_sp) {
         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());
+        ScriptedMetadataSP metadata_sp = std::make_shared<ScriptedMetadata>(
+            m_class_options.GetName(), m_class_options.GetStructuredData());
+        m_options.launch_info.SetScriptedMetadata(metadata_sp);
         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);
public:
 
   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());
+        ScriptedMetadataSP metadata_sp = std::make_shared<ScriptedMetadata>(
+            m_class_options.GetName(), m_class_options.GetStructuredData());
+        m_options.attach_info.SetScriptedMetadata(metadata_sp);
       }
 
       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) {

lldb/source/Commands/CommandObjectProcess.cpp

bool DoExecute(Args &launch_args, CommandReturnObject &result) override {
     } 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_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());
+      ScriptedMetadataSP metadata_sp = std::make_shared<ScriptedMetadata>(
+          m_class_options.GetName(), m_class_options.GetStructuredData());
+      m_options.launch_info.SetScriptedMetadata(metadata_sp);
       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 == nullptr) {
       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());
+      ScriptedMetadataSP metadata_sp = std::make_shared<ScriptedMetadata>(
+          m_class_options.GetName(), m_class_options.GetStructuredData());
+      m_options.attach_info.SetScriptedMetadata(metadata_sp);
     }
 
     // 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();

lldb/source/Host/common/ProcessLaunchInfo.cpp

 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_monitor_callback(nullptr),
-      m_listener_sp(), m_hijack_listener_sp(), m_scripted_process_class_name(),
-      m_scripted_process_dictionary_sp() {}
+      m_listener_sp(), m_hijack_listener_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_scripted_process_class_name(), m_scripted_process_dictionary_sp() {
+      m_file_actions(), m_pty(new PseudoTerminal) {
   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_class_name.clear();
-  m_scripted_process_dictionary_sp.reset();
 }
 
 void ProcessLaunchInfo::NoOpMonitorCallback(lldb::pid_t pid, int signal,
                                             int status) {
   Log *log = GetLog(LLDBLog::Process);
   LLDB_LOG(log, "pid = {0}, signal = {1}, status = {2}", pid, signal, status);
 }
 

lldb/source/Interpreter/ScriptInterpreter.cpp

std::string ScriptInterpreter::LanguageToString(lldb::ScriptLanguage language) {
   llvm_unreachable("Unhandled ScriptInterpreter!");
 }
 
 lldb::DataExtractorSP
 ScriptInterpreter::GetDataExtractorFromSBData(const lldb::SBData &data) const {
   return data.m_opaque_sp;
 }
 
+lldb::ProcessAttachInfoSP ScriptInterpreter::GetOpaqueTypeFromSBAttachInfo(
+    const lldb::SBAttachInfo &attach_info) const {
+  return attach_info.m_opaque_sp;
+}
+
+lldb::ProcessLaunchInfoSP ScriptInterpreter::GetOpaqueTypeFromSBLaunchInfo(
+    const lldb::SBLaunchInfo &launch_info) const {
+  return std::make_shared<ProcessLaunchInfo>(
+      *reinterpret_cast<ProcessLaunchInfo *>(launch_info.m_opaque_sp.get()));
+}
+
 Status
 ScriptInterpreter::GetStatusFromSBError(const lldb::SBError &error) const {
   if (error.m_opaque_up)
     return *error.m_opaque_up;
 
   return Status();
 }
 

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

public:
   Status DoLoadCore() override;
 
   Status DoLaunch(Module *exe_module, ProcessLaunchInfo &launch_info) override;
 
   void DidLaunch() override;
 
   Status DoResume() override;
 
+  Status DoAttachToProcessWithID(lldb::pid_t pid,
+                                 const ProcessAttachInfo &attach_info) override;
+
+  Status
+  DoAttachToProcessWithName(const char *process_name,
+                            const ProcessAttachInfo &attach_info) override;
+
+  void DidAttach(ArchSpec &process_arch) override;
+
   Status DoDestroy() override;
 
   void RefreshStateAfterStop() override;
 
   bool IsAlive() override;
 
   size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
                       Status &error) override;
protected:
   void Clear();
 
   bool DoUpdateThreadList(ThreadList &old_thread_list,
                           ThreadList &new_thread_list) override;
 
   Status DoGetMemoryRegionInfo(lldb::addr_t load_addr,
                                MemoryRegionInfo &range_info) override;
 
+  Status DoAttach(const ProcessAttachInfo &attach_info);
+
 private:
   friend class ScriptedThread;
 
   inline void CheckScriptedInterface() const {
     lldbassert(m_interface_up && "Invalid scripted process interface.");
   }
 
   ScriptedProcessInterface &GetInterface() const;

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

if (resume) {
     SetPrivateState(eStateRunning);
     SetPrivateState(eStateStopped);
     error = GetInterface().Resume();
   }
 
   return error;
 }
 
+Status ScriptedProcess::DoAttach(const ProcessAttachInfo &attach_info) {
+  Status error = GetInterface().Attach(attach_info);
+  SetPrivateState(eStateRunning);
+  SetPrivateState(eStateStopped);
+  if (error.Fail())
+    return error;
+  // NOTE: We need to set the PID before finishing to attach otherwise we will
+  // hit an assert when calling the attach completion handler.
+  DidLaunch();
+
+  return {};
+}
+
+Status
+ScriptedProcess::DoAttachToProcessWithID(lldb::pid_t pid,
+                                         const ProcessAttachInfo &attach_info) {
+  return DoAttach(attach_info);
+}
+
+Status ScriptedProcess::DoAttachToProcessWithName(
+    const char *process_name, const ProcessAttachInfo &attach_info) {
+  return DoAttach(attach_info);
+}
+
+void ScriptedProcess::DidAttach(ArchSpec &process_arch) {
+  process_arch = GetArchitecture();
+}
+
 Status ScriptedProcess::DoStop() {
   Log *log = GetLog(LLDBLog::Process);
 
   if (GetInterface().ShouldStop()) {
     SetPrivateState(eStateStopped);
     LLDB_LOGF(log, "ScriptedProcess::%s Immediate stop", __FUNCTION__);
     return {};
   }

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

 PythonObject ToSWIGWrapper(lldb::StackFrameSP frame_sp);
 PythonObject ToSWIGWrapper(lldb::DebuggerSP debugger_sp);
 PythonObject ToSWIGWrapper(lldb::WatchpointSP watchpoint_sp);
 PythonObject ToSWIGWrapper(lldb::BreakpointLocationSP bp_loc_sp);
 PythonObject ToSWIGWrapper(lldb::ExecutionContextRefSP ctx_sp);
 PythonObject ToSWIGWrapper(const TypeSummaryOptions &summary_options);
 PythonObject ToSWIGWrapper(const SymbolContext &sym_ctx);
 
+PythonObject ToSWIGWrapper(lldb::ProcessAttachInfoSP attach_info_sp);
+PythonObject ToSWIGWrapper(lldb::ProcessLaunchInfoSP launch_info_sp);
+
 PythonObject ToSWIGWrapper(std::unique_ptr<lldb::SBValue> value_sb);
 PythonObject ToSWIGWrapper(std::unique_ptr<lldb::SBStream> stream_sb);
 PythonObject ToSWIGWrapper(std::unique_ptr<lldb::SBStructuredData> data_sb);
 
 python::ScopedPythonObject<lldb::SBCommandReturnObject>
 ToSWIGWrapper(CommandReturnObject &cmd_retobj);
 python::ScopedPythonObject<lldb::SBEvent> ToSWIGWrapper(Event *event);
 
 } // namespace python
 
 void *LLDBSWIGPython_CastPyObjectToSBData(PyObject *data);
+void *LLDBSWIGPython_CastPyObjectToSBAttachInfo(PyObject *data);
+void *LLDBSWIGPython_CastPyObjectToSBLaunchInfo(PyObject *data);
 void *LLDBSWIGPython_CastPyObjectToSBError(PyObject *data);
 void *LLDBSWIGPython_CastPyObjectToSBValue(PyObject *data);
 void *LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo(PyObject *data);
 
 // These prototypes are the Pythonic implementations of the required callbacks.
 // Although these are scripting-language specific, their definition depends on
 // the public API.
 

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

public:
   StructuredData::GenericSP
   CreatePluginObject(const llvm::StringRef class_name,
                      ExecutionContext &exe_ctx,
                      StructuredData::DictionarySP args_sp,
                      StructuredData::Generic *script_obj = nullptr) override;
 
   StructuredData::DictionarySP GetCapabilities() override;
 
+  Status Attach(const ProcessAttachInfo &attach_info) override;
+
   Status Launch() override;
 
   Status Resume() override;
 
   bool ShouldStop() override;
 
   Status Stop() override;
 

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

 //===-- ScriptedProcessPythonInterface.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/Target/Process.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-enumerations.h"
 
 #if LLDB_ENABLE_PYTHON
 
 // LLDB Python header must be included first
 #include "lldb-python.h"
StructuredData::DictionarySP dict =
       Dispatch<StructuredData::DictionarySP>("get_capabilities", error);
 
   if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, dict, error))
     return {};
 
   return dict;
 }
 
+Status
+ScriptedProcessPythonInterface::Attach(const ProcessAttachInfo &attach_info) {
+  lldb::ProcessAttachInfoSP attach_info_sp =
+      std::make_shared<ProcessAttachInfo>(attach_info);
+  return GetStatusFromMethod("attach", attach_info_sp);
+}
+
 Status ScriptedProcessPythonInterface::Launch() {
   return GetStatusFromMethod("launch");
 }
 
 Status ScriptedProcessPythonInterface::Resume() {
   return GetStatusFromMethod("resume");
 }
 

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

template <typename T> T Transform(T object) {
     // No Transformation for generic usage
     return {object};
   }
 
   python::PythonObject Transform(Status arg) {
     return python::ToSWIGWrapper(arg);
   }
 
+  python::PythonObject Transform(lldb::ProcessAttachInfoSP arg) {
+    return python::ToSWIGWrapper(arg);
+  }
+
+  python::PythonObject Transform(lldb::ProcessLaunchInfoSP arg) {
+    return python::ToSWIGWrapper(arg);
+  }
+
   template <typename T, typename U>
   void ReverseTransform(T &original_arg, U transformed_arg, Status &error) {
     // If U is not a PythonObject, don't touch it!
     return;
   }
 
   template <typename T>
   void ReverseTransform(T &original_arg, python::PythonObject transformed_arg,

 ScriptedPythonInterface::ExtractValueFromPythonObject<
     StructuredData::DictionarySP>(python::PythonObject &p, Status &error);
 
 template <>
 Status ScriptedPythonInterface::ExtractValueFromPythonObject<Status>(
     python::PythonObject &p, Status &error);
 
 template <>
+lldb::ProcessAttachInfoSP ScriptedPythonInterface::ExtractValueFromPythonObject<
+    lldb::ProcessAttachInfoSP>(python::PythonObject &p, Status &error);
+
+template <>
+lldb::ProcessLaunchInfoSP ScriptedPythonInterface::ExtractValueFromPythonObject<
+    lldb::ProcessLaunchInfoSP>(python::PythonObject &p, Status &error);
+
+template <>
 lldb::DataExtractorSP
 ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::DataExtractorSP>(
     python::PythonObject &p, Status &error);
 
 template <>
 std::optional<MemoryRegionInfo>
 ScriptedPythonInterface::ExtractValueFromPythonObject<
     std::optional<MemoryRegionInfo>>(python::PythonObject &p, Status &error);
 
 } // namespace lldb_private
 
 #endif // LLDB_ENABLE_PYTHON
 #endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTEDPYTHONINTERFACE_H

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

 #include "lldb/Utility/Log.h"
 #include "lldb/lldb-enumerations.h"
 
 #if LLDB_ENABLE_PYTHON
 
 // LLDB Python header must be included first
 #include "lldb-python.h"
 
-#include "SWIGPythonBridge.h"
 #include "ScriptInterpreterPythonImpl.h"
 #include "ScriptedPythonInterface.h"
 #include <optional>
 
 using namespace lldb;
 using namespace lldb_private;
 
 ScriptedPythonInterface::ScriptedPythonInterface(
error.SetErrorString(
         "Couldn't cast lldb::SBData to lldb::DataExtractorSP.");
     return nullptr;
   }
 
   return m_interpreter.GetDataExtractorFromSBData(*sb_data);
 }
 
 template <>
+lldb::ProcessAttachInfoSP ScriptedPythonInterface::ExtractValueFromPythonObject<
+    lldb::ProcessAttachInfoSP>(python::PythonObject &p, Status &error) {
+  lldb::SBAttachInfo *sb_attach_info = reinterpret_cast<lldb::SBAttachInfo *>(
+      LLDBSWIGPython_CastPyObjectToSBAttachInfo(p.get()));
+
+  if (!sb_attach_info) {
+    error.SetErrorString(
+        "Couldn't cast lldb::SBAttachInfo to lldb::ProcessAttachInfoSP.");
+    return nullptr;
+  }
+
+  return m_interpreter.GetOpaqueTypeFromSBAttachInfo(*sb_attach_info);
+}
+
+template <>
+lldb::ProcessLaunchInfoSP ScriptedPythonInterface::ExtractValueFromPythonObject<
+    lldb::ProcessLaunchInfoSP>(python::PythonObject &p, Status &error) {
+  lldb::SBLaunchInfo *sb_launch_info = reinterpret_cast<lldb::SBLaunchInfo *>(
+      LLDBSWIGPython_CastPyObjectToSBLaunchInfo(p.get()));
+
+  if (!sb_launch_info) {
+    error.SetErrorString(
+        "Couldn't cast lldb::SBLaunchInfo to lldb::ProcessLaunchInfoSP.");
+    return nullptr;
+  }
+
+  return m_interpreter.GetOpaqueTypeFromSBLaunchInfo(*sb_launch_info);
+}
+
+template <>
 std::optional<MemoryRegionInfo>
 ScriptedPythonInterface::ExtractValueFromPythonObject<
     std::optional<MemoryRegionInfo>>(python::PythonObject &p, Status &error) {
 
   lldb::SBMemoryRegionInfo *sb_mem_reg_info =
       reinterpret_cast<lldb::SBMemoryRegionInfo *>(
           LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo(p.get()));
 

lldb/source/Target/Target.cpp

bool Target::SetSectionUnloaded(const lldb::SectionSP &section_sp,
   else
     stop_id = m_section_load_history.GetLastStopID();
   return m_section_load_history.SetSectionUnloaded(stop_id, section_sp,
                                                    load_addr);
 }
 
 void Target::ClearAllLoadedSections() { m_section_load_history.Clear(); }
 
+void Target::SaveScriptedLaunchInfo(lldb_private::ProcessInfo &process_info) {
+  if (process_info.IsScriptedProcess()) {
+    // Only copy scripted process launch options.
+    ProcessLaunchInfo &default_launch_info = const_cast<ProcessLaunchInfo &>(
+        GetGlobalProperties().GetProcessLaunchInfo());
+    default_launch_info.SetProcessPluginName("ScriptedProcess");
+    default_launch_info.SetScriptedMetadata(process_info.GetScriptedMetadata());
+    SetProcessLaunchInfo(default_launch_info);
+  }
+}
+
 Status Target::Launch(ProcessLaunchInfo &launch_info, Stream *stream) {
   m_stats.SetLaunchOrAttachTime();
   Status error;
   Log *log = GetLog(LLDBLog::Target);
 
   LLDB_LOGF(log, "Target::%s() called for %s", __FUNCTION__,
             launch_info.GetExecutableFile().GetPath().c_str());
 
// launching.
     } else {
       LLDB_LOGF(log, "Target::%s the process instance doesn't currently exist.",
                 __FUNCTION__);
     }
   }
 
   launch_info.GetFlags().Set(eLaunchFlagDebug);
 
-  if (launch_info.IsScriptedProcess()) {
-    // Only copy scripted process launch options.
-    ProcessLaunchInfo &default_launch_info = const_cast<ProcessLaunchInfo &>(
-        GetGlobalProperties().GetProcessLaunchInfo());
-
-    default_launch_info.SetProcessPluginName("ScriptedProcess");
-    default_launch_info.SetScriptedProcessClassName(
-        launch_info.GetScriptedProcessClassName());
-    default_launch_info.SetScriptedProcessDictionarySP(
-        launch_info.GetScriptedProcessDictionarySP());
-
-    SetProcessLaunchInfo(launch_info);
-  }
+  SaveScriptedLaunchInfo(launch_info);
 
   // Get the value of synchronous execution here.  If you wait till after you
   // have started to run, then you could have hit a breakpoint, whose command
   // might switch the value, and then you'll pick up that incorrect value.
   Debugger &debugger = GetDebugger();
   const bool synchronous_execution =
       debugger.GetCommandInterpreter().GetSynchronous();
 
Status Target::Attach(ProcessAttachInfo &attach_info, Stream *stream) {
   if (!async) {
     hijack_listener_sp =
         Listener::MakeListener("lldb.Target.Attach.attach.hijack");
     attach_info.SetHijackListener(hijack_listener_sp);
   }
 
   Status error;
   if (state != eStateConnected && platform_sp != nullptr &&
-      platform_sp->CanDebugProcess()) {
+      platform_sp->CanDebugProcess() && !attach_info.IsScriptedProcess()) {
     SetPlatform(platform_sp);
     process_sp = platform_sp->Attach(attach_info, GetDebugger(), this, error);
   } else {
     if (state != eStateConnected) {
+      SaveScriptedLaunchInfo(attach_info);
       const char *plugin_name = attach_info.GetProcessPluginName();
       process_sp =
           CreateProcess(attach_info.GetListenerForProcess(GetDebugger()),
                         plugin_name, nullptr, false);
       if (process_sp == nullptr) {
         error.SetErrorStringWithFormat(
             "failed to create process using plugin %s",
             (plugin_name) ? plugin_name : "null");

lldb/source/Utility/ProcessInfo.cpp

 //===-- ProcessInfo.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/Utility/ProcessInfo.h"
 
+#include "lldb/Interpreter/ScriptedMetadata.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/UserIDResolver.h"
 #include "llvm/ADT/SmallString.h"
 
 #include <climits>
 #include <optional>

 void ProcessInfo::Clear() {
   m_executable.Clear();
   m_arguments.Clear();
   m_environment.clear();
   m_uid = UINT32_MAX;
   m_gid = UINT32_MAX;
   m_arch.Clear();
   m_pid = LLDB_INVALID_PROCESS_ID;
+  m_scripted_metadata_sp.reset();
 }
 
 const char *ProcessInfo::GetName() const {
   return m_executable.GetFilename().GetCString();
 }
 
 llvm::StringRef ProcessInfo::GetNameAsStringRef() const {
   return m_executable.GetFilename().GetStringRef();
if (first_arg) {
       // Yes the first argument is an executable, set it as the executable in
       // the launch options. Don't resolve the file path as the path could be a
       // remote platform path
       m_executable.SetFile(first_arg, FileSpec::Style::native);
     }
   }
 }
 
+bool ProcessInfo::IsScriptedProcess() const {
+  return m_scripted_metadata_sp && *m_scripted_metadata_sp;
+}
+
 void ProcessInstanceInfo::Dump(Stream &s, UserIDResolver &resolver) const {
   if (m_pid != LLDB_INVALID_PROCESS_ID)
     s.Printf("    pid = %" PRIu64 "\n", m_pid);
 
   if (m_parent_pid != LLDB_INVALID_PROCESS_ID)
     s.Printf(" parent = %" PRIu64 "\n", m_parent_pid);
 
   if (m_executable) {

lldb/test/API/functionalities/scripted_process/TestScriptedProcess.py

def test_scripted_process_and_scripted_thread(self):
         addr = 0x500000000
         message = "Hello, target 0"
         buff = process_0.ReadCStringFromMemory(addr, len(message) + 1, error)
         self.assertSuccess(error)
         self.assertEqual(buff, message)
 
         target_1 = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.assertTrue(target_1, VALID_TARGET)
+
+        # We still need to specify a PID when attaching even for scripted processes
+        attach_info = lldb.SBAttachInfo(42)
+        attach_info.SetProcessPluginName("ScriptedProcess")
+        attach_info.SetScriptedProcessClassName("dummy_scripted_process.DummyScriptedProcess")
+
         error = lldb.SBError()
-        process_1 = target_1.Launch(launch_info, error)
+        process_1 = target_1.Attach(attach_info, error)
         self.assertTrue(process_1 and process_1.IsValid(), PROCESS_IS_VALID)
         self.assertEqual(process_1.GetProcessID(), 42)
         self.assertEqual(process_1.GetNumThreads(), 1)
 
         # ... then try reading from target #1 process ...
         addr = 0x500000000
         message = "Hello, target 1"
         buff = process_1.ReadCStringFromMemory(addr, len(message) + 1, error)

lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp

int lldb_private::LLDBSwigPython_GetIndexOfChildWithName(
     PyObject *implementor, const char *child_name) {
   return 0;
 }
 
 void *lldb_private::LLDBSWIGPython_CastPyObjectToSBData(PyObject *data) {
   return nullptr;
 }
 
+void *lldb_private::LLDBSWIGPython_CastPyObjectToSBAttachInfo(PyObject *data) {
+  return nullptr;
+}
+
+void *lldb_private::LLDBSWIGPython_CastPyObjectToSBLaunchInfo(PyObject *data) {
+  return nullptr;
+}
+
 void *lldb_private::LLDBSWIGPython_CastPyObjectToSBError(PyObject *data) {
   return nullptr;
 }
 
 void *lldb_private::LLDBSWIGPython_CastPyObjectToSBValue(PyObject *data) {
   return nullptr;
 }
 
bool lldb_private::LLDBSwigPythonStopHookCallHandleStop(
     void *implementor, lldb::ExecutionContextRefSP exc_ctx_sp,
     lldb::StreamSP stream) {
   return false;
 }
 
 python::PythonObject lldb_private::python::ToSWIGWrapper(const Status &status) {
   return python::PythonObject();
 }
+
+python::PythonObject
+lldb_private::python::ToSWIGWrapper(lldb::ProcessAttachInfoSP) {
+  return python::PythonObject();
+}
+
+python::PythonObject
+lldb_private::python::ToSWIGWrapper(lldb::ProcessLaunchInfoSP) {
+  return python::PythonObject();
+}