[lldb] Add Debugger & ScriptedMetadata reference to Platform::CreateInstance

[mib]

Summary

This patch is preparatory work for Scripted Platform support and does
multiple things:

First, it introduces new options for the platform select command and
SBPlatform::Create API, to hold a reference to the debugger object,
the name of the python script managing the Scripted Platform and a
structured data dictionary that the user can use to pass arbitrary data.

Then, it updates the various Create and GetOrCreate methods for
the Platform and PlatformList classes to pass down the new parameter
to the Platform::CreateInstance callbacks.

Finally, it updates every callback to reflect these changes.

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

[mib]

Update ScriptedMetadata header location

[bulbazord]

The idea of the patch seems fine to me. One thing that I thought about is creating a PlatformSpec struct that can contain all the needed configuration for CreateInstance/GetOrCreate. What do you think of this?

lldb/source/API/SBDebugger.cpp

1501–1503

You could add a small comment indicating what parameter the nullptr is standing in for.

lldb/source/API/SBPlatform.cpp

298–322

Here too

lldb/source/Interpreter/OptionGroupPlatform.cpp

13

Is it OptionGroupPythonClassWithDict.h you want to include here? It looks more like you'd want to include ScriptedMetadata.h

lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

514

Add a small comment here for nullptr as well.

lldb/source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

973

Here too.

lldb/source/Target/Platform.cpp

167–200

Yipee! :)

2043–2046

Here too

2083–2084

Here too.

lldb/source/Target/Process.cpp

2934–2935

Here too.

lldb/source/Target/Target.cpp

1506–1509

Here

lldb/source/Target/TargetList.cpp

187–189

Here

222–225

Here

235

H

268

H

[jingham]

You need documentation for what the name & scripted metadata do here somewhere. In SBPlatform.i so that it goes into the SB API docs is one good place. Also maybe in the Platform.h where it gets passed to Create or something.

Other than that, LGTM...

lldb/source/API/SBPlatform.cpp

305

Do you need to check script_name != nullptr here as well as checking the dict?

[mib]

Addressed @jingham @bulbazord comments:

• Add docstring to swig interface
• Add comment on nullptr arguments

@bulbazord Having a PlatformSpec object is a good idea but I don't think it's necessary quite yet since there are only 2 arguments passed to the Platform::CreateInstance

[bulbazord]

LGTM

[labath]

lldb/include/lldb/Interpreter/OptionGroupPlatform.h

73

These nested groups are fairly unusual? Couldn't CommandObjectPlatformSelect just have two OptionGroup members?

[labath]

lldb/include/lldb/Interpreter/OptionGroupPlatform.h

73

I see that this is referenced in OptionGroupPlatform::CreatePlatformWithOptions. Maybe that could be fixed by moving that functions somewhere else (making it a free function) and having it take the two groups as arguments? Creating a platforms seems like too high-level of a task for an option group anyway...

[mib]

lldb/include/lldb/Interpreter/OptionGroupPlatform.h

73

This special option group is used by many other scripted objects (Scripted Process, Breakpoint Callbacks, Stop Hooks, ...) since their basically an affordance to take a script name and a dictionary from the command line. I think it totally makes sense to use it here.

[mib]

Update unittests

[JDevlieghere]

This seems very intrusive: I don't think every plugin should have to be aware of this metadata that only one plugin needs. Is there a way to avoid this? For example, could we initialize a generic scripted platform first, with no backing Python class, and then have that set after the fact? My concern here is how the scripted process/platform is slowly creeping into all the generic code. Maybe that will require bigger design changes or maybe it's entirely unavoidable to achieve what we need, but I'd like to make sure we've given fair consideration to potential alternatives.

(Requesting changes so this shows up in my review queue)

[labath]

In addition to that, it breaks tests with ubsan. :)

I raised a similar concern in one of the other patches. I'm of the opinion that it's not worth pretending like the scripted processes (platforms, etc.) are plugins. I don't think that it can be achieved without some sort of a leakage, and I don't think it makes sense given that the part that's really interesting to have pluggable is being able to plug a different scripting language into the scripted process. I don't exactly have an opinion on this metadata argument, but it definitely looks sub-optimal.

Given this uncertainty, and the ubsan problem, maybe we can revert this for the time being?

lldb/unittests/Platform/PlatformTest.cpp

90

m_debugger_sp is never initialized. I guess this kinda works because the test does not actually dereference it, but UBSAN lights it up straight away.

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:
   /// This platform will be used as the default platform when launching or
   /// attaching to processes unless another platform is specified.
   static lldb::PlatformSP GetHostPlatform();
 
   static const char *GetHostPlatformName();
 
   static void SetHostPlatform(const lldb::PlatformSP &platform_sp);
 
-  static lldb::PlatformSP Create(llvm::StringRef name);
+  static lldb::PlatformSP Create(llvm::StringRef name, const Debugger *debugger,
+                                 const ScriptedMetadata *metadata);
 
   /// Augments the triple either with information from platform or the host
   /// system (if platform is null).
   static ArchSpec GetAugmentedArchSpec(Platform *platform,
                                        llvm::StringRef triple);
 
   /// Find a platform plugin for a given process.
   ///
private:
   bool GetCachedSharedModule(const ModuleSpec &module_spec,
                              lldb::ModuleSP &module_sp, bool *did_create_ptr);
 
   FileSpec GetModuleCacheRoot();
 };
 
 class PlatformList {
 public:
-  PlatformList() = default;
+  PlatformList(Debugger &debugger) : m_debugger(debugger) {}
 
   ~PlatformList() = default;
 
   void Append(const lldb::PlatformSP &platform_sp, bool set_selected) {
     std::lock_guard<std::recursive_mutex> guard(m_mutex);
     m_platforms.push_back(platform_sp);
     if (set_selected)
       m_selected_platform_sp = m_platforms.back();
if (platform_sp) {
           return;
         }
       }
       m_platforms.push_back(platform_sp);
       m_selected_platform_sp = m_platforms.back();
     }
   }
 
-  lldb::PlatformSP GetOrCreate(llvm::StringRef name);
+  lldb::PlatformSP GetOrCreate(llvm::StringRef name,
+                               const ScriptedMetadata *metadata);
   lldb::PlatformSP GetOrCreate(const ArchSpec &arch,
                                const ArchSpec &process_host_arch,
-                               ArchSpec *platform_arch_ptr, Status &error);
+                               ArchSpec *platform_arch_ptr, Status &error,
+                               const ScriptedMetadata *metadata);
   lldb::PlatformSP GetOrCreate(const ArchSpec &arch,
                                const ArchSpec &process_host_arch,
-                               ArchSpec *platform_arch_ptr);
+                               ArchSpec *platform_arch_ptr,
+                               const ScriptedMetadata *metadata);
 
   /// Get the platform for the given list of architectures.
   ///
   /// The algorithm works a follows:
   ///
   /// 1. Returns the selected platform if it matches any of the architectures.
   /// 2. Returns the host platform if it matches any of the architectures.
   /// 3. Returns the platform that matches all the architectures.
   ///
   /// If none of the above apply, this function returns a default platform. The
   /// candidates output argument differentiates between either no platforms
   /// supporting the given architecture or multiple platforms supporting the
   /// given architecture.
   lldb::PlatformSP GetOrCreate(llvm::ArrayRef<ArchSpec> archs,
                                const ArchSpec &process_host_arch,
-                               std::vector<lldb::PlatformSP> &candidates);
+                               std::vector<lldb::PlatformSP> &candidates,
+                               const ScriptedMetadata *metadata);
 
-  lldb::PlatformSP Create(llvm::StringRef name);
+  lldb::PlatformSP Create(llvm::StringRef name,
+                          const ScriptedMetadata *metadata);
 
   /// Detect a binary in memory that will determine which Platform and
   /// DynamicLoader should be used in this target/process, and update
   /// the Platform/DynamicLoader.
   /// The binary will be loaded into the Target, or will be registered with
   /// the DynamicLoader so that it will be loaded at a later stage.  Returns
   /// true to indicate that this is a platform binary and has been
   /// loaded/registered, no further action should be taken by the caller.
protected:
   typedef std::vector<lldb::PlatformSP> collection;
   mutable std::recursive_mutex m_mutex;
   collection m_platforms;
   lldb::PlatformSP m_selected_platform_sp;
 
 private:
   PlatformList(const PlatformList &) = delete;
   const PlatformList &operator=(const PlatformList &) = delete;
+  Debugger &m_debugger;
 };
 
 class OptionGroupPlatformRSync : public lldb_private::OptionGroup {
 public:
   OptionGroupPlatformRSync() = default;
 
   ~OptionGroupPlatformRSync() override = default;
 

lldb/include/lldb/lldb-private-interfaces.h

 namespace llvm {
 namespace json {
 class Object;
 class Value;
 }
 } // namespace llvm
 
 namespace lldb_private {
+class ScriptedMetadata;
 typedef lldb::ABISP (*ABICreateInstance)(lldb::ProcessSP process_sp,
                                          const ArchSpec &arch);
 typedef std::unique_ptr<Architecture> (*ArchitectureCreateInstance)(
     const ArchSpec &arch);
 typedef Disassembler *(*DisassemblerCreateInstance)(const ArchSpec &arch,
                                                     const char *flavor);
 typedef DynamicLoader *(*DynamicLoaderCreateInstance)(Process *process,
                                                       bool force);

 typedef lldb::BreakpointPreconditionSP (
     *LanguageRuntimeGetExceptionPrecondition)(lldb::LanguageType language,
                                               bool throw_bp);
 typedef lldb::StructuredDataPluginSP (*StructuredDataPluginCreateInstance)(
     Process &process);
 typedef Status (*StructuredDataFilterLaunchInfo)(ProcessLaunchInfo &launch_info,
                                                  Target *target);
 typedef SystemRuntime *(*SystemRuntimeCreateInstance)(Process *process);
-typedef lldb::PlatformSP (*PlatformCreateInstance)(bool force,
-                                                   const ArchSpec *arch);
+typedef lldb::PlatformSP (*PlatformCreateInstance)(
+    bool force, const ArchSpec *arch, const Debugger *debugger,
+    const ScriptedMetadata *metadata);
 typedef lldb::ProcessSP (*ProcessCreateInstance)(
     lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
     const FileSpec *crash_file_path, bool can_connect);
 typedef lldb::ScriptInterpreterSP (*ScriptInterpreterCreateInstance)(
     Debugger &debugger);
 typedef SymbolFile *(*SymbolFileCreateInstance)(lldb::ObjectFileSP objfile_sp);
 typedef SymbolVendor *(*SymbolVendorCreateInstance)(
     const lldb::ModuleSP &module_sp,

lldb/source/API/SBDebugger.cpp

 
 SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) {
   LLDB_INSTRUMENT_VA(this, platform_name_cstr);
 
   SBError sb_error;
   if (m_opaque_sp) {
     if (platform_name_cstr && platform_name_cstr[0]) {
       PlatformList &platforms = m_opaque_sp->GetPlatformList();
-      if (PlatformSP platform_sp = platforms.GetOrCreate(platform_name_cstr))
+      if (PlatformSP platform_sp = platforms.GetOrCreate(
+              platform_name_cstr, /*metadata = */ nullptr))
         platforms.SetSelectedPlatform(platform_sp);
       else
         sb_error.ref().SetErrorString("platform not found");
     } else {
       sb_error.ref().SetErrorString("invalid platform name");
     }
   } else {
     sb_error.ref().SetErrorString("invalid debugger");
   }

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::SBPlatform() { LLDB_INSTRUMENT_VA(this); }
 
 SBPlatform::SBPlatform(const char *platform_name) {
   LLDB_INSTRUMENT_VA(this, platform_name);
 
-  m_opaque_sp = Platform::Create(platform_name);
+  m_opaque_sp = Platform::Create(platform_name, /*debugger = */ nullptr,
+                                 /*metadata = */ nullptr);
+}
+
+SBPlatform::SBPlatform(const char *platform_name, const SBDebugger &debugger,
+                       const char *script_name, const SBStructuredData &dict) {
+  LLDB_INSTRUMENT_VA(this, platform_name, debugger, script_name, dict);
+
+  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 metadata(script_name, dict_sp);
+
+  m_opaque_sp =
+      Platform::Create(platform_name, debugger.m_opaque_sp.get(), &metadata);
 }
 
 SBPlatform::SBPlatform(const SBPlatform &rhs) {
   LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_sp = rhs.m_opaque_sp;
 }
 

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) {
 
-          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();
-  }
 
-  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/Core/Debugger.cpp

 Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton)
     : UserID(g_unique_id++),
       Properties(std::make_shared<OptionValueProperties>()),
       m_input_file_sp(std::make_shared<NativeFile>(stdin, false)),
       m_output_stream_sp(std::make_shared<StreamFile>(stdout, false)),
       m_error_stream_sp(std::make_shared<StreamFile>(stderr, false)),
       m_input_recorder(nullptr),
       m_broadcaster_manager_sp(BroadcasterManager::MakeBroadcasterManager()),
-      m_terminal_state(), m_target_list(*this), m_platform_list(),
+      m_terminal_state(), m_target_list(*this), m_platform_list(*this),
       m_listener_sp(Listener::MakeListener("lldb.Debugger")),
       m_source_manager_up(), m_source_file_cache(),
       m_command_interpreter_up(
           std::make_unique<CommandInterpreter>(*this, false)),
       m_io_handler_stack(), m_instance_name(), m_loaded_plugins(),
       m_event_handler_thread(), m_io_handler_thread(),
       m_sync_broadcaster(nullptr, "lldb.debugger.sync"),
       m_broadcaster(m_broadcaster_manager_sp,

lldb/source/Interpreter/OptionGroupPlatform.cpp

 //===-- OptionGroupPlatform.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/Interpreter/OptionGroupPlatform.h"
 
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Interpreter/ScriptedMetadata.h"
 #include "lldb/Target/Platform.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 PlatformSP OptionGroupPlatform::CreatePlatformWithOptions(
     CommandInterpreter &interpreter, const ArchSpec &arch, bool make_selected,
     Status &error, ArchSpec &platform_arch) const {
   PlatformList &platforms = interpreter.GetDebugger().GetPlatformList();
 
   PlatformSP platform_sp;
 
+  const ScriptedMetadata metadata(m_class_options);
+
   if (!m_platform_name.empty()) {
-    platform_sp = platforms.Create(m_platform_name);
+    platform_sp = platforms.Create(m_platform_name, &metadata);
     if (!platform_sp) {
       error.SetErrorStringWithFormatv(
           "unable to find a plug-in for the platform named \"{0}\"",
           m_platform_name);
     }
     if (platform_sp) {
       if (platform_arch.IsValid() &&
           !platform_sp->IsCompatibleArchitecture(
               arch, {}, ArchSpec::CompatibleMatch, &platform_arch)) {
         error.SetErrorStringWithFormatv("platform '{0}' doesn't support '{1}'",
                                         platform_sp->GetPluginName(),
                                         arch.GetTriple().getTriple());
         platform_sp.reset();
         return platform_sp;
       }
     }
   } else if (arch.IsValid()) {
-    platform_sp = platforms.GetOrCreate(arch, {}, &platform_arch, error);
+    platform_sp =
+        platforms.GetOrCreate(arch, {}, &platform_arch, error, &metadata);
   }
 
   if (platform_sp) {
     if (make_selected)
       platforms.SetSelectedPlatform(platform_sp);
     if (!m_os_version.empty())
       platform_sp->SetOSVersion(m_os_version);
 

lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

DynamicLoaderDarwinKernel::DynamicLoaderDarwinKernel(Process *process,
     : DynamicLoader(process), m_kernel_load_address(kernel_addr), m_kernel(),
       m_kext_summary_header_ptr_addr(), m_kext_summary_header_addr(),
       m_kext_summary_header(), m_known_kexts(), m_mutex(),
       m_break_id(LLDB_INVALID_BREAK_ID) {
   Status error;
   process->SetCanRunCode(false);
   PlatformSP platform_sp =
       process->GetTarget().GetDebugger().GetPlatformList().Create(
-          PlatformDarwinKernel::GetPluginNameStatic());
+          PlatformDarwinKernel::GetPluginNameStatic(), /*metadata = */ nullptr);
   if (platform_sp.get())
     process->GetTarget().SetPlatform(platform_sp);
 }
 
 // Destructor
 DynamicLoaderDarwinKernel::~DynamicLoaderDarwinKernel() { Clear(true); }
 
 void DynamicLoaderDarwinKernel::UpdateIfNeeded() {

lldb/source/Plugins/Platform/Android/PlatformAndroid.h

 public:
   PlatformAndroid(bool is_host);
 
   static void Initialize();
 
   static void Terminate();
 
   // lldb_private::PluginInterface functions
-  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
+  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                         const Debugger *debugger,
+                                         const ScriptedMetadata *metadata);
 
   static llvm::StringRef GetPluginNameStatic(bool is_host) {
     return is_host ? Platform::GetHostPlatformName() : "remote-android";
   }
 
   static llvm::StringRef GetPluginDescriptionStatic(bool is_host);
 
   llvm::StringRef GetPluginName() override {

lldb/source/Plugins/Platform/Android/PlatformAndroid.cpp

if (g_initialize_count > 0) {
     if (--g_initialize_count == 0) {
       PluginManager::UnregisterPlugin(PlatformAndroid::CreateInstance);
     }
   }
 
   PlatformLinux::Terminate();
 }
 
-PlatformSP PlatformAndroid::CreateInstance(bool force, const ArchSpec *arch) {
+PlatformSP PlatformAndroid::CreateInstance(bool force, const ArchSpec *arch,
+                                           const Debugger *debugger,
+                                           const ScriptedMetadata *metadata) {
   Log *log = GetLog(LLDBLog::Platform);
   if (log) {
     const char *arch_name;
     if (arch && arch->GetArchitectureName())
       arch_name = arch->GetArchitectureName();
     else
       arch_name = "<null>";
 

lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.h

 public:
   PlatformFreeBSD(bool is_host);
 
   static void Initialize();
 
   static void Terminate();
 
   // lldb_private::PluginInterface functions
-  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
+  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                         const Debugger *debugger,
+                                         const ScriptedMetadata *metadata);
 
   static llvm::StringRef GetPluginNameStatic(bool is_host) {
     return is_host ? Platform::GetHostPlatformName() : "remote-freebsd";
   }
 
   static llvm::StringRef GetPluginDescriptionStatic(bool is_host);
 
   llvm::StringRef GetPluginName() override {

lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::platform_freebsd;
 
 LLDB_PLUGIN_DEFINE(PlatformFreeBSD)
 
 static uint32_t g_initialize_count = 0;
 
-
-PlatformSP PlatformFreeBSD::CreateInstance(bool force, const ArchSpec *arch) {
+PlatformSP PlatformFreeBSD::CreateInstance(bool force, const ArchSpec *arch,
+                                           const Debugger *debugger,
+                                           const ScriptedMetadata *metadata) {
   Log *log = GetLog(LLDBLog::Platform);
   LLDB_LOG(log, "force = {0}, arch=({1}, {2})", force,
            arch ? arch->GetArchitectureName() : "<null>",
            arch ? arch->GetTriple().getTriple() : "<null>");
 
   bool create = force;
   if (!create && arch && arch->IsValid()) {
     const llvm::Triple &triple = arch->GetTriple();

lldb/source/Plugins/Platform/Linux/PlatformLinux.h

 public:
   PlatformLinux(bool is_host);
 
   static void Initialize();
 
   static void Terminate();
 
   // lldb_private::PluginInterface functions
-  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
+  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                         const Debugger *debugger,
+                                         const ScriptedMetadata *metadata);
 
   static llvm::StringRef GetPluginNameStatic(bool is_host) {
     return is_host ? Platform::GetHostPlatformName() : "remote-linux";
   }
 
   static llvm::StringRef GetPluginDescriptionStatic(bool is_host);
 
   llvm::StringRef GetPluginName() override {

lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp

 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::platform_linux;
 
 LLDB_PLUGIN_DEFINE(PlatformLinux)
 
 static uint32_t g_initialize_count = 0;
 
-
-PlatformSP PlatformLinux::CreateInstance(bool force, const ArchSpec *arch) {
+PlatformSP PlatformLinux::CreateInstance(bool force, const ArchSpec *arch,
+                                         const Debugger *debugger,
+                                         const ScriptedMetadata *metadata) {
   Log *log = GetLog(LLDBLog::Platform);
   LLDB_LOG(log, "force = {0}, arch=({1}, {2})", force,
            arch ? arch->GetArchitectureName() : "<null>",
            arch ? arch->GetTriple().getTriple() : "<null>");
 
   bool create = force;
   if (!create && arch && arch->IsValid()) {
     const llvm::Triple &triple = arch->GetTriple();

lldb/source/Plugins/Platform/MacOSX/PlatformAppleSimulator.cpp

static void Initialize() {
     PluginManager::RegisterPlugin(g_ios_plugin_name, g_ios_description,
                                   PlatformiOSSimulator::CreateInstance);
   }
 
   static void Terminate() {
     PluginManager::UnregisterPlugin(PlatformiOSSimulator::CreateInstance);
   }
 
-  static PlatformSP CreateInstance(bool force, const ArchSpec *arch) {
+  static PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                   const Debugger *debugger,
+                                   const ScriptedMetadata *metadata) {
     if (shouldSkipSimulatorPlatform(force, arch))
       return nullptr;
 
     return PlatformAppleSimulator::CreateInstance(
         "PlatformiOSSimulator", g_ios_description,
         ConstString(g_ios_plugin_name),
         {llvm::Triple::aarch64, llvm::Triple::x86_64, llvm::Triple::x86},
         llvm::Triple::IOS,
static void Initialize() {
     PluginManager::RegisterPlugin(g_tvos_plugin_name, g_tvos_description,
                                   PlatformAppleTVSimulator::CreateInstance);
   }
 
   static void Terminate() {
     PluginManager::UnregisterPlugin(PlatformAppleTVSimulator::CreateInstance);
   }
 
-  static PlatformSP CreateInstance(bool force, const ArchSpec *arch) {
+  static PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                   const Debugger *debugger,
+                                   const ScriptedMetadata *metadata) {
     if (shouldSkipSimulatorPlatform(force, arch))
       return nullptr;
     return PlatformAppleSimulator::CreateInstance(
         "PlatformAppleTVSimulator", g_tvos_description,
         ConstString(g_tvos_plugin_name),
         {llvm::Triple::aarch64, llvm::Triple::x86_64}, llvm::Triple::TvOS,
         {llvm::Triple::TvOS},
         {
PluginManager::RegisterPlugin(g_watchos_plugin_name, g_watchos_description,
                                   PlatformAppleWatchSimulator::CreateInstance);
   }
 
   static void Terminate() {
     PluginManager::UnregisterPlugin(
         PlatformAppleWatchSimulator::CreateInstance);
   }
 
-  static PlatformSP CreateInstance(bool force, const ArchSpec *arch) {
+  static PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                   const Debugger *debugger,
+                                   const ScriptedMetadata *metadata) {
     if (shouldSkipSimulatorPlatform(force, arch))
       return nullptr;
     return PlatformAppleSimulator::CreateInstance(
         "PlatformAppleWatchSimulator", g_watchos_description,
         ConstString(g_watchos_plugin_name),
         {llvm::Triple::aarch64, llvm::Triple::x86_64, llvm::Triple::x86},
         llvm::Triple::WatchOS, {llvm::Triple::WatchOS},
         {

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.h

 class Target;
 
 class PlatformDarwin : public PlatformPOSIX {
 public:
   using PlatformPOSIX::PlatformPOSIX;
 
   ~PlatformDarwin() override;
 
-  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
+  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                         const Debugger *debugger,
+                                         const ScriptedMetadata *metadata);
 
   static void DebuggerInitialize(lldb_private::Debugger &debugger);
   
   static void Initialize();
 
   static void Terminate();
 
   static llvm::StringRef GetPluginNameStatic() { return "darwin"; }

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

void PlatformDarwin::Terminate() {
 
   Platform::Terminate();
 }
 
 llvm::StringRef PlatformDarwin::GetDescriptionStatic() {
   return "Darwin platform plug-in.";
 }
 
-PlatformSP PlatformDarwin::CreateInstance(bool force, const ArchSpec *arch) {
-   // We only create subclasses of the PlatformDarwin plugin.
-   return PlatformSP();
+PlatformSP PlatformDarwin::CreateInstance(bool force, const ArchSpec *arch,
+                                          const Debugger *debugger,
+                                          const ScriptedMetadata *metadata) {
 }
 
 #define LLDB_PROPERTIES_platformdarwin
 #include "PlatformMacOSXProperties.inc"
 
 #define LLDB_PROPERTIES_platformdarwin
 enum {
 #include "PlatformMacOSXPropertiesEnum.inc"

lldb/source/Plugins/Platform/MacOSX/PlatformDarwinKernel.h

 class Process;
 class Stream;
 
 #if defined(__APPLE__) // This Plugin uses the Mac-specific
                        // source/Host/macosx/cfcpp utilities
 
 class PlatformDarwinKernel : public PlatformDarwin {
 public:
-  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
+  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                         const Debugger *debugger,
+                                         const ScriptedMetadata *metadata);
 
   static void DebuggerInitialize(Debugger &debugger);
 
   static void Initialize();
 
   static void Terminate();
 
   static llvm::StringRef GetPluginNameStatic() { return "darwin-kernel"; }

lldb/source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

if (g_initialize_count > 0) {
     if (--g_initialize_count == 0) {
       PluginManager::UnregisterPlugin(PlatformDarwinKernel::CreateInstance);
     }
   }
 
   PlatformDarwin::Terminate();
 }
 
-PlatformSP PlatformDarwinKernel::CreateInstance(bool force,
-                                                const ArchSpec *arch) {
+PlatformSP
+PlatformDarwinKernel::CreateInstance(bool force, const ArchSpec *arch,
+                                     const Debugger *debugger,
+                                     const ScriptedMetadata *metadata) {
   Log *log = GetLog(LLDBLog::Platform);
   if (log) {
     const char *arch_name;
     if (arch && arch->GetArchitectureName())
       arch_name = arch->GetArchitectureName();
     else
       arch_name = "<null>";
 
if (actual_address == LLDB_INVALID_ADDRESS)
     return false;
 
   // We have a xnu kernel binary, this is a kernel debug session.
   // Set the Target's Platform to be PlatformDarwinKernel, and the
   // Process' DynamicLoader to be DynamicLoaderDarwinKernel.
 
   PlatformSP platform_sp =
       process->GetTarget().GetDebugger().GetPlatformList().Create(
-          PlatformDarwinKernel::GetPluginNameStatic());
+          PlatformDarwinKernel::GetPluginNameStatic(), /*metadata = */ nullptr);
   if (platform_sp)
     process->GetTarget().SetPlatform(platform_sp);
 
   DynamicLoaderUP dyld_up =
       std::make_unique<DynamicLoaderDarwinKernel>(process, actual_address);
   if (!dyld_up)
     return false;
 

lldb/source/Plugins/Platform/MacOSX/PlatformMacOSX.h

 class ModuleSpec;
 class Process;
 class Target;
 
 class PlatformMacOSX : public PlatformDarwinDevice {
 public:
   PlatformMacOSX();
 
-  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
+  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                         const Debugger *debugger,
+                                         const ScriptedMetadata *metadata);
 
   static void Initialize();
 
   static void Terminate();
 
   static llvm::StringRef GetPluginNameStatic() {
     return Platform::GetHostPlatformName();
   }

lldb/source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp

#endif
   PlatformRemoteiOS::Terminate();
   PlatformDarwin::Terminate();
 }
 
 llvm::StringRef PlatformMacOSX::GetDescriptionStatic() {
   return "Local Mac OS X user platform plug-in.";
 }
 
-PlatformSP PlatformMacOSX::CreateInstance(bool force, const ArchSpec *arch) {
+PlatformSP PlatformMacOSX::CreateInstance(bool force, const ArchSpec *arch,
+                                          const Debugger *debugger,
+                                          const ScriptedMetadata *metadata) {
   // The only time we create an instance is when we are creating a remote
   // macosx platform which is handled by PlatformRemoteMacOSX.
   return PlatformSP();
 }
 
 /// Default Constructor
 PlatformMacOSX::PlatformMacOSX() : PlatformDarwinDevice(true) {}
 

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteAppleBridge.h

 
 namespace lldb_private {
 class ArchSpec;
 
 class PlatformRemoteAppleBridge : public PlatformRemoteDarwinDevice {
 public:
   PlatformRemoteAppleBridge();
 
-  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
+  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                         const Debugger *debugger,
+                                         const ScriptedMetadata *metadata);
 
   static void Initialize();
 
   static void Terminate();
 
   static llvm::StringRef GetPluginNameStatic() { return "remote-bridgeos"; }
 
   static llvm::StringRef GetDescriptionStatic();

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteAppleBridge.cpp

if (g_initialize_count > 0) {
     if (--g_initialize_count == 0) {
       PluginManager::UnregisterPlugin(PlatformRemoteAppleBridge::CreateInstance);
     }
   }
 
   PlatformDarwin::Terminate();
 }
 
-PlatformSP PlatformRemoteAppleBridge::CreateInstance(bool force,
-                                                 const ArchSpec *arch) {
+PlatformSP
+PlatformRemoteAppleBridge::CreateInstance(bool force, const ArchSpec *arch,
+                                          const Debugger *debugger,
+                                          const ScriptedMetadata *metadata) {
   Log *log = GetLog(LLDBLog::Platform);
   if (log) {
     const char *arch_name;
     if (arch && arch->GetArchitectureName())
       arch_name = arch->GetArchitectureName();
     else
       arch_name = "<null>";
 

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteAppleTV.h

 namespace lldb_private {
 class ArchSpec;
 
 class PlatformRemoteAppleTV : public PlatformRemoteDarwinDevice {
 public:
   PlatformRemoteAppleTV();
 
   // Class Functions
-  static lldb::PlatformSP CreateInstance(bool force,
-                                         const lldb_private::ArchSpec *arch);
+  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                         const Debugger *debugger,
+                                         const ScriptedMetadata *metadata);
 
   static void Initialize();
 
   static void Terminate();
 
   static llvm::StringRef GetPluginNameStatic() { return "remote-tvos"; }
 
   static llvm::StringRef GetDescriptionStatic();

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteAppleTV.cpp

if (g_initialize_count > 0) {
     if (--g_initialize_count == 0) {
       PluginManager::UnregisterPlugin(PlatformRemoteAppleTV::CreateInstance);
     }
   }
 
   PlatformDarwin::Terminate();
 }
 
-PlatformSP PlatformRemoteAppleTV::CreateInstance(bool force,
-                                                 const ArchSpec *arch) {
+PlatformSP
+PlatformRemoteAppleTV::CreateInstance(bool force, const ArchSpec *arch,
+                                      const Debugger *debugger,
+                                      const ScriptedMetadata *metadata) {
   Log *log = GetLog(LLDBLog::Platform);
   if (log) {
     const char *arch_name;
     if (arch && arch->GetArchitectureName())
       arch_name = arch->GetArchitectureName();
     else
       arch_name = "<null>";
 

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteAppleWatch.h

 
 namespace lldb_private {
 class ArchSpec;
 
 class PlatformRemoteAppleWatch : public PlatformRemoteDarwinDevice {
 public:
   PlatformRemoteAppleWatch();
 
-  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
+  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                         const Debugger *debugger,
+                                         const ScriptedMetadata *metadata);
 
   static void Initialize();
 
   static void Terminate();
 
   static llvm::StringRef GetPluginNameStatic() { return "remote-watchos"; }
 
   static llvm::StringRef GetDescriptionStatic();

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteAppleWatch.cpp

if (g_initialize_count > 0) {
     if (--g_initialize_count == 0) {
       PluginManager::UnregisterPlugin(PlatformRemoteAppleWatch::CreateInstance);
     }
   }
 
   PlatformDarwin::Terminate();
 }
 
-PlatformSP PlatformRemoteAppleWatch::CreateInstance(bool force,
-                                                    const ArchSpec *arch) {
+PlatformSP
+PlatformRemoteAppleWatch::CreateInstance(bool force, const ArchSpec *arch,
+                                         const Debugger *debugger,
+                                         const ScriptedMetadata *metadata) {
   Log *log = GetLog(LLDBLog::Platform);
   if (log) {
     const char *arch_name;
     if (arch && arch->GetArchitectureName())
       arch_name = arch->GetArchitectureName();
     else
       arch_name = "<null>";
 

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteMacOSX.h

 class ArchSpec;
 class FileSpec;
 class UUID;
 
 class PlatformRemoteMacOSX : public virtual PlatformRemoteDarwinDevice {
 public:
   PlatformRemoteMacOSX();
 
-  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
+  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                         const Debugger *debugger,
+                                         const ScriptedMetadata *metadata);
 
   static void Initialize();
 
   static void Terminate();
 
   static llvm::StringRef GetPluginNameStatic() { return "remote-macosx"; }
 
   static llvm::StringRef GetDescriptionStatic();

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteMacOSX.cpp

if (g_initialize_count > 0) {
     if (--g_initialize_count == 0) {
       PluginManager::UnregisterPlugin(PlatformRemoteMacOSX::CreateInstance);
     }
   }
 
   PlatformDarwin::Terminate();
 }
 
-PlatformSP PlatformRemoteMacOSX::CreateInstance(bool force,
-                                                const ArchSpec *arch) {
+PlatformSP
+PlatformRemoteMacOSX::CreateInstance(bool force, const ArchSpec *arch,
+                                     const Debugger *debugger,
+                                     const ScriptedMetadata *metadata) {
   Log *log = GetLog(LLDBLog::Platform);
   if (log) {
     const char *arch_name;
     if (arch && arch->GetArchitectureName())
       arch_name = arch->GetArchitectureName();
     else
       arch_name = "<null>";
 

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteiOS.h

 
 namespace lldb_private {
 class ArchSpec;
 
 class PlatformRemoteiOS : public PlatformRemoteDarwinDevice {
 public:
   PlatformRemoteiOS();
 
-  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
+  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                         const Debugger *debugger,
+                                         const ScriptedMetadata *metadata);
 
   static void Initialize();
 
   static void Terminate();
 
   static llvm::StringRef GetPluginNameStatic() { return "remote-ios"; }
 
   static llvm::StringRef GetDescriptionStatic();

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteiOS.cpp

if (g_initialize_count > 0) {
     if (--g_initialize_count == 0) {
       PluginManager::UnregisterPlugin(PlatformRemoteiOS::CreateInstance);
     }
   }
 
   PlatformDarwin::Terminate();
 }
 
-PlatformSP PlatformRemoteiOS::CreateInstance(bool force, const ArchSpec *arch) {
+PlatformSP PlatformRemoteiOS::CreateInstance(bool force, const ArchSpec *arch,
+                                             const Debugger *debugger,
+                                             const ScriptedMetadata *metadata) {
   Log *log = GetLog(LLDBLog::Platform);
   if (log) {
     const char *arch_name;
     if (arch && arch->GetArchitectureName())
       arch_name = arch->GetArchitectureName();
     else
       arch_name = "<null>";
 

lldb/source/Plugins/Platform/NetBSD/PlatformNetBSD.h

 public:
   PlatformNetBSD(bool is_host);
 
   static void Initialize();
 
   static void Terminate();
 
   // lldb_private::PluginInterface functions
-  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
+  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                         const Debugger *debugger,
+                                         const ScriptedMetadata *metadata);
 
   static llvm::StringRef GetPluginNameStatic(bool is_host) {
     return is_host ? Platform::GetHostPlatformName() : "remote-netbsd";
   }
 
   static llvm::StringRef GetPluginDescriptionStatic(bool is_host);
 
   llvm::StringRef GetPluginName() override {

lldb/source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp

 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::platform_netbsd;
 
 LLDB_PLUGIN_DEFINE(PlatformNetBSD)
 
 static uint32_t g_initialize_count = 0;
 
-
-PlatformSP PlatformNetBSD::CreateInstance(bool force, const ArchSpec *arch) {
+PlatformSP PlatformNetBSD::CreateInstance(bool force, const ArchSpec *arch,
+                                          const Debugger *debugger,
+                                          const ScriptedMetadata *metadata) {
   Log *log = GetLog(LLDBLog::Platform);
   LLDB_LOG(log, "force = {0}, arch=({1}, {2})", force,
            arch ? arch->GetArchitectureName() : "<null>",
            arch ? arch->GetTriple().getTriple() : "<null>");
 
   bool create = force;
   if (!create && arch && arch->IsValid()) {
     const llvm::Triple &triple = arch->GetTriple();

lldb/source/Plugins/Platform/OpenBSD/PlatformOpenBSD.h

 public:
   PlatformOpenBSD(bool is_host);
 
   static void Initialize();
 
   static void Terminate();
 
   // lldb_private::PluginInterface functions
-  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
+  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                         const Debugger *debugger,
+                                         const ScriptedMetadata *metadata);
 
   static llvm::StringRef GetPluginNameStatic(bool is_host) {
     return is_host ? Platform::GetHostPlatformName() : "remote-openbsd";
   }
 
   static llvm::StringRef GetPluginDescriptionStatic(bool is_host);
 
   llvm::StringRef GetPluginName() override {

lldb/source/Plugins/Platform/OpenBSD/PlatformOpenBSD.cpp

 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::platform_openbsd;
 
 LLDB_PLUGIN_DEFINE(PlatformOpenBSD)
 
 static uint32_t g_initialize_count = 0;
 
-
-PlatformSP PlatformOpenBSD::CreateInstance(bool force, const ArchSpec *arch) {
+PlatformSP PlatformOpenBSD::CreateInstance(bool force, const ArchSpec *arch,
+                                           const Debugger *debugger,
+                                           const ScriptedMetadata *metadata) {
   Log *log = GetLog(LLDBLog::Platform);
   LLDB_LOG(log, "force = {0}, arch=({1}, {2})", force,
            arch ? arch->GetArchitectureName() : "<null>",
            arch ? arch->GetTriple().getTriple() : "<null>");
 
   bool create = force;
   if (!create && arch && arch->IsValid()) {
     const llvm::Triple &triple = arch->GetTriple();

lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

Status PlatformPOSIX::ConnectRemote(Args &args) {
   if (IsHost()) {
     error.SetErrorStringWithFormatv(
         "can't connect to the host platform '{0}', always connected",
         GetPluginName());
   } else {
     if (!m_remote_platform_sp)
       m_remote_platform_sp =
           platform_gdb_server::PlatformRemoteGDBServer::CreateInstance(
-              /*force=*/true, nullptr);
+              /*force=*/true, /*arch=*/nullptr, /*debugger=*/nullptr,
+              /*metadata=*/nullptr);
 
     if (m_remote_platform_sp && error.Success())
       error = m_remote_platform_sp->ConnectRemote(args);
     else
       error.SetErrorString("failed to create a 'remote-gdb-server' platform");
 
     if (error.Fail())
       m_remote_platform_sp.reset();

lldb/source/Plugins/Platform/QemuUser/PlatformQemuUser.h

MmapArgList GetMmapArgumentList(const ArchSpec &arch, lldb::addr_t addr,
                                   lldb::addr_t length, unsigned prot,
                                   unsigned flags, lldb::addr_t fd,
                                   lldb::addr_t offset) override {
     return Platform::GetHostPlatform()->GetMmapArgumentList(
         arch, addr, length, prot, flags, fd, offset);
   }
 
 private:
-  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
+  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                         const Debugger *debugger,
+                                         const ScriptedMetadata *metadata);
   static void DebuggerInitialize(Debugger &debugger);
 
   PlatformQemuUser() : Platform(/*is_host=*/true) {}
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_QEMUUSER_PLATFORMQEMUUSER_H

lldb/source/Plugins/Platform/QemuUser/PlatformQemuUser.cpp

if (!PluginManager::GetSettingForPlatformPlugin(
           debugger, ConstString(GetPluginNameStatic()))) {
     PluginManager::CreateSettingForPlatformPlugin(
         debugger, GetGlobalProperties().GetValueProperties(),
         ConstString("Properties for the qemu-user platform plugin."),
         /*is_global_property=*/true);
   }
 }
 
-PlatformSP PlatformQemuUser::CreateInstance(bool force, const ArchSpec *arch) {
+PlatformSP PlatformQemuUser::CreateInstance(bool force, const ArchSpec *arch,
+                                            const Debugger *debugger,
+                                            const ScriptedMetadata *metadata) {
   if (force)
     return PlatformSP(new PlatformQemuUser());
   return nullptr;
 }
 
 std::vector<ArchSpec>
 PlatformQemuUser::GetSupportedArchitectures(const ArchSpec &process_host_arch) {
   llvm::Triple triple = HostInfo::GetArchitecture().GetTriple();

lldb/source/Plugins/Platform/Windows/PlatformWindows.h

 public:
   PlatformWindows(bool is_host);
 
   static void Initialize();
 
   static void Terminate();
 
   // lldb_private::PluginInterface functions
-  static lldb::PlatformSP CreateInstance(bool force,
-                                         const lldb_private::ArchSpec *arch);
+  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                         const Debugger *debugger,
+                                         const ScriptedMetadata *metadata);
 
   static llvm::StringRef GetPluginNameStatic(bool is_host) {
     return is_host ? Platform::GetHostPlatformName() : "remote-windows";
   }
 
   static llvm::StringRef GetPluginDescriptionStatic(bool is_host);
 
   llvm::StringRef GetPluginName() override {

lldb/source/Plugins/Platform/Windows/PlatformWindows.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 LLDB_PLUGIN_DEFINE(PlatformWindows)
 
 static uint32_t g_initialize_count = 0;
 
-PlatformSP PlatformWindows::CreateInstance(bool force,
-                                           const lldb_private::ArchSpec *arch) {
+PlatformSP PlatformWindows::CreateInstance(bool force, const ArchSpec *arch,
+                                           const Debugger *debugger,
+                                           const ScriptedMetadata *metadata) {
   // The only time we create an instance is when we are creating a remote
   // windows platform
   const bool is_host = false;
 
   bool create = force;
   if (!create && arch && arch->IsValid()) {
     const llvm::Triple &triple = arch->GetTriple();
     switch (triple.getVendor()) {

 
 Status PlatformWindows::ConnectRemote(Args &args) {
   Status error;
   if (IsHost()) {
     error.SetErrorStringWithFormatv(
         "can't connect to the host platform '{0}', always connected",
         GetPluginName());
   } else {
-    if (!m_remote_platform_sp)
+    if (!m_remote_platform_sp) {
       m_remote_platform_sp =
           platform_gdb_server::PlatformRemoteGDBServer::CreateInstance(
-              /*force=*/true, nullptr);
+              /*force=*/true, /*arch=*/nullptr, /*debugger=*/nullptr,
+              /*metadata=*/nullptr);
+    }
 
     if (m_remote_platform_sp) {
       if (error.Success()) {
         if (m_remote_platform_sp) {
           error = m_remote_platform_sp->ConnectRemote(args);
         } else {
           error.SetErrorString(
               "\"platform connect\" takes a single argument: <connect-url>");

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h

 namespace platform_gdb_server {
 
 class PlatformRemoteGDBServer : public Platform, private UserIDResolver {
 public:
   static void Initialize();
 
   static void Terminate();
 
-  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
+  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                         const Debugger *debugger,
+                                         const ScriptedMetadata *metadata);
 
   static llvm::StringRef GetPluginNameStatic() { return "remote-gdb-server"; }
 
   static llvm::StringRef GetDescriptionStatic();
 
   PlatformRemoteGDBServer();
 
   ~PlatformRemoteGDBServer() override;

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

void PlatformRemoteGDBServer::Terminate() {
   if (g_initialized) {
     g_initialized = false;
     PluginManager::UnregisterPlugin(PlatformRemoteGDBServer::CreateInstance);
   }
 
   Platform::Terminate();
 }
 
-PlatformSP PlatformRemoteGDBServer::CreateInstance(bool force,
-                                                   const ArchSpec *arch) {
+PlatformSP
+PlatformRemoteGDBServer::CreateInstance(bool force, const ArchSpec *arch,
+                                        const Debugger *debugger,
+                                        const ScriptedMetadata *metadata) {
   bool create = force;
   if (!create) {
     create = !arch->TripleVendorWasSpecified() && !arch->TripleOSWasSpecified();
   }
   if (create)
     return PlatformSP(new PlatformRemoteGDBServer());
   return PlatformSP();
 }

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);
if (ObjectFile::GetModuleSpecifications(module_file_spec, 0, 0,
                                           module_specs) == 0)
     return false;
 
   ModuleSpec matched_module_spec;
   return module_specs.FindMatchingModuleSpec(ModuleSpec(module_file_spec, arch),
                                              module_spec);
 }
 
-PlatformSP Platform::Create(llvm::StringRef name) {
+PlatformSP Platform::Create(llvm::StringRef name, const Debugger *debugger,
+                            const ScriptedMetadata *metadata) {
   lldb::PlatformSP platform_sp;
   if (name == GetHostPlatformName())
     return GetHostPlatform();
 
   if (PlatformCreateInstance create_callback =
           PluginManager::GetPlatformCreateCallbackForPluginName(name))
-    return create_callback(true, nullptr);
+    return create_callback(true, nullptr, debugger, metadata);
   return nullptr;
 }
 
 ArchSpec Platform::GetAugmentedArchSpec(Platform *platform, llvm::StringRef triple) {
   if (platform)
     return platform->GetAugmentedArchSpec(triple);
   return HostInfo::GetAugmentedArchSpec(triple);
 }

 CompilerType Platform::GetSiginfoType(const llvm::Triple& triple) {
   return CompilerType();
 }
 
 Args Platform::GetExtraStartupCommands() {
   return {};
 }
 
-PlatformSP PlatformList::GetOrCreate(llvm::StringRef name) {
+PlatformSP PlatformList::GetOrCreate(llvm::StringRef name,
+                                     const ScriptedMetadata *metadata) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   for (const PlatformSP &platform_sp : m_platforms) {
     if (platform_sp->GetName() == name)
       return platform_sp;
   }
-  return Create(name);
+  return Create(name, metadata);
 }
 
 PlatformSP PlatformList::GetOrCreate(const ArchSpec &arch,
                                      const ArchSpec &process_host_arch,
-                                     ArchSpec *platform_arch_ptr,
-                                     Status &error) {
+                                     ArchSpec *platform_arch_ptr, Status &error,
+                                     const ScriptedMetadata *metadata) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   // First try exact arch matches across all platforms already created
   for (const auto &platform_sp : m_platforms) {
     if (platform_sp->IsCompatibleArchitecture(
             arch, process_host_arch, ArchSpec::ExactMatch, platform_arch_ptr))
       return platform_sp;
   }
 
   // Next try compatible arch matches across all platforms already created
   for (const auto &platform_sp : m_platforms) {
     if (platform_sp->IsCompatibleArchitecture(arch, process_host_arch,
                                               ArchSpec::CompatibleMatch,
                                               platform_arch_ptr))
       return platform_sp;
   }
 
   PlatformCreateInstance create_callback;
   // First try exact arch matches across all platform plug-ins
   uint32_t idx;
   for (idx = 0;
        (create_callback = PluginManager::GetPlatformCreateCallbackAtIndex(idx));
        ++idx) {
-    PlatformSP platform_sp = create_callback(false, &arch);
+    PlatformSP platform_sp =
+        create_callback(false, &arch, &m_debugger, metadata);
     if (platform_sp &&
         platform_sp->IsCompatibleArchitecture(
             arch, process_host_arch, ArchSpec::ExactMatch, platform_arch_ptr)) {
       m_platforms.push_back(platform_sp);
       return platform_sp;
     }
   }
   // Next try compatible arch matches across all platform plug-ins
   for (idx = 0;
        (create_callback = PluginManager::GetPlatformCreateCallbackAtIndex(idx));
        ++idx) {
-    PlatformSP platform_sp = create_callback(false, &arch);
+    PlatformSP platform_sp =
+        create_callback(false, &arch, &m_debugger, metadata);
     if (platform_sp && platform_sp->IsCompatibleArchitecture(
                            arch, process_host_arch, ArchSpec::CompatibleMatch,
                            platform_arch_ptr)) {
       m_platforms.push_back(platform_sp);
       return platform_sp;
     }
   }
   if (platform_arch_ptr)
     platform_arch_ptr->Clear();
   return nullptr;
 }
 
 PlatformSP PlatformList::GetOrCreate(const ArchSpec &arch,
                                      const ArchSpec &process_host_arch,
-                                     ArchSpec *platform_arch_ptr) {
+                                     ArchSpec *platform_arch_ptr,
+                                     const ScriptedMetadata *metadata) {
   Status error;
   if (arch.IsValid())
-    return GetOrCreate(arch, process_host_arch, platform_arch_ptr, error);
+    return GetOrCreate(arch, process_host_arch, platform_arch_ptr, error,
+                       metadata);
   return nullptr;
 }
 
 PlatformSP PlatformList::GetOrCreate(llvm::ArrayRef<ArchSpec> archs,
                                      const ArchSpec &process_host_arch,
-                                     std::vector<PlatformSP> &candidates) {
+                                     std::vector<PlatformSP> &candidates,
+                                     const ScriptedMetadata *metadata) {
   candidates.clear();
   candidates.reserve(archs.size());
 
   if (archs.empty())
     return nullptr;
 
   PlatformSP host_platform_sp = Platform::GetHostPlatform();
 
for (const ArchSpec &arch : archs) {
       if (host_platform_sp->IsCompatibleArchitecture(
               arch, process_host_arch, ArchSpec::CompatibleMatch, nullptr))
         return host_platform_sp;
     }
   }
 
   // Collect a list of candidate platforms for the architectures.
   for (const ArchSpec &arch : archs) {
-    if (PlatformSP platform = GetOrCreate(arch, process_host_arch, nullptr))
+    if (PlatformSP platform = GetOrCreate(arch, process_host_arch,
+                                          /*platform_arch_ptr = */ nullptr,
+                                          /*metadata = */ nullptr))
       candidates.push_back(platform);
   }
 
   // The selected or host platform didn't match any of the architectures. If
   // the same platform supports all architectures then that's the obvious next
   // best thing.
   if (candidates.size() == archs.size()) {
     if (llvm::all_of(candidates, [&](const PlatformSP &p) -> bool {
           return p->GetName() == candidates.front()->GetName();
         })) {
       return candidates.front();
     }
   }
 
   // At this point we either have no platforms that match the given
   // architectures or multiple platforms with no good way to disambiguate
   // between them.
   return nullptr;
 }
 
-PlatformSP PlatformList::Create(llvm::StringRef name) {
+PlatformSP PlatformList::Create(llvm::StringRef name,
+                                const ScriptedMetadata *metadata) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  PlatformSP platform_sp = Platform::Create(name);
+  PlatformSP platform_sp = Platform::Create(name, &m_debugger, metadata);
   m_platforms.push_back(platform_sp);
   return platform_sp;
 }
 
 bool PlatformList::LoadPlatformBinaryAndSetup(Process *process,
                                               lldb::addr_t addr, bool notify) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
   PlatformCreateInstance create_callback;
   for (int idx = 0;
        (create_callback = PluginManager::GetPlatformCreateCallbackAtIndex(idx));
        ++idx) {
     ArchSpec arch;
-    PlatformSP platform_sp = create_callback(true, &arch);
+    PlatformSP platform_sp =
+        create_callback(true, &arch, &m_debugger, /*metadata = */ nullptr);
     if (platform_sp) {
       if (platform_sp->LoadPlatformBinaryAndSetup(process, addr, notify))
         return true;
     }
   }
   return false;
 }

lldb/source/Target/Process.cpp

void Process::CompleteAttach() {
   ArchSpec process_host_arch = GetSystemArchitecture();
   if (platform_sp) {
     const ArchSpec &target_arch = GetTarget().GetArchitecture();
     if (target_arch.IsValid() && !platform_sp->IsCompatibleArchitecture(
                                      target_arch, process_host_arch,
                                      ArchSpec::CompatibleMatch, nullptr)) {
       ArchSpec platform_arch;
       platform_sp = GetTarget().GetDebugger().GetPlatformList().GetOrCreate(
-          target_arch, process_host_arch, &platform_arch);
+          target_arch, process_host_arch, &platform_arch,
+          /*metadata = */ nullptr);
       if (platform_sp) {
         GetTarget().SetPlatform(platform_sp);
         GetTarget().SetArchitecture(platform_arch);
         LLDB_LOG(log,
                  "switching platform to {0} and architecture to {1} based on "
                  "info from attach",
                  platform_sp->GetName(), platform_arch.GetTriple().getTriple());
       }

lldb/source/Target/Target.cpp

bool Target::SetArchitecture(const ArchSpec &arch_spec, bool set_platform,
   // otherwise assume the user will set the platform manually.
   if (set_platform) {
     if (other.IsValid()) {
       auto platform_sp = GetPlatform();
       if (!platform_sp || !platform_sp->IsCompatibleArchitecture(
                               other, {}, ArchSpec::CompatibleMatch, nullptr)) {
         ArchSpec platform_arch;
         if (PlatformSP arch_platform_sp =
-                GetDebugger().GetPlatformList().GetOrCreate(other, {},
-                                                            &platform_arch)) {
+                GetDebugger().GetPlatformList().GetOrCreate(
+                    other, /*process_host_arch = */ {}, &platform_arch,
+                    /*metadata = */ nullptr)) {
           SetPlatform(arch_platform_sp);
           if (platform_arch.IsValid())
             other = platform_arch;
         }
       }
     }
   }
 
   if (!missing_local_arch) {

lldb/source/Target/TargetList.cpp

if (num_specs > 0) {
             update_platform_arch(matching_module_spec.GetArchitecture());
       } else {
         // Fat binary. No architecture specified, check if there is
         // only one platform for all of the architectures.
         std::vector<PlatformSP> candidates;
         std::vector<ArchSpec> archs;
         for (const ModuleSpec &spec : module_specs.ModuleSpecs())
           archs.push_back(spec.GetArchitecture());
-        if (PlatformSP platform_for_archs_sp =
-                platform_list.GetOrCreate(archs, {}, candidates)) {
+        if (PlatformSP platform_for_archs_sp = platform_list.GetOrCreate(
+                archs, /*process_host_arch = */ {}, candidates,
+                /*metadata = */ nullptr)) {
           platform_sp = platform_for_archs_sp;
         } else if (candidates.empty()) {
           error.SetErrorString("no matching platforms found for this file");
           return error;
         } else {
           // More than one platform claims to support this file.
           StreamString error_strm;
           std::set<llvm::StringRef> platform_set;
if (!user_exe_path.empty()) {
     }
   }
 
   // If we have a valid architecture, make sure the current platform is
   // compatible with that architecture.
   if (!prefer_platform_arch && arch.IsValid()) {
     if (!platform_sp->IsCompatibleArchitecture(
             arch, {}, ArchSpec::CompatibleMatch, nullptr)) {
-      platform_sp = platform_list.GetOrCreate(arch, {}, &platform_arch);
+      platform_sp =
+          platform_list.GetOrCreate(arch, /*process_host_arch = */ {},
+                                    &platform_arch, /*metadata = */ nullptr);
       if (platform_sp)
         platform_list.SetSelectedPlatform(platform_sp);
     }
   } else if (platform_arch.IsValid()) {
     // If "arch" isn't valid, yet "platform_arch" is, it means we have an
     // executable file with a single architecture which should be used.
     ArchSpec fixed_platform_arch;
     if (!platform_sp->IsCompatibleArchitecture(
             platform_arch, {}, ArchSpec::CompatibleMatch, nullptr)) {
-      platform_sp =
-          platform_list.GetOrCreate(platform_arch, {}, &fixed_platform_arch);
+      platform_sp = platform_list.GetOrCreate(
+          platform_arch, /*process_host_arch = */ {}, &fixed_platform_arch,
+          /*metadata = */ nullptr);
       if (platform_sp)
         platform_list.SetSelectedPlatform(platform_sp);
     }
   }
 
   if (!platform_arch.IsValid())
     platform_arch = arch;
 
Status TargetList::CreateTargetInternal(Debugger &debugger,
   Status error;
   const bool is_dummy_target = false;
 
   ArchSpec arch(specified_arch);
 
   if (arch.IsValid()) {
     if (!platform_sp || !platform_sp->IsCompatibleArchitecture(
                             arch, {}, ArchSpec::CompatibleMatch, nullptr))
-      platform_sp =
-          debugger.GetPlatformList().GetOrCreate(specified_arch, {}, &arch);
+      platform_sp = debugger.GetPlatformList().GetOrCreate(
+          specified_arch, /*process_host_arch = */ {}, &arch,
+          /*metadata = */ nullptr);
   }
 
   if (!platform_sp)
     platform_sp = debugger.GetPlatformList().GetSelectedPlatform();
 
   if (!arch.IsValid())
     arch = specified_arch;
 

lldb/unittests/Core/DiagnosticEventTest.cpp

public:
   void SetUp() override {
     FileSystem::Initialize();
     HostInfo::Initialize();
     PlatformMacOSX::Initialize();
     std::call_once(debugger_initialize_flag,
                    []() { Debugger::Initialize(nullptr); });
     ArchSpec arch("x86_64-apple-macosx-");
     Platform::SetHostPlatform(
-        PlatformRemoteMacOSX::CreateInstance(true, &arch));
+        PlatformRemoteMacOSX::CreateInstance(true, &arch, /*debugger=*/nullptr,
+                                             /*metadata=*/nullptr));
   }
   void TearDown() override {
     PlatformMacOSX::Terminate();
     HostInfo::Terminate();
     FileSystem::Terminate();
   }
 };
 } // namespace

lldb/unittests/Expression/DWARFExpressionTest.cpp

size_t DoReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
         ((char *)buf)[i] = (vm_addr + i) & 0xff;
       error.Clear();
       return size;
     }
   };
 
   // Set up a mock process.
   ArchSpec arch("i386-pc-linux");
-  Platform::SetHostPlatform(
-      platform_linux::PlatformLinux::CreateInstance(true, &arch));
+  Platform::SetHostPlatform(platform_linux::PlatformLinux::CreateInstance(
+      true, &arch, /*debugger=*/nullptr,
+      /*metadata=*/nullptr));
   lldb::DebuggerSP debugger_sp = Debugger::CreateInstance();
   ASSERT_TRUE(debugger_sp);
   lldb::TargetSP target_sp;
   lldb::PlatformSP platform_sp;
   debugger_sp->GetTargetList().CreateTarget(
       *debugger_sp, "", arch, eLoadDependentsNo, platform_sp, target_sp);
   ASSERT_TRUE(target_sp);
   ASSERT_TRUE(target_sp->GetArchitecture().IsValid());
EXPECT_THAT_EXPECTED(
       Evaluate({DW_OP_lit4, DW_OP_deref, DW_OP_stack_value}, {}, {}, &exe_ctx),
       llvm::HasValue(GetScalar(32, 0x07060504, false)));
 }
 
 TEST_F(DWARFExpressionMockProcessTest, WASM_DW_OP_addr) {
   // Set up a wasm target
   ArchSpec arch("wasm32-unknown-unknown-wasm");
   lldb::PlatformSP host_platform_sp =
-      platform_linux::PlatformLinux::CreateInstance(true, &arch);
+      platform_linux::PlatformLinux::CreateInstance(true, &arch,
+                                                    /*debugger=*/nullptr,
+                                                    /*metadata=*/nullptr);
   ASSERT_TRUE(host_platform_sp);
   Platform::SetHostPlatform(host_platform_sp);
   lldb::DebuggerSP debugger_sp = Debugger::CreateInstance();
   ASSERT_TRUE(debugger_sp);
   lldb::TargetSP target_sp;
   lldb::PlatformSP platform_sp;
   debugger_sp->GetTargetList().CreateTarget(*debugger_sp, "", arch,
                                             lldb_private::eLoadDependentsNo,
auto *dwarf_cu = llvm::cast<SymbolFileDWARF>(module_sp->GetSymbolFile())
                        ->DebugInfo()
                        .GetUnitAtIndex(0);
   ASSERT_TRUE(dwarf_cu);
   dwarf_cu->ExtractDIEsIfNeeded();
 
   // Set up a wasm target
   ArchSpec arch("wasm32-unknown-unknown-wasm");
   lldb::PlatformSP host_platform_sp =
-      platform_linux::PlatformLinux::CreateInstance(true, &arch);
+      platform_linux::PlatformLinux::CreateInstance(true, &arch,
+                                                    /*debugger=*/nullptr,
+                                                    /*metadata=*/nullptr);
   ASSERT_TRUE(host_platform_sp);
   Platform::SetHostPlatform(host_platform_sp);
   lldb::DebuggerSP debugger_sp = Debugger::CreateInstance();
   ASSERT_TRUE(debugger_sp);
   lldb::TargetSP target_sp;
   lldb::PlatformSP platform_sp;
   debugger_sp->GetTargetList().CreateTarget(*debugger_sp, "", arch,
                                             lldb_private::eLoadDependentsNo,

lldb/unittests/Interpreter/TestCommandPaths.cpp

if (success) {
     ASSERT_TRUE(error.Fail());
     ASSERT_STREQ(error.AsCString(), test_str);
   }
 }
 
 TEST_F(VerifyUserMultiwordCmdPathTest, TestErrors) {
   ArchSpec arch("x86_64-apple-macosx-");
 
-  Platform::SetHostPlatform(PlatformRemoteMacOSX::CreateInstance(true, &arch));
-                            
+  Platform::SetHostPlatform(
+      PlatformRemoteMacOSX::CreateInstance(true, &arch, /*debugger=*/nullptr,
+                                           /*metadata=*/nullptr));
   DebuggerSP debugger_sp = Debugger::CreateInstance();
   ASSERT_TRUE(debugger_sp);
 
   CommandInterpreter &interp = debugger_sp->GetCommandInterpreter();
 
   Status error;
   bool success;
   bool is_leaf;

lldb/unittests/Platform/PlatformAppleSimulatorTest.cpp

 //===-- PlatformAppleSimulatorTest.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 
 #include "Plugins/Platform/MacOSX/PlatformAppleSimulator.h"
+#include "Plugins/Platform/MacOSX/PlatformMacOSX.h"
 #include "Plugins/Platform/MacOSX/PlatformRemoteAppleTV.h"
 #include "Plugins/Platform/MacOSX/PlatformRemoteAppleWatch.h"
+#include "Plugins/Platform/MacOSX/PlatformRemoteMacOSX.h"
 #include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h"
 #include "TestingSupport/SubsystemRAII.h"
+#include "lldb/Core/Debugger.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Platform.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+static std::once_flag platform_initialize_flag;
+static std::once_flag debugger_initialize_flag;
+
 class PlatformAppleSimulatorTest : public ::testing::Test {
   SubsystemRAII<FileSystem, HostInfo, PlatformAppleSimulator, PlatformRemoteiOS,
                 PlatformRemoteAppleTV, PlatformRemoteAppleWatch>
       subsystems;
+
+public:
+  void SetUp() override {
+    std::call_once(platform_initialize_flag,
+                   []() { PlatformMacOSX::Initialize(); });
+    std::call_once(debugger_initialize_flag,
+                   []() { Debugger::Initialize(nullptr); });
+    ArchSpec arch("x86_64-apple-macosx-");
+    Platform::SetHostPlatform(
+        PlatformRemoteMacOSX::CreateInstance(true, &arch, /*debugger=*/nullptr,
+                                             /*metadata=*/nullptr));
+  }
+  void TearDown() override { PlatformMacOSX::Terminate(); }
+
+protected:
+  DebuggerSP m_debugger_sp = nullptr;
 };
 
 #ifdef __APPLE__
 
 static void testSimPlatformArchHasSimEnvironment(llvm::StringRef name) {
-  auto platform_sp = Platform::Create(name);
+  auto platform_sp = Platform::Create(name, /*debugger=*/nullptr,
+                                      /*metadata=*/nullptr);
   ASSERT_TRUE(platform_sp);
   int num_arches = 0;
 
   for (auto arch : platform_sp->GetSupportedArchitectures({})) {
     EXPECT_EQ(arch.GetTriple().getEnvironment(), llvm::Triple::Simulator);
     num_arches++;
   }
 
TEST_F(PlatformAppleSimulatorTest, TestHostPlatformToSim) {
 
   const llvm::Triple::OSType sim_platforms[] = {
       llvm::Triple::IOS,
       llvm::Triple::TvOS,
       llvm::Triple::WatchOS,
   };
 
   for (auto sim : sim_platforms) {
-    PlatformList list;
+    PlatformList list(*m_debugger_sp.get());
     ArchSpec arch = platform_arch;
     arch.GetTriple().setOS(sim);
     arch.GetTriple().setEnvironment(llvm::Triple::Simulator);
 
-    auto platform_sp = list.GetOrCreate(arch, {}, nullptr);
+    auto platform_sp = list.GetOrCreate(arch, {}, /*platform_arch_ptr=*/nullptr,
+                                        /*metadata=*/nullptr);
     EXPECT_TRUE(platform_sp);
   }
 }
 
 TEST_F(PlatformAppleSimulatorTest, TestPlatformSelectionOrder) {
   static const ArchSpec platform_arch(
       HostInfo::GetArchitecture(HostInfo::eArchKindDefault));
 
   const llvm::Triple::OSType sim_platforms[] = {
       llvm::Triple::IOS,
       llvm::Triple::TvOS,
       llvm::Triple::WatchOS,
   };
 
-  PlatformList list;
-  list.GetOrCreate("remote-ios");
-  list.GetOrCreate("remote-tvos");
-  list.GetOrCreate("remote-watchos");
+  PlatformList list(*m_debugger_sp.get());
+  list.GetOrCreate("remote-ios", /*metadata=*/nullptr);
+  list.GetOrCreate("remote-tvos", /*metadata=*/nullptr);
+  list.GetOrCreate("remote-watchos", /*metadata=*/nullptr);
 
   for (auto sim : sim_platforms) {
     ArchSpec arch = platform_arch;
     arch.GetTriple().setOS(sim);
     arch.GetTriple().setEnvironment(llvm::Triple::Simulator);
 
     Status error;
-    auto platform_sp = list.GetOrCreate(arch, {}, nullptr, error);
+    auto platform_sp =
+        list.GetOrCreate(arch, {}, /*platform_arch_ptr=*/nullptr, error,
+                         /*metadata=*/nullptr);
     EXPECT_TRUE(platform_sp);
     EXPECT_TRUE(platform_sp->GetName().contains("simulator"));
   }
 }
 
 #endif

lldb/unittests/Platform/PlatformSiginfoTest.cpp

for (auto x : fields)
       ExpectField(container, x);
   }
 
   void InitializeSiginfo(const std::string &triple) {
     ArchSpec arch(triple);
 
     switch (arch.GetTriple().getOS()) {
     case llvm::Triple::FreeBSD:
-      platform_sp =
-          platform_freebsd::PlatformFreeBSD::CreateInstance(true, &arch);
+      platform_sp = platform_freebsd::PlatformFreeBSD::CreateInstance(
+          true, &arch, /*debugger=*/nullptr,
+          /*metadata=*/nullptr);
       break;
     case llvm::Triple::Linux:
-      platform_sp = platform_linux::PlatformLinux::CreateInstance(true, &arch);
+      platform_sp = platform_linux::PlatformLinux::CreateInstance(
+          true, &arch, /*debugger=*/nullptr,
+          /*metadata=*/nullptr);
       break;
     case llvm::Triple::NetBSD:
-      platform_sp =
-          platform_netbsd::PlatformNetBSD::CreateInstance(true, &arch);
+      platform_sp = platform_netbsd::PlatformNetBSD::CreateInstance(
+          true, &arch, /*debugger=*/nullptr,
+          /*metadata=*/nullptr);
       break;
     default:
       llvm_unreachable("unknown ostype in triple");
     }
     Platform::SetHostPlatform(platform_sp);
 
     debugger_sp = Debugger::CreateInstance();
     ASSERT_TRUE(debugger_sp);

lldb/unittests/Platform/PlatformTest.cpp

 //===-- PlatformTest.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 
 #include "Plugins/Platform/POSIX/PlatformPOSIX.h"
 #include "TestingSupport/SubsystemRAII.h"
+#include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Platform.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+static std::once_flag debugger_initialize_flag;
+
 class TestPlatform : public PlatformPOSIX {
 public:
   TestPlatform() : PlatformPOSIX(false) {}
 };
 
 class PlatformArm : public TestPlatform {
 public:
   PlatformArm() = default;
public:
   static void Initialize() {
     PluginManager::RegisterPlugin("thumb", "thumb",
                                   PlatformThumb::CreateInstance);
   }
   static void Terminate() {
     PluginManager::UnregisterPlugin(PlatformThumb::CreateInstance);
   }
 
-  static PlatformSP CreateInstance(bool force, const ArchSpec *arch) {
+  static PlatformSP CreateInstance(bool force, const ArchSpec *arch,
+                                   const Debugger *debugger,
+                                   const ScriptedMetadata *metadata) {
     return std::make_shared<PlatformThumb>();
   }
 
   std::vector<ArchSpec>
   GetSupportedArchitectures(const ArchSpec &process_host_arch) override {
     return {ArchSpec("thumbv7-apple-ps4"), ArchSpec("thumbv7f-apple-ps4")};
   }
 
   llvm::StringRef GetPluginName() override { return "thumb"; }
   llvm::StringRef GetDescription() override { return "thumb"; }
 };
 
 class PlatformTest : public ::testing::Test {
   SubsystemRAII<FileSystem, HostInfo> subsystems;
 
 protected:
-  PlatformList list;
+  PlatformList *list = nullptr;
+  DebuggerSP m_debugger_sp = nullptr;
+
+  void SetUp() override {
+    std::call_once(debugger_initialize_flag,
+                   []() { Debugger::Initialize(nullptr); });
+    list = new PlatformList(*m_debugger_sp.get());
+  }
+
+  void TearDown() override { delete list; }
 
   void SetHostPlatform(const PlatformSP &platform_sp) {
     Platform::SetHostPlatform(platform_sp);
     ASSERT_EQ(Platform::GetHostPlatform(), platform_sp);
-    list.Append(platform_sp, /*set_selected=*/true);
+    list->Append(platform_sp, /*set_selected=*/true);
   }
 };
 
 TEST_F(PlatformTest, GetPlatformForArchitecturesHost) {
   SetHostPlatform(std::make_shared<PlatformArm>());
 
   const std::vector<ArchSpec> archs = {ArchSpec("arm64-apple-ps4"),
                                        ArchSpec("arm64e-apple-ps4")};
   std::vector<PlatformSP> candidates;
 
   // The host platform matches all architectures.
-  PlatformSP platform_sp = list.GetOrCreate(archs, {}, candidates);
+  PlatformSP platform_sp =
+      list->GetOrCreate(archs, {}, candidates, /*metadata=*/nullptr);
   ASSERT_TRUE(platform_sp);
   EXPECT_EQ(platform_sp, Platform::GetHostPlatform());
 }
 
 TEST_F(PlatformTest, GetPlatformForArchitecturesSelected) {
   SetHostPlatform(std::make_shared<PlatformIntel>());
 
   const std::vector<ArchSpec> archs = {ArchSpec("arm64-apple-ps4"),
                                        ArchSpec("arm64e-apple-ps4")};
   std::vector<PlatformSP> candidates;
 
   // The host platform matches no architectures.
-  PlatformSP platform_sp = list.GetOrCreate(archs, {}, candidates);
+  PlatformSP platform_sp =
+      list->GetOrCreate(archs, {}, candidates, /*metadata=*/nullptr);
   ASSERT_FALSE(platform_sp);
 
   // The selected platform matches all architectures.
   const PlatformSP selected_platform_sp = std::make_shared<PlatformArm>();
-  list.Append(selected_platform_sp, /*set_selected=*/true);
-  platform_sp = list.GetOrCreate(archs, {}, candidates);
+  list->Append(selected_platform_sp, /*set_selected=*/true);
+  platform_sp = list->GetOrCreate(archs, {}, candidates, /*metadata=*/nullptr);
   ASSERT_TRUE(platform_sp);
   EXPECT_EQ(platform_sp, selected_platform_sp);
 }
 
 TEST_F(PlatformTest, GetPlatformForArchitecturesSelectedOverHost) {
   SetHostPlatform(std::make_shared<PlatformIntel>());
 
   const std::vector<ArchSpec> archs = {ArchSpec("arm64-apple-ps4"),
                                        ArchSpec("x86_64-apple-ps4")};
   std::vector<PlatformSP> candidates;
 
   // The host platform matches one architecture.
-  PlatformSP platform_sp = list.GetOrCreate(archs, {}, candidates);
+  PlatformSP platform_sp =
+      list->GetOrCreate(archs, {}, candidates, /*metadata=*/nullptr);
   ASSERT_TRUE(platform_sp);
   EXPECT_EQ(platform_sp, Platform::GetHostPlatform());
 
   // The selected and host platform each match one architecture.
   // The selected platform is preferred.
   const PlatformSP selected_platform_sp = std::make_shared<PlatformArm>();
-  list.Append(selected_platform_sp, /*set_selected=*/true);
-  platform_sp = list.GetOrCreate(archs, {}, candidates);
+  list->Append(selected_platform_sp, /*set_selected=*/true);
+  platform_sp = list->GetOrCreate(archs, {}, candidates, /*metadata=*/nullptr);
   ASSERT_TRUE(platform_sp);
   EXPECT_EQ(platform_sp, selected_platform_sp);
 }
 
 TEST_F(PlatformTest, GetPlatformForArchitecturesCandidates) {
   PlatformThumb::Initialize();
 
   SetHostPlatform(std::make_shared<PlatformIntel>());
 
   const PlatformSP selected_platform_sp = std::make_shared<PlatformArm>();
-  list.Append(selected_platform_sp, /*set_selected=*/true);
+  list->Append(selected_platform_sp, /*set_selected=*/true);
 
   const std::vector<ArchSpec> archs = {ArchSpec("thumbv7-apple-ps4"),
                                        ArchSpec("thumbv7f-apple-ps4")};
   std::vector<PlatformSP> candidates;
 
   // The host platform matches one architecture.
-  PlatformSP platform_sp = list.GetOrCreate(archs, {}, candidates);
+  PlatformSP platform_sp =
+      list->GetOrCreate(archs, {}, candidates, /*metadata=*/nullptr);
   ASSERT_TRUE(platform_sp);
   EXPECT_EQ(platform_sp->GetName(), "thumb");
 
   PlatformThumb::Terminate();
 }

lldb/unittests/Process/ProcessEventDataTest.cpp

ThreadSP CreateThread(ProcessSP &process_sp, bool should_stop,
   process_sp->GetThreadList().AddThread(thread_sp);
 
   return thread_sp;
 }
 
 TEST_F(ProcessEventDataTest, DoOnRemoval) {
   ArchSpec arch("x86_64-apple-macosx-");
 
-  Platform::SetHostPlatform(PlatformRemoteMacOSX::CreateInstance(true, &arch));
+  Platform::SetHostPlatform(
+      PlatformRemoteMacOSX::CreateInstance(true, &arch, /*debugger=*/nullptr,
+                                           /*metadata=*/nullptr));
 
   DebuggerSP debugger_sp = Debugger::CreateInstance();
   ASSERT_TRUE(debugger_sp);
 
   TargetSP target_sp = CreateTarget(debugger_sp, arch);
   ASSERT_TRUE(target_sp);
 
   ListenerSP listener_sp(Listener::MakeListener("dummy"));
TEST_F(ProcessEventDataTest, DoOnRemoval) {
   result = static_cast<DummyProcessEventData *>(event_data_sp.get())
                ->m_should_stop_hit_count == 0;
   ASSERT_TRUE(result);
 }
 
 TEST_F(ProcessEventDataTest, ShouldStop) {
   ArchSpec arch("x86_64-apple-macosx-");
 
-  Platform::SetHostPlatform(PlatformRemoteMacOSX::CreateInstance(true, &arch));
+  Platform::SetHostPlatform(
+      PlatformRemoteMacOSX::CreateInstance(true, &arch, /*debugger=*/nullptr,
+                                           /*metadata=*/nullptr));
 
   DebuggerSP debugger_sp = Debugger::CreateInstance();
   ASSERT_TRUE(debugger_sp);
 
   TargetSP target_sp = CreateTarget(debugger_sp, arch);
   ASSERT_TRUE(target_sp);
 
   ListenerSP listener_sp(Listener::MakeListener("dummy"));

lldb/unittests/Target/ExecutionContextTest.cpp

 TEST_F(ExecutionContextTest, GetByteOrder) {
   ExecutionContext exe_ctx(nullptr, nullptr, nullptr);
   EXPECT_EQ(endian::InlHostByteOrder(), exe_ctx.GetByteOrder());
 }
 
 TEST_F(ExecutionContextTest, GetByteOrderTarget) {
   ArchSpec arch("powerpc64-pc-linux");
 
-  Platform::SetHostPlatform(
-      platform_linux::PlatformLinux::CreateInstance(true, &arch));
+  Platform::SetHostPlatform(platform_linux::PlatformLinux::CreateInstance(
+      true, &arch, /*debugger=*/nullptr,
+      /*metadata=*/nullptr));
 
   DebuggerSP debugger_sp = Debugger::CreateInstance();
   ASSERT_TRUE(debugger_sp);
 
   TargetSP target_sp;
   PlatformSP platform_sp;
   Status error = debugger_sp->GetTargetList().CreateTarget(
       *debugger_sp, "", arch, eLoadDependentsNo, platform_sp, target_sp);
   ASSERT_TRUE(target_sp);
   ASSERT_TRUE(target_sp->GetArchitecture().IsValid());
   ASSERT_TRUE(platform_sp);
 
   ExecutionContext target_ctx(target_sp, false);
   EXPECT_EQ(target_sp->GetArchitecture().GetByteOrder(),
             target_ctx.GetByteOrder());
 }
 
 TEST_F(ExecutionContextTest, GetByteOrderProcess) {
   ArchSpec arch("powerpc64-pc-linux");
 
-  Platform::SetHostPlatform(
-      platform_linux::PlatformLinux::CreateInstance(true, &arch));
+  Platform::SetHostPlatform(platform_linux::PlatformLinux::CreateInstance(
+      true, &arch, /*debugger=*/nullptr,
+      /*metadata=*/nullptr));
 
   DebuggerSP debugger_sp = Debugger::CreateInstance();
   ASSERT_TRUE(debugger_sp);
 
   TargetSP target_sp;
   PlatformSP platform_sp;
   Status error = debugger_sp->GetTargetList().CreateTarget(
       *debugger_sp, "", arch, eLoadDependentsNo, platform_sp, target_sp);

lldb/unittests/Target/StackFrameRecognizerTest.cpp

 public:
   void SetUp() override {
     FileSystem::Initialize();
     HostInfo::Initialize();
 
     // Pretend Linux is the host platform.
     platform_linux::PlatformLinux::Initialize();
     ArchSpec arch("powerpc64-pc-linux");
-    Platform::SetHostPlatform(
-        platform_linux::PlatformLinux::CreateInstance(true, &arch));
+    Platform::SetHostPlatform(platform_linux::PlatformLinux::CreateInstance(
+        true, &arch, /*debugger=*/nullptr,
+        /*metadata=*/nullptr));
   }
 
   void TearDown() override {
     platform_linux::PlatformLinux::Terminate();
     HostInfo::Terminate();
     FileSystem::Terminate();
   }
 };

lldb/unittests/Thread/ThreadTest.cpp

debugger_sp->GetTargetList().CreateTarget(
       *debugger_sp, "", arch, eLoadDependentsNo, platform_sp, target_sp);
 
   return target_sp;
 }
 
 TEST_F(ThreadTest, SetStopInfo) {
   ArchSpec arch("powerpc64-pc-linux");
 
-  Platform::SetHostPlatform(
-      platform_linux::PlatformLinux::CreateInstance(true, &arch));
+  Platform::SetHostPlatform(platform_linux::PlatformLinux::CreateInstance(
+      true, &arch, /*debugger=*/nullptr,
+      /*metadata=*/nullptr));
 
   DebuggerSP debugger_sp = Debugger::CreateInstance();
   ASSERT_TRUE(debugger_sp);
 
   TargetSP target_sp = CreateTarget(debugger_sp, arch);
   ASSERT_TRUE(target_sp);
 
   ListenerSP listener_sp(Listener::MakeListener("dummy"));
TEST_F(ThreadTest, SetStopInfo) {
 
   thread_sp->SetStopInfo(stopinfo_sp);
   ASSERT_TRUE(stopinfo_sp->IsValid() == true);
 }
 
 TEST_F(ThreadTest, GetPrivateStopInfo) {
   ArchSpec arch("powerpc64-pc-linux");
 
-  Platform::SetHostPlatform(
-      platform_linux::PlatformLinux::CreateInstance(true, &arch));
+  Platform::SetHostPlatform(platform_linux::PlatformLinux::CreateInstance(
+      true, &arch, /*debugger=*/nullptr,
+      /*metadata=*/nullptr));
 
   DebuggerSP debugger_sp = Debugger::CreateInstance();
   ASSERT_TRUE(debugger_sp);
 
   TargetSP target_sp = CreateTarget(debugger_sp, arch);
   ASSERT_TRUE(target_sp);
 
   ListenerSP listener_sp(Listener::MakeListener("dummy"));