[lldb] Add PlatformMetadata for ScriptedPlatform

[mib]

Summary

This patch is a less intrusive implementation of 2d53527.

It introduces a new PlatformMetadata held by every platform that
contains various objects that might be used my a platform instance.

In its current form, the PlatformMetadata holds a reference to the
Debugger and a ScriptedMetadata pointer. These are necessary in other to
instanciate the scripted object that the ScriptedPlatform interacts with.

In order to make it less introsive with the rest of lldb's platform
creation code, platform metadata are set after the platform creation,
and requires to platform to reload them (using Platform::ReloadMetadata).

This approach has the tradeoff that the ScriptedPlaform instance is
technically invalid and useless right after its creation. However, the user
should never be in that situation, since we reload the platform metadata
everytime with create or select the platform.

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

[mib]

Friendly reminder @labath @JDevlieghere

[JDevlieghere]

Cool, I like how this sidesteps having to go through the plugin instantiation mechanism. LGTM if Pavel's happy.

lldb/include/lldb/Interpreter/OptionGroupPlatform.h

19

newline

[labath]

I wouldn't exactly use the word happy, but I also don't have the time to come up with an alternative proposal.

lldb/bindings/interface/SBPlatform.i

 class SBPlatform
 {
 public:
 
     SBPlatform ();
 
     SBPlatform (const char *);
 
+    %feature("docstring", "
+    Create a platform instance using a specific platform plugin name, debugger,
+    script name and user-provided dictionary.
+
+    :param platform_name: name of the platform plugin to use to create the platform
+    :param debugger: debugger instance owning the platform
+    :param script_name: name of the script class and module to use to create the platform
+    :param dict: user-provided dictionary that can be used when instanciating a platform
+    ")
+    SBPlatform (const char *, const SBDebugger&,
+                const char *, const SBStructuredData&);
+
     ~SBPlatform();
 
     static SBPlatform GetHostPlatform();
 
     bool
     IsValid () const;
 
     explicit operator bool() const;

lldb/include/lldb/API/SBDebugger.h

public:
   ///   An error if the trace could not be created.
   ///
   /// \param[in] trace_description_file
   ///   The file containing the necessary information to load the trace.
   SBTrace LoadTraceFromFile(SBError &error,
                             const SBFileSpec &trace_description_file);
 
 private:
+  friend class SBPlatform;
   friend class SBCommandInterpreter;
   friend class SBInputReader;
   friend class SBListener;
   friend class SBProcess;
   friend class SBSourceManager;
   friend class SBTarget;
   friend class SBTrace;
 

lldb/include/lldb/API/SBPlatform.h

 };
 
 class LLDB_API SBPlatform {
 public:
   SBPlatform();
 
   SBPlatform(const char *platform_name);
 
+  SBPlatform(const char *platform_name, const SBDebugger &debugger,
+             const char *script_name, const SBStructuredData &dict);
+
   SBPlatform(const SBPlatform &rhs);
 
   SBPlatform &operator=(const SBPlatform &rhs);
 
   ~SBPlatform();
 
   static SBPlatform GetHostPlatform();
 

lldb/include/lldb/API/SBStructuredData.h

public:
   ///     Returns the byte size needed to completely write the string value at
   ///     \a dst in all cases.
   size_t GetStringValue(char *dst, size_t dst_len) const;
 
 protected:
   friend class SBLaunchInfo;
   friend class SBDebugger;
   friend class SBTarget;
+  friend class SBPlatform;
   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/Interpreter/OptionGroupPlatform.h

 //===-- OptionGroupPlatform.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_OPTIONGROUPPLATFORM_H
 #define LLDB_INTERPRETER_OPTIONGROUPPLATFORM_H
 
+#include "lldb/Interpreter/OptionGroupPythonClassWithDict.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Utility/ConstString.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
+class CommandObjectPlatformSelect;
 // PlatformOptionGroup
 //
 // Make platform options available to any commands that need the settings.
 class OptionGroupPlatform : public OptionGroup {
 public:
   OptionGroupPlatform(bool include_platform_option)
-      : m_include_platform_option(include_platform_option) {}
+      : m_include_platform_option(include_platform_option),
+        m_class_options("scripted platform", true, 'C', 'K', 'V', 0) {}
 
   ~OptionGroupPlatform() override = default;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                         ExecutionContext *execution_context) override;
   Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
public:
 
   ConstString GetSDKBuild() const { return m_sdk_build; }
 
   void SetSDKBuild(ConstString sdk_build) { m_sdk_build = sdk_build; }
 
   bool PlatformMatches(const lldb::PlatformSP &platform_sp) const;
 
 protected:
+  friend class CommandObjectPlatformSelect;
+
   std::string m_platform_name;
   ConstString m_sdk_sysroot;
   ConstString m_sdk_build;
   llvm::VersionTuple m_os_version;
   bool m_include_platform_option;
+  OptionGroupPythonClassWithDict m_class_options;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_OPTIONGROUPPLATFORM_H

lldb/include/lldb/Target/Platform.h

 #include <optional>
 #include <string>
 #include <vector>
 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Host/File.h"
 #include "lldb/Interpreter/Options.h"
+#include "lldb/Interpreter/ScriptedMetadata.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/Timeout.h"
 #include "lldb/Utility/UserIDResolver.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-public.h"
public:
   bool SetModuleCacheDirectory(const FileSpec &dir_spec);
 
 private:
   void SetDefaultModuleCacheDirectory(const FileSpec &dir_spec);
 };
 
 typedef llvm::SmallVector<lldb::addr_t, 6> MmapArgList;
 
+class PlatformMetadata;
+
 /// \class Platform Platform.h "lldb/Target/Platform.h"
 /// A plug-in interface definition class for debug platform that
 /// includes many platform abilities such as:
 ///     \li getting platform information such as supported architectures,
 ///         supported binary file formats and more
 ///     \li launching new processes
 ///     \li attaching to existing processes
 ///     \li download/upload files
virtual lldb_private::Status RunShellCommand(
       std::string
           *command_output, // Pass nullptr if you don't want the command output
       const Timeout<std::micro> &timeout);
 
   virtual void SetLocalCacheDirectory(const char *local);
 
   virtual const char *GetLocalCacheDirectory();
 
+  void SetMetadata(std::unique_ptr<PlatformMetadata> metadata);
+
+  virtual bool ReloadMetadata() { return true; }
+
   virtual std::string GetPlatformSpecificConnectionInformation() { return ""; }
 
   virtual bool CalculateMD5(const FileSpec &file_spec, uint64_t &low,
                             uint64_t &high);
 
   virtual uint32_t GetResumeCountForLaunchInfo(ProcessLaunchInfo &launch_info) {
     return 1;
   }
protected:
   std::string m_rsync_prefix;
   bool m_supports_ssh;
   std::string m_ssh_opts;
   bool m_ignores_remote_hostname;
   std::string m_local_cache_directory;
   std::vector<ConstString> m_trap_handlers;
   bool m_calculated_trap_handlers;
   const std::unique_ptr<ModuleCache> m_module_cache;
+  std::unique_ptr<PlatformMetadata> m_metadata;
 
   /// Ask the Platform subclass to fill in the list of trap handler names
   ///
   /// For most Unix user process environments, this will be a single function
   /// name, _sigtramp.  More specialized environments may have additional
   /// handler names.  The unwinder code needs to know when a trap handler is
   /// on the stack because the unwind rules for the frame that caused the trap
   /// are different.
protected:
   collection m_platforms;
   lldb::PlatformSP m_selected_platform_sp;
 
 private:
   PlatformList(const PlatformList &) = delete;
   const PlatformList &operator=(const PlatformList &) = delete;
 };
 
+class PlatformMetadata {
+public:
+  PlatformMetadata(Debugger &debugger, const ScriptedMetadata *metadata);
+  ~PlatformMetadata() = default;
+
+  Debugger &GetDebugger() const { return m_debugger; }
+  const ScriptedMetadata *GetScriptedMetadata() const {
+    return m_scripted_metadata;
+  }
+
+protected:
+  Debugger &m_debugger;
+  const ScriptedMetadata *m_scripted_metadata;
+};
+
 class OptionGroupPlatformRSync : public lldb_private::OptionGroup {
 public:
   OptionGroupPlatformRSync() = default;
 
   ~OptionGroupPlatformRSync() override = default;
 
   lldb_private::Status
   SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,

lldb/source/API/SBPlatform.cpp

 //===-- SBPlatform.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/SBPlatform.h"
+#include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEnvironment.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBLaunchInfo.h"
 #include "lldb/API/SBPlatform.h"
+#include "lldb/API/SBStructuredData.h"
 #include "lldb/API/SBUnixSignals.h"
 #include "lldb/Host/File.h"
+#include "lldb/Interpreter/ScriptedMetadata.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Instrumentation.h"
 #include "lldb/Utility/Status.h"
 
 #include "llvm/Support/FileSystem.h"

 SBPlatform::SBPlatform() { LLDB_INSTRUMENT_VA(this); }
 
 SBPlatform::SBPlatform(const char *platform_name) {
   LLDB_INSTRUMENT_VA(this, platform_name);
 
   m_opaque_sp = Platform::Create(platform_name);
 }
 
+SBPlatform::SBPlatform(const char *platform_name, const SBDebugger &debugger,
+                       const char *script_name, const SBStructuredData &dict)
+    : SBPlatform(platform_name) {
+  LLDB_INSTRUMENT_VA(this, platform_name, debugger, script_name, dict);
+
+  if (!m_opaque_sp)
+    return;
+
+  if (!script_name || !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;
+
+  const ScriptedMetadata scripted_metadata(script_name, dict_sp);
+
+  auto metadata =
+      std::make_unique<PlatformMetadata>(debugger.ref(), &scripted_metadata);
+  m_opaque_sp->SetMetadata(std::move(metadata));
+  m_opaque_sp->ReloadMetadata();
+}
+
 SBPlatform::SBPlatform(const SBPlatform &rhs) {
   LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_sp = rhs.m_opaque_sp;
 }
 
 SBPlatform &SBPlatform::operator=(const SBPlatform &rhs) {
   LLDB_INSTRUMENT_VA(this, rhs);

lldb/source/Commands/CommandObjectPlatform.h

 //===-- CommandObjectPlatform.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_COMMANDOBJECTPLATFORM_H
 #define LLDB_SOURCE_COMMANDS_COMMANDOBJECTPLATFORM_H
 
 #include "lldb/Interpreter/CommandObjectMultiword.h"
+#include "lldb/Interpreter/OptionGroupPlatform.h"
 
 namespace lldb_private {
 
 // CommandObjectPlatform
 
 class CommandObjectPlatform : public CommandObjectMultiword {
 public:
   CommandObjectPlatform(CommandInterpreter &interpreter);
 
   ~CommandObjectPlatform() override;
 
 private:
   CommandObjectPlatform(const CommandObjectPlatform &) = delete;
   const CommandObjectPlatform &
   operator=(const CommandObjectPlatform &) = delete;
 };
 
+class CommandObjectPlatformSelect : public CommandObjectParsed {
+public:
+  CommandObjectPlatformSelect(CommandInterpreter &interpreter);
+
+  ~CommandObjectPlatformSelect() override = default;
+
+  void HandleCompletion(CompletionRequest &request) override;
+
+  Options *GetOptions() override;
+
+protected:
+  bool DoExecute(Args &args, CommandReturnObject &result) override;
+
+  OptionGroupOptions m_option_group;
+  OptionGroupPlatform m_platform_options;
+};
+
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_COMMANDS_COMMANDOBJECTPLATFORM_H

lldb/source/Commands/CommandObjectPlatform.cpp

public:
   uint32_t m_permissions;
 
 private:
   OptionPermissions(const OptionPermissions &) = delete;
   const OptionPermissions &operator=(const OptionPermissions &) = delete;
 };
 
 // "platform select <platform-name>"
-class CommandObjectPlatformSelect : public CommandObjectParsed {
-public:
-  CommandObjectPlatformSelect(CommandInterpreter &interpreter)
-      : CommandObjectParsed(interpreter, "platform select",
-                            "Create a platform if needed and select it as the "
-                            "current platform.",
-                            "platform select <platform-name>", 0),
-        m_platform_options(
-            false) // Don't include the "--platform" option by passing false
-  {
-    m_option_group.Append(&m_platform_options, LLDB_OPT_SET_ALL, 1);
-    m_option_group.Finalize();
-    CommandArgumentData platform_arg{eArgTypePlatform, eArgRepeatPlain};
-    m_arguments.push_back({platform_arg});
-  }
+CommandObjectPlatformSelect::CommandObjectPlatformSelect(
+    CommandInterpreter &interpreter)
+  m_option_group.Append(&m_platform_options.m_class_options,
+                        LLDB_OPT_SET_1 | LLDB_OPT_SET_2, LLDB_OPT_SET_ALL);
 
-  ~CommandObjectPlatformSelect() override = default;
-
-  void HandleCompletion(CompletionRequest &request) override {
-    CommandCompletions::PlatformPluginNames(GetCommandInterpreter(), request,
-                                            nullptr);
-  }
+void CommandObjectPlatformSelect::HandleCompletion(CompletionRequest &request) {
 
-  Options *GetOptions() override { return &m_option_group; }
+Options *CommandObjectPlatformSelect::GetOptions() { return &m_option_group; }
 
-protected:
-  bool DoExecute(Args &args, CommandReturnObject &result) override {
-    if (args.GetArgumentCount() == 1) {
-      const char *platform_name = args.GetArgumentAtIndex(0);
-      if (platform_name && platform_name[0]) {
-        const bool select = true;
-        m_platform_options.SetPlatformName(platform_name);
-        Status error;
-        ArchSpec platform_arch;
-        PlatformSP platform_sp(m_platform_options.CreatePlatformWithOptions(
-            m_interpreter, ArchSpec(), select, error, platform_arch));
-        if (platform_sp) {
-          GetDebugger().GetPlatformList().SetSelectedPlatform(platform_sp);
+bool CommandObjectPlatformSelect::DoExecute(Args &args,
+                                            CommandReturnObject &result) {
+        const ScriptedMetadata scripted_metadata(
+            m_platform_options.m_class_options);
 
-          platform_sp->GetStatus(result.GetOutputStream());
-          result.SetStatus(eReturnStatusSuccessFinishResult);
-        } else {
-          result.AppendError(error.AsCString());
-        }
-      } else {
-        result.AppendError("invalid platform name");
-      }
-    } else {
-      result.AppendError(
-          "platform create takes a platform name as an argument\n");
-    }
-    return result.Succeeded();
-  }
+        auto metadata = std::make_unique<PlatformMetadata>(GetDebugger(),
+                                                           &scripted_metadata);
+        platform_sp->SetMetadata(std::move(metadata));
+        if (!platform_sp->ReloadMetadata())
+          result.AppendError("platform couldn't reload metadata\n");
 
-  OptionGroupOptions m_option_group;
-  OptionGroupPlatform m_platform_options;
-};
-
 // "platform list"
 class CommandObjectPlatformList : public CommandObjectParsed {
 public:
   CommandObjectPlatformList(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "platform list",
                             "List all platforms that are available.", nullptr,
                             0) {}
 

lldb/source/Plugins/Platform/scripted/ScriptedPlatform.h

 
 #include "lldb/Interpreter/ScriptedMetadata.h"
 #include "lldb/Target/Platform.h"
 
 namespace lldb_private {
 
 class ScriptedPlatform : public Platform {
 public:
-  ScriptedPlatform(Debugger *debugger,
-                   const ScriptedMetadata *scripted_metadata, Status &error);
+  ScriptedPlatform();
 
   ~ScriptedPlatform() override;
 
-  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch,
-                                         const Debugger *debugger,
-                                         const ScriptedMetadata *metadata);
+  bool SetupScriptedObject(Status &error);
+
+  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
 
   static void Initialize();
 
   static void Terminate();
 
   static llvm::StringRef GetPluginNameStatic() { return "scripted-platform"; }
 
   static llvm::StringRef GetDescriptionStatic() {
public:
   bool GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &proc_info) override;
 
   Status LaunchProcess(ProcessLaunchInfo &launch_info) override;
 
   Status KillProcess(const lldb::pid_t pid) override;
 
   void CalculateTrapHandlerSymbolNames() override {}
 
+  bool ReloadMetadata() override;
+
 private:
   inline void CheckInterpreterAndScriptObject() const {
     assert(m_interpreter && "Invalid Script Interpreter.");
     assert(m_script_object_sp && "Invalid Script Object.");
   }
 
   ScriptedPlatform(const ScriptedPlatform &) = delete;
   const ScriptedPlatform &operator=(const ScriptedPlatform &) = delete;
 
   ScriptedPlatformInterface &GetInterface() const;
 
   llvm::Expected<ProcessInstanceInfo>
   ParseProcessInfo(StructuredData::Dictionary &dict, lldb::pid_t pid) const;
 
   static bool IsScriptLanguageSupported(lldb::ScriptLanguage language);
 
-  const ScriptedMetadata *m_scripted_metadata = nullptr;
+  ScriptedMetadata *m_scripted_metadata = nullptr;
   lldb_private::ScriptInterpreter *m_interpreter = nullptr;
   lldb_private::StructuredData::ObjectSP m_script_object_sp = nullptr;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SCRIPTED_PLATFORM_H

lldb/source/Plugins/Platform/scripted/ScriptedPlatform.cpp

bool ScriptedPlatform::IsScriptLanguageSupported(
 
   return llvm::is_contained(supported_languages, language);
 }
 
 ScriptedPlatformInterface &ScriptedPlatform::GetInterface() const {
   return m_interpreter->GetScriptedPlatformInterface();
 }
 
-lldb::PlatformSP
-ScriptedPlatform::CreateInstance(bool force, const ArchSpec *arch,
-                                 const Debugger *debugger,
-                                 const ScriptedMetadata *metadata) {
+lldb::PlatformSP ScriptedPlatform::CreateInstance(bool force,
+                                                  const ArchSpec *arch) {
   Log *log = GetLog(LLDBLog::Platform);
   if (log) {
     const char *arch_name;
     if (arch && arch->GetArchitectureName())
       arch_name = arch->GetArchitectureName();
     else
       arch_name = "<null>";
 
     const char *triple_cstr =
         arch ? arch->GetTriple().getTriple().c_str() : "<null>";
 
-    LLDB_LOGF(log,
-              "ScriptedPlatform::%s(force=%s, arch={%s,%s}, debugger=%" PRIxPTR
-              ")",
+    LLDB_LOGF(log, "ScriptedPlatform::%s(force=%s, arch={%s,%s})",
               __PRETTY_FUNCTION__, force ? "true" : "false", arch_name,
-              triple_cstr, (uintptr_t)debugger);
+              triple_cstr);
   }
 
-  if (!debugger || !IsScriptLanguageSupported(debugger->GetScriptLanguage()))
-    return {};
+  return std::make_shared<ScriptedPlatform>();
+}
 
-  if (!metadata)
-    return {};
+ScriptedPlatform::ScriptedPlatform() : Platform(false) {}
 
-  Status error;
-  std::shared_ptr<ScriptedPlatform> scripted_platform_sp =
-      std::make_shared<ScriptedPlatform>(const_cast<Debugger *>(debugger),
-                                         metadata, error);
+bool ScriptedPlatform::SetupScriptedObject(Status &error) {
 
-  if (error.Success())
-    return scripted_platform_sp;
+  auto error_with_message = [&error](llvm::StringRef message) {
+    return ScriptedInterface::ErrorWithMessage<bool>(
+        LLVM_PRETTY_FUNCTION, message, error, LLDBLog::Platform);
+  };
 
-  LLDB_LOGF(log, "ScriptedPlatform::%s() aborting creation of platform",
-            __PRETTY_FUNCTION__);
+  Debugger &debugger = m_metadata->GetDebugger();
 
-  return {};
-}
+  if (!IsScriptLanguageSupported(debugger.GetScriptLanguage()))
+    return error_with_message("Debugger language not supported");
 
-ScriptedPlatform::ScriptedPlatform(Debugger *debugger,
-                                   const ScriptedMetadata *scripted_metadata,
-                                   Status &error)
-    : Platform(false), m_scripted_metadata(scripted_metadata) {
-  if (!debugger) {
-    error.SetErrorStringWithFormat("ScriptedPlatform::%s () - ERROR: %s",
-                                   __FUNCTION__, "Invalid debugger");
-    return;
-  }
+  m_interpreter = debugger.GetScriptInterpreter();
 
-  m_interpreter = debugger->GetScriptInterpreter();
+  if (!m_interpreter)
+    return error_with_message("Debugger has no Script Interpreter");
 
-  if (!m_interpreter) {
-    error.SetErrorStringWithFormat("ScriptedPlatform::%s () - ERROR: %s",
-                                   __FUNCTION__,
-                                   "Debugger has no Script Interpreter");
-    return;
-  }
+  const ScriptedMetadata *scripted_metadata = m_metadata->GetScriptedMetadata();
 
-  ExecutionContext e;
+  if (!scripted_metadata)
+    return error_with_message("No scripted metadata");
+
+  m_scripted_metadata = const_cast<ScriptedMetadata *>(scripted_metadata);
 
+  ExecutionContext e;
   StructuredData::GenericSP object_sp = GetInterface().CreatePluginObject(
       m_scripted_metadata->GetClassName(), e, m_scripted_metadata->GetArgsSP());
 
-  if (!object_sp || !object_sp->IsValid()) {
-    error.SetErrorStringWithFormat("ScriptedPlatform::%s () - ERROR: %s",
-                                   __FUNCTION__,
-                                   "Failed to create valid script object");
-    return;
-  }
+  if (!object_sp || !object_sp->IsValid())
+    return error_with_message("Failed to create valid script object");
 
   m_hostname = GetHostPlatform()->GetHostname();
   m_script_object_sp = object_sp;
+  return true;
 }
 
 ScriptedPlatform::~ScriptedPlatform() {}
 
+bool ScriptedPlatform::ReloadMetadata() {
+  if (!m_metadata)
+    return false;
+
+  Status error;
+  return SetupScriptedObject(error);
+}
+
 void ScriptedPlatform::Initialize() {
   if (g_initialize_count++ == 0) {
     // NOTE: This should probably be using the driving process platform
     PluginManager::RegisterPlugin(ScriptedPlatform::GetPluginNameStatic(),
                                   ScriptedPlatform::GetDescriptionStatic(),
                                   ScriptedPlatform::CreateInstance);
   }
 }
if (!proc_info_or_error) {
     return false;
   }
 
   proc_info = *proc_info_or_error;
   return true;
 }
 
 Status ScriptedPlatform::LaunchProcess(ProcessLaunchInfo &launch_info) {
-  return GetInterface().LaunchProcess();
+  lldb::ProcessLaunchInfoSP launch_info_sp =
+      std::make_shared<ProcessLaunchInfo>(launch_info);
+  return GetInterface().LaunchProcess(launch_info_sp);
 }
 
 Status ScriptedPlatform::KillProcess(const lldb::pid_t pid) {
   return GetInterface().KillProcess(pid);
 }

lldb/source/Target/Platform.cpp

 }
 
 FileSpecList
 Platform::LocateExecutableScriptingResources(Target *target, Module &module,
                                              Stream *feedback_stream) {
   return FileSpecList();
 }
 
-// PlatformSP
-// Platform::FindPlugin (Process *process, ConstString plugin_name)
-//{
-//    PlatformCreateInstance create_callback = nullptr;
-//    if (plugin_name)
-//    {
-//        create_callback  =
-//        PluginManager::GetPlatformCreateCallbackForPluginName (plugin_name);
-//        if (create_callback)
-//        {
-//            ArchSpec arch;
-//            if (process)
-//            {
-//                arch = process->GetTarget().GetArchitecture();
-//            }
-//            PlatformSP platform_sp(create_callback(process, &arch));
-//            if (platform_sp)
-//                return platform_sp;
-//        }
-//    }
-//    else
-//    {
-//        for (uint32_t idx = 0; (create_callback =
-//        PluginManager::GetPlatformCreateCallbackAtIndex(idx)) != nullptr;
-//        ++idx)
-//        {
-//            PlatformSP platform_sp(create_callback(process, nullptr));
-//            if (platform_sp)
-//                return platform_sp;
-//        }
-//    }
-//    return PlatformSP();
-//}
-
 Status Platform::GetSharedModule(
     const ModuleSpec &module_spec, Process *process, ModuleSP &module_sp,
     const FileSpecList *module_search_paths_ptr,
     llvm::SmallVectorImpl<lldb::ModuleSP> *old_modules, bool *did_create_ptr) {
   if (IsHost())
     return ModuleList::GetSharedModule(module_spec, module_sp,
                                        module_search_paths_ptr, old_modules,
                                        did_create_ptr, false);

 }
 
 ArchSpec Platform::GetAugmentedArchSpec(Platform *platform, llvm::StringRef triple) {
   if (platform)
     return platform->GetAugmentedArchSpec(triple);
   return HostInfo::GetAugmentedArchSpec(triple);
 }
 
+PlatformMetadata::PlatformMetadata(Debugger &debugger,
+                                   const ScriptedMetadata *metadata)
+    : m_debugger(debugger), m_scripted_metadata(metadata) {}
+
 /// Default Constructor
 Platform::Platform(bool is_host)
     : m_is_host(is_host), m_os_version_set_while_connected(false),
       m_system_arch_set_while_connected(false), m_max_uid_name_len(0),
       m_max_gid_name_len(0), m_supports_rsync(false), m_rsync_opts(),
       m_rsync_prefix(), m_supports_ssh(false), m_ssh_opts(),
       m_ignores_remote_hostname(false), m_trap_handlers(),
       m_calculated_trap_handlers(false),
-      m_module_cache(std::make_unique<ModuleCache>()) {
+      m_module_cache(std::make_unique<ModuleCache>()), m_metadata() {
   Log *log = GetLog(LLDBLog::Object);
   LLDB_LOGF(log, "%p Platform::Platform()", static_cast<void *>(this));
 }
 
 Platform::~Platform() = default;
 
 void Platform::GetStatus(Stream &strm) {
   strm.Format("  Platform: {0}\n", GetPluginName());

 void Platform::SetLocalCacheDirectory(const char *local) {
   m_local_cache_directory.assign(local);
 }
 
 const char *Platform::GetLocalCacheDirectory() {
   return m_local_cache_directory.c_str();
 }
 
+void Platform::SetMetadata(std::unique_ptr<PlatformMetadata> metadata) {
+  m_metadata = std::move(metadata);
+}
+
 static constexpr OptionDefinition g_rsync_option_table[] = {
     {LLDB_OPT_SET_ALL, false, "rsync", 'r', OptionParser::eNoArgument, nullptr,
      {}, 0, eArgTypeNone, "Enable rsync."},
     {LLDB_OPT_SET_ALL, false, "rsync-opts", 'R',
      OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCommandName,
      "Platform-specific options required for rsync to work."},
     {LLDB_OPT_SET_ALL, false, "rsync-prefix", 'P',
      OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCommandName,