Extract common PlatformPOSIX/Windows code into a separate class

[labath]

Summary

The two classes contained a lot of duplicated code, but there wasn't a
good place to factor it to. It couldn't be the base Platform class,
since we also have platforms which are only remote (such as
PlatformGDBRemoteServer), and so it did not make sense for those to have
an m_remote_platform member.

This patch creates a new class, RemoteAwarePlatform, which can serve as
a base class for platforms which can both serve as a host, and forward
actions to a remote system. It is motivated partly by D56232 (which was
about to add a bunch of additional duplicated methods), and partly by my
own need to modify a function which happens to be implemented in both
places identically.

The patch moves the methods which are trivially identical in the two
classes into the common base class, there were one or two more methods
which could probably be merged into one, but this wasn't completely
trivial, so I did not attempt to do that now.

[jingham]

LGTM.

include/lldb/Target/RemoteAwarePlatform.h

+//===-- RemoteAwarePlatform.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_TARGET_REMOTEAWAREPLATFORM_H
+#define LLDB_TARGET_REMOTEAWAREPLATFORM_H
+
+#include "lldb/Target/Platform.h"
+
+namespace lldb_private {
+
+/// A base class for platforms which automatically want to be able to forward
+/// operations to a remote platform instance (such as PlatformRemoteGDBServer).
+class RemoteAwarePlatform : public Platform {
+public:
+  using Platform::Platform;
+
+  bool GetModuleSpec(const FileSpec &module_file_spec, const ArchSpec &arch,
+                     ModuleSpec &module_spec) override;
+  Status GetFileWithUUID(const FileSpec &platform_file, const UUID *uuid,
+                         FileSpec &local_file) override;
+
+  bool GetRemoteOSVersion() override;
+  bool GetRemoteOSBuildString(std::string &s) override;
+  bool GetRemoteOSKernelDescription(std::string &s) override;
+  ArchSpec GetRemoteSystemArchitecture() override;
+
+  const char *GetHostname() override;
+  const char *GetUserName(uint32_t uid) override;
+  const char *GetGroupName(uint32_t gid) override;
+  lldb_private::Environment GetEnvironment() override;
+
+  bool IsConnected() const override;
+
+  bool GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &proc_info) override;
+  uint32_t FindProcesses(const ProcessInstanceInfoMatch &match_info,
+                         ProcessInstanceInfoList &process_infos) override;
+  Status LaunchProcess(ProcessLaunchInfo &launch_info) override;
+
+protected:
+  lldb::PlatformSP m_remote_platform_sp;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_TARGET_REMOTEAWAREPLATFORM_H

source/Plugins/Platform/POSIX/PlatformPOSIX.h

 //===-- PlatformPOSIX.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 liblldb_PlatformPOSIX_h_
 #define liblldb_PlatformPOSIX_h_
 
 #include <map>
 #include <memory>
 
 #include "lldb/Interpreter/Options.h"
-#include "lldb/Target/Platform.h"
+#include "lldb/Target/RemoteAwarePlatform.h"
 
-class PlatformPOSIX : public lldb_private::Platform {
+class PlatformPOSIX : public lldb_private::RemoteAwarePlatform {
 public:
   PlatformPOSIX(bool is_host);
 
   ~PlatformPOSIX() override;
 
   //------------------------------------------------------------
   // lldb_private::Platform functions
   //------------------------------------------------------------
 
-  bool GetModuleSpec(const lldb_private::FileSpec &module_file_spec,
-                     const lldb_private::ArchSpec &arch,
-                     lldb_private::ModuleSpec &module_spec) override;
-
   lldb_private::OptionGroupOptions *
   GetConnectionOptions(lldb_private::CommandInterpreter &interpreter) override;
 
-  const char *GetHostname() override;
-
-  const char *GetUserName(uint32_t uid) override;
-
-  const char *GetGroupName(uint32_t gid) override;
-
   lldb_private::Status PutFile(const lldb_private::FileSpec &source,
                                const lldb_private::FileSpec &destination,
                                uint32_t uid = UINT32_MAX,
                                uint32_t gid = UINT32_MAX) override;
 
   lldb::user_id_t OpenFile(const lldb_private::FileSpec &file_spec,
                            uint32_t flags, uint32_t mode,
                            lldb_private::Status &error) override;
public:
   GetFile(const lldb_private::FileSpec &source,
           const lldb_private::FileSpec &destination) override;
 
   lldb_private::FileSpec GetRemoteWorkingDirectory() override;
 
   bool
   SetRemoteWorkingDirectory(const lldb_private::FileSpec &working_dir) override;
 
-  bool GetRemoteOSVersion() override;
-
-  bool GetRemoteOSBuildString(std::string &s) override;
-
-  bool GetRemoteOSKernelDescription(std::string &s) override;
-
-  lldb_private::ArchSpec GetRemoteSystemArchitecture() override;
-
   const lldb::UnixSignalsSP &GetRemoteUnixSignals() override;
 
-  lldb_private::Environment GetEnvironment() override;
-
-  bool IsConnected() const override;
-
   lldb_private::Status RunShellCommand(
       const char *command,                       // Shouldn't be nullptr
       const lldb_private::FileSpec &working_dir, // Pass empty FileSpec to use
                                                  // the current working
                                                  // directory
       int *status_ptr, // Pass nullptr if you don't want the process exit status
       int *signo_ptr,  // Pass nullptr if you don't want the signal that caused
                        // the process to exit
       std::string
           *command_output, // Pass nullptr if you don't want the command output
       const lldb_private::Timeout<std::micro> &timeout) override;
 
   lldb_private::Status ResolveExecutable(
       const lldb_private::ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
       const lldb_private::FileSpecList *module_search_paths_ptr) override;
 
-  lldb_private::Status
-  GetFileWithUUID(const lldb_private::FileSpec &platform_file,
-                  const lldb_private::UUID *uuid,
-                  lldb_private::FileSpec &local_file) override;
-
-  bool GetProcessInfo(lldb::pid_t pid, lldb_private::ProcessInstanceInfo &proc_info) override;
-
-  uint32_t FindProcesses(const lldb_private::ProcessInstanceInfoMatch &match_info,
-                         lldb_private::ProcessInstanceInfoList &process_infos) override;
-
   lldb_private::Status MakeDirectory(const lldb_private::FileSpec &file_spec,
                                      uint32_t mode) override;
 
   lldb_private::Status
   GetFilePermissions(const lldb_private::FileSpec &file_spec,
                      uint32_t &file_permissions) override;
 
   lldb_private::Status
   SetFilePermissions(const lldb_private::FileSpec &file_spec,
                      uint32_t file_permissions) override;
 
   bool GetFileExists(const lldb_private::FileSpec &file_spec) override;
 
   lldb_private::Status Unlink(const lldb_private::FileSpec &file_spec) override;
 
-  lldb_private::Status
-  LaunchProcess(lldb_private::ProcessLaunchInfo &launch_info) override;
-
   lldb_private::Status KillProcess(const lldb::pid_t pid) override;
 
   lldb::ProcessSP Attach(lldb_private::ProcessAttachInfo &attach_info,
                          lldb_private::Debugger &debugger,
                          lldb_private::Target *target, // Can be nullptr, if
                                                        // nullptr create a new
                                                        // target, else use
                                                        // existing one
protected:
   std::unique_ptr<lldb_private::OptionGroupPlatformSSH>
       m_option_group_platform_ssh;
   std::unique_ptr<lldb_private::OptionGroupPlatformCaching>
       m_option_group_platform_caching;
 
   std::map<lldb_private::CommandInterpreter *,
            std::unique_ptr<lldb_private::OptionGroupOptions>>
       m_options;
-  lldb::PlatformSP m_remote_platform_sp; // Allow multiple ways to connect to a
-                                         // remote POSIX-compliant OS
 
   lldb_private::Status
   EvaluateLibdlExpression(lldb_private::Process *process, const char *expr_cstr,
                           llvm::StringRef expr_prefix,
                           lldb::ValueObjectSP &result_valobj_sp);
 
   std::unique_ptr<lldb_private::UtilityFunction>
   MakeLoadImageUtilityFunction(lldb_private::ExecutionContext &exe_ctx,

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
 PlatformPOSIX::PlatformPOSIX(bool is_host)
-    : Platform(is_host), // This is the local host platform
+    : RemoteAwarePlatform(is_host), // This is the local host platform
       m_option_group_platform_rsync(new OptionGroupPlatformRSync()),
       m_option_group_platform_ssh(new OptionGroupPlatformSSH()),
-      m_option_group_platform_caching(new OptionGroupPlatformCaching()),
-      m_remote_platform_sp() {}
+      m_option_group_platform_caching(new OptionGroupPlatformCaching()) {}
 
 //------------------------------------------------------------------
 /// Destructor.
 ///
 /// The destructor is virtual since this class is designed to be
 /// inherited from by the plug-in instance.
 //------------------------------------------------------------------
 PlatformPOSIX::~PlatformPOSIX() {}
 
-bool PlatformPOSIX::GetModuleSpec(const FileSpec &module_file_spec,
-                                  const ArchSpec &arch,
-                                  ModuleSpec &module_spec) {
-  if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetModuleSpec(module_file_spec, arch,
-                                               module_spec);
-
-  return Platform::GetModuleSpec(module_file_spec, arch, module_spec);
-}
-
 lldb_private::OptionGroupOptions *PlatformPOSIX::GetConnectionOptions(
     lldb_private::CommandInterpreter &interpreter) {
   auto iter = m_options.find(&interpreter), end = m_options.end();
   if (iter == end) {
     std::unique_ptr<lldb_private::OptionGroupOptions> options(
         new OptionGroupOptions());
     options->Append(m_option_group_platform_rsync.get());
     options->Append(m_option_group_platform_ssh.get());
     options->Append(m_option_group_platform_caching.get());
     m_options[&interpreter] = std::move(options);
   }
 
   return m_options.at(&interpreter).get();
 }
 
-bool PlatformPOSIX::IsConnected() const {
-  if (IsHost())
-    return true;
-  else if (m_remote_platform_sp)
-    return m_remote_platform_sp->IsConnected();
-  return false;
-}
-
 lldb_private::Status PlatformPOSIX::RunShellCommand(
     const char *command, // Shouldn't be NULL
     const FileSpec &
         working_dir, // Pass empty FileSpec to use the current working directory
     int *status_ptr, // Pass NULL if you don't want the process exit status
     int *signo_ptr,  // Pass NULL if you don't want the signal that caused the
                      // process to exit
     std::string
// it another try.
         }
       }
     }
   }
 
   return error;
 }
 
-Status PlatformPOSIX::GetFileWithUUID(const FileSpec &platform_file,
-                                      const UUID *uuid_ptr,
-                                      FileSpec &local_file) {
-  if (IsRemote() && m_remote_platform_sp)
-      return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
-                                                   local_file);
-
-  // Default to the local case
-  local_file = platform_file;
-  return Status();
-}
-
-bool PlatformPOSIX::GetProcessInfo(lldb::pid_t pid,
-                                     ProcessInstanceInfo &process_info) {
-  if (IsHost())
-    return Platform::GetProcessInfo(pid, process_info);
-  if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetProcessInfo(pid, process_info);
-  return false;
-}
-
-uint32_t
-PlatformPOSIX::FindProcesses(const ProcessInstanceInfoMatch &match_info,
-                               ProcessInstanceInfoList &process_infos) {
-  if (IsHost())
-    return Platform::FindProcesses(match_info, process_infos);
-  if (m_remote_platform_sp)
-    return
-      m_remote_platform_sp->FindProcesses(match_info, process_infos);
-  return 0;
-}
-
 Status PlatformPOSIX::MakeDirectory(const FileSpec &file_spec,
                                     uint32_t file_permissions) {
   if (m_remote_platform_sp)
     return m_remote_platform_sp->MakeDirectory(file_spec, file_permissions);
   else
     return Platform::MakeDirectory(file_spec, file_permissions);
 }
 

 
 bool PlatformPOSIX::SetRemoteWorkingDirectory(const FileSpec &working_dir) {
   if (IsRemote() && m_remote_platform_sp)
     return m_remote_platform_sp->SetRemoteWorkingDirectory(working_dir);
   else
     return Platform::SetRemoteWorkingDirectory(working_dir);
 }
 
-bool PlatformPOSIX::GetRemoteOSVersion() {
-  if (m_remote_platform_sp) {
-    m_os_version = m_remote_platform_sp->GetOSVersion();
-    return !m_os_version.empty();
-  }
-  return false;
-}
-
-bool PlatformPOSIX::GetRemoteOSBuildString(std::string &s) {
-  if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetRemoteOSBuildString(s);
-  s.clear();
-  return false;
-}
-
-Environment PlatformPOSIX::GetEnvironment() {
-  if (IsRemote()) {
-    if (m_remote_platform_sp)
-      return m_remote_platform_sp->GetEnvironment();
-    return Environment();
-  }
-  return Host::GetEnvironment();
-}
-
-bool PlatformPOSIX::GetRemoteOSKernelDescription(std::string &s) {
-  if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetRemoteOSKernelDescription(s);
-  s.clear();
-  return false;
-}
-
-// Remote Platform subclasses need to override this function
-ArchSpec PlatformPOSIX::GetRemoteSystemArchitecture() {
-  if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetRemoteSystemArchitecture();
-  return ArchSpec();
-}
-
-const char *PlatformPOSIX::GetHostname() {
-  if (IsHost())
-    return Platform::GetHostname();
-
-  if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetHostname();
-  return NULL;
-}
-
-const char *PlatformPOSIX::GetUserName(uint32_t uid) {
-  // Check the cache in Platform in case we have already looked this uid up
-  const char *user_name = Platform::GetUserName(uid);
-  if (user_name)
-    return user_name;
-
-  if (IsRemote() && m_remote_platform_sp)
-    return m_remote_platform_sp->GetUserName(uid);
-  return NULL;
-}
-
-const char *PlatformPOSIX::GetGroupName(uint32_t gid) {
-  const char *group_name = Platform::GetGroupName(gid);
-  if (group_name)
-    return group_name;
-
-  if (IsRemote() && m_remote_platform_sp)
-    return m_remote_platform_sp->GetGroupName(gid);
-  return NULL;
-}
-
 Status PlatformPOSIX::ConnectRemote(Args &args) {
   Status error;
   if (IsHost()) {
     error.SetErrorStringWithFormat(
         "can't connect to the host platform '%s', always connected",
         GetPluginName().GetCString());
   } else {
     if (!m_remote_platform_sp)
if (IsHost()) {
     if (m_remote_platform_sp)
       error = m_remote_platform_sp->DisconnectRemote();
     else
       error.SetErrorString("the platform is not currently connected");
   }
   return error;
 }
 
-Status PlatformPOSIX::LaunchProcess(ProcessLaunchInfo &launch_info) {
-  Status error;
-
-  if (IsHost()) {
-    error = Platform::LaunchProcess(launch_info);
-  } else {
-    if (m_remote_platform_sp)
-      error = m_remote_platform_sp->LaunchProcess(launch_info);
-    else
-      error.SetErrorString("the platform is not currently connected");
-  }
-  return error;
-}
-
 lldb_private::Status PlatformPOSIX::KillProcess(const lldb::pid_t pid) {
   if (IsHost())
     return Platform::KillProcess(pid);
 
   if (m_remote_platform_sp)
     return m_remote_platform_sp->KillProcess(pid);
 
   return Status("the platform is not currently connected");

source/Plugins/Platform/Windows/PlatformWindows.h

 //===-- PlatformWindows.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 liblldb_PlatformWindows_h_
 #define liblldb_PlatformWindows_h_
 
-#include "lldb/Target/Platform.h"
+#include "lldb/Target/RemoteAwarePlatform.h"
 
 namespace lldb_private {
 
-class PlatformWindows : public Platform {
+class PlatformWindows : public RemoteAwarePlatform {
 public:
   PlatformWindows(bool is_host);
 
   ~PlatformWindows() override;
 
   static void Initialize();
 
   static void Terminate();
public:
 
   lldb_private::ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override { return 1; }
 
   //------------------------------------------------------------
   // lldb_private::Platform functions
   //------------------------------------------------------------
-  bool GetModuleSpec(const lldb_private::FileSpec &module_file_spec,
-                     const lldb_private::ArchSpec &arch,
-                     lldb_private::ModuleSpec &module_spec) override;
-
   Status
   ResolveExecutable(const lldb_private::ModuleSpec &module_spec,
                     lldb::ModuleSP &module_sp,
                     const FileSpecList *module_search_paths_ptr) override;
 
   const char *GetDescription() override {
     return GetPluginDescriptionStatic(IsHost());
   }
 
-  bool GetRemoteOSVersion() override;
-
-  bool GetRemoteOSBuildString(std::string &s) override;
-
-  bool GetRemoteOSKernelDescription(std::string &s) override;
-
-  // Remote Platform subclasses need to override this function
-  lldb_private::ArchSpec GetRemoteSystemArchitecture() override;
-
-  bool IsConnected() const override;
-
   lldb_private::Status ConnectRemote(lldb_private::Args &args) override;
 
   lldb_private::Status DisconnectRemote() override;
 
-  const char *GetHostname() override;
-
-  const char *GetUserName(uint32_t uid) override;
-
-  const char *GetGroupName(uint32_t gid) override;
-
-  bool GetProcessInfo(lldb::pid_t pid,
-                      lldb_private::ProcessInstanceInfo &proc_info) override;
-
-  uint32_t
-  FindProcesses(const lldb_private::ProcessInstanceInfoMatch &match_info,
-                lldb_private::ProcessInstanceInfoList &process_infos) override;
-
-  lldb_private::Status
-  LaunchProcess(lldb_private::ProcessLaunchInfo &launch_info) override;
-
   lldb::ProcessSP DebugProcess(lldb_private::ProcessLaunchInfo &launch_info,
                                lldb_private::Debugger &debugger,
                                lldb_private::Target *target,
                                lldb_private::Status &error) override;
 
   lldb::ProcessSP Attach(lldb_private::ProcessAttachInfo &attach_info,
                          lldb_private::Debugger &debugger,
                          lldb_private::Target *target,
                          lldb_private::Status &error) override;
 
   lldb_private::Status
-  GetFileWithUUID(const lldb_private::FileSpec &platform_file,
-                  const lldb_private::UUID *uuid,
-                  lldb_private::FileSpec &local_file) override;
-
-  lldb_private::Status
   GetSharedModule(const lldb_private::ModuleSpec &module_spec,
                   lldb_private::Process *process, lldb::ModuleSP &module_sp,
                   const lldb_private::FileSpecList *module_search_paths_ptr,
                   lldb::ModuleSP *old_module_sp_ptr,
                   bool *did_create_ptr) override;
 
   bool GetSupportedArchitectureAtIndex(uint32_t idx,
                                        lldb_private::ArchSpec &arch) override;
 
   void GetStatus(lldb_private::Stream &strm) override;
 
   bool CanDebugProcess() override;
 
-  Environment GetEnvironment() override;
-
   // FIXME not sure what the _sigtramp equivalent would be on this platform
   void CalculateTrapHandlerSymbolNames() override {}
 
   ConstString GetFullNameForDylib(ConstString basename) override;
 
-protected:
-  lldb::PlatformSP m_remote_platform_sp;
-
 private:
   DISALLOW_COPY_AND_ASSIGN(PlatformWindows);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_PlatformWindows_h_

source/Plugins/Platform/Windows/PlatformWindows.cpp

#endif
   }
 
   Platform::Terminate();
 }
 
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
-PlatformWindows::PlatformWindows(bool is_host) : Platform(is_host) {}
+PlatformWindows::PlatformWindows(bool is_host) : RemoteAwarePlatform(is_host) {}
 
 //------------------------------------------------------------------
 /// Destructor.
 ///
 /// The destructor is virtual since this class is designed to be
 /// inherited from by the plug-in instance.
 //------------------------------------------------------------------
 PlatformWindows::~PlatformWindows() = default;
 
-bool PlatformWindows::GetModuleSpec(const FileSpec &module_file_spec,
-                                    const ArchSpec &arch,
-                                    ModuleSpec &module_spec) {
-  if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetModuleSpec(module_file_spec, arch,
-                                               module_spec);
-
-  return Platform::GetModuleSpec(module_file_spec, arch, module_spec);
-}
-
 Status PlatformWindows::ResolveExecutable(
     const ModuleSpec &ms, lldb::ModuleSP &exe_module_sp,
     const FileSpecList *module_search_paths_ptr) {
   Status error;
   // Nothing special to do here, just use the actual file and architecture
 
   char exe_path[PATH_MAX];
   ModuleSpec resolved_module_spec(ms);
if (resolved_module_spec.GetArchitecture().IsValid()) {
         }
       }
     }
   }
 
   return error;
 }
 
-bool PlatformWindows::GetRemoteOSVersion() {
-  if (m_remote_platform_sp) {
-    m_os_version = m_remote_platform_sp->GetOSVersion();
-    return !m_os_version.empty();
-  }
-  return false;
-}
-
-bool PlatformWindows::GetRemoteOSBuildString(std::string &s) {
-  if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetRemoteOSBuildString(s);
-  s.clear();
-  return false;
-}
-
-bool PlatformWindows::GetRemoteOSKernelDescription(std::string &s) {
-  if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetRemoteOSKernelDescription(s);
-  s.clear();
-  return false;
-}
-
-// Remote Platform subclasses need to override this function
-ArchSpec PlatformWindows::GetRemoteSystemArchitecture() {
-  if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetRemoteSystemArchitecture();
-  return ArchSpec();
-}
-
-const char *PlatformWindows::GetHostname() {
-  if (IsHost())
-    return Platform::GetHostname();
-
-  if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetHostname();
-  return nullptr;
-}
-
-bool PlatformWindows::IsConnected() const {
-  if (IsHost())
-    return true;
-  else if (m_remote_platform_sp)
-    return m_remote_platform_sp->IsConnected();
-  return false;
-}
-
 Status PlatformWindows::ConnectRemote(Args &args) {
   Status error;
   if (IsHost()) {
     error.SetErrorStringWithFormat(
         "can't connect to the host platform '%s', always connected",
         GetPluginName().AsCString());
   } else {
     if (!m_remote_platform_sp)
if (IsHost()) {
     if (m_remote_platform_sp)
       error = m_remote_platform_sp->DisconnectRemote();
     else
       error.SetErrorString("the platform is not currently connected");
   }
   return error;
 }
 
-bool PlatformWindows::GetProcessInfo(lldb::pid_t pid,
-                                     ProcessInstanceInfo &process_info) {
-  bool success = false;
-  if (IsHost()) {
-    success = Platform::GetProcessInfo(pid, process_info);
-  } else if (m_remote_platform_sp) {
-    success = m_remote_platform_sp->GetProcessInfo(pid, process_info);
-  }
-  return success;
-}
-
-uint32_t
-PlatformWindows::FindProcesses(const ProcessInstanceInfoMatch &match_info,
-                               ProcessInstanceInfoList &process_infos) {
-  uint32_t match_count = 0;
-  if (IsHost()) {
-    // Let the base class figure out the host details
-    match_count = Platform::FindProcesses(match_info, process_infos);
-  } else {
-    // If we are remote, we can only return results if we are connected
-    if (m_remote_platform_sp)
-      match_count =
-          m_remote_platform_sp->FindProcesses(match_info, process_infos);
-  }
-  return match_count;
-}
-
-Status PlatformWindows::LaunchProcess(ProcessLaunchInfo &launch_info) {
-  Status error;
-  if (IsHost()) {
-    error = Platform::LaunchProcess(launch_info);
-  } else {
-    if (m_remote_platform_sp)
-      error = m_remote_platform_sp->LaunchProcess(launch_info);
-    else
-      error.SetErrorString("the platform is not currently connected");
-  }
-  return error;
-}
-
 ProcessSP PlatformWindows::DebugProcess(ProcessLaunchInfo &launch_info,
                                         Debugger &debugger, Target *target,
                                         Status &error) {
   // Windows has special considerations that must be followed when launching or
   // attaching to a process.  The key requirement is that when launching or
   // attaching to a process, you must do it from the same the thread that will
   // go into a permanent loop which will then receive debug events from the
   // process.  In particular, this means we can't use any of LLDB's generic
lldb::ProcessSP PlatformWindows::Attach(ProcessAttachInfo &attach_info,
 
   process_sp->HijackProcessEvents(attach_info.GetHijackListener());
   if (process_sp)
     error = process_sp->Attach(attach_info);
 
   return process_sp;
 }
 
-const char *PlatformWindows::GetUserName(uint32_t uid) {
-  // Check the cache in Platform in case we have already looked this uid up
-  const char *user_name = Platform::GetUserName(uid);
-  if (user_name)
-    return user_name;
-
-  if (IsRemote() && m_remote_platform_sp)
-    return m_remote_platform_sp->GetUserName(uid);
-  return nullptr;
-}
-
-const char *PlatformWindows::GetGroupName(uint32_t gid) {
-  const char *group_name = Platform::GetGroupName(gid);
-  if (group_name)
-    return group_name;
-
-  if (IsRemote() && m_remote_platform_sp)
-    return m_remote_platform_sp->GetGroupName(gid);
-  return nullptr;
-}
-
-Status PlatformWindows::GetFileWithUUID(const FileSpec &platform_file,
-                                        const UUID *uuid_ptr,
-                                        FileSpec &local_file) {
-  if (IsRemote()) {
-    if (m_remote_platform_sp)
-      return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
-                                                   local_file);
-  }
-
-  // Default to the local case
-  local_file = platform_file;
-  return Status();
-}
-
 Status PlatformWindows::GetSharedModule(
     const ModuleSpec &module_spec, Process *process, ModuleSP &module_sp,
     const FileSpecList *module_search_paths_ptr, ModuleSP *old_module_sp_ptr,
     bool *did_create_ptr) {
   Status error;
   module_sp.reset();
 
   if (IsRemote()) {

 #ifdef _WIN32
   llvm::VersionTuple version = HostInfo::GetOSVersion();
   strm << "Host: Windows " << version.getAsString() << '\n';
 #endif
 }
 
 bool PlatformWindows::CanDebugProcess() { return true; }
 
-Environment PlatformWindows::GetEnvironment() {
-  if (IsRemote()) {
-    if (m_remote_platform_sp)
-      return m_remote_platform_sp->GetEnvironment();
-    return Environment();
-  }
-
-  return Host::GetEnvironment();
-}
-
 ConstString PlatformWindows::GetFullNameForDylib(ConstString basename) {
   if (basename.IsEmpty())
     return basename;
 
   StreamString stream;
   stream.Printf("%s.dll", basename.GetCString());
   return ConstString(stream.GetString());
 }

source/Target/CMakeLists.txt

add_lldb_library(lldbTarget
   PathMappingList.cpp
   Platform.cpp
   Process.cpp
   Queue.cpp
   QueueItem.cpp
   QueueList.cpp
   RegisterContext.cpp
   RegisterNumber.cpp
+  RemoteAwarePlatform.cpp
   SectionLoadHistory.cpp
   SectionLoadList.cpp
   StackFrame.cpp
   StackFrameList.cpp
   StackFrameRecognizer.cpp
   StackID.cpp
   StopInfo.cpp
   StructuredDataPlugin.cpp

source/Target/RemoteAwarePlatform.cpp

+//===-- RemoteAwarePlatform.cpp ---------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Target/RemoteAwarePlatform.h"
+#include "lldb/Host/Host.h"
+
+using namespace lldb_private;
+
+bool RemoteAwarePlatform::GetModuleSpec(const FileSpec &module_file_spec,
+                                        const ArchSpec &arch,
+                                        ModuleSpec &module_spec) {
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->GetModuleSpec(module_file_spec, arch,
+                                               module_spec);
+
+  return Platform::GetModuleSpec(module_file_spec, arch, module_spec);
+}
+
+Status RemoteAwarePlatform::GetFileWithUUID(const FileSpec &platform_file,
+                                            const UUID *uuid_ptr,
+                                            FileSpec &local_file) {
+  if (IsRemote() && m_remote_platform_sp)
+    return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
+                                                 local_file);
+
+  // Default to the local case
+  local_file = platform_file;
+  return Status();
+}
+
+bool RemoteAwarePlatform::GetRemoteOSVersion() {
+  if (m_remote_platform_sp) {
+    m_os_version = m_remote_platform_sp->GetOSVersion();
+    return !m_os_version.empty();
+  }
+  return false;
+}
+
+bool RemoteAwarePlatform::GetRemoteOSBuildString(std::string &s) {
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->GetRemoteOSBuildString(s);
+  s.clear();
+  return false;
+}
+
+bool RemoteAwarePlatform::GetRemoteOSKernelDescription(std::string &s) {
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->GetRemoteOSKernelDescription(s);
+  s.clear();
+  return false;
+}
+
+ArchSpec RemoteAwarePlatform::GetRemoteSystemArchitecture() {
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->GetRemoteSystemArchitecture();
+  return ArchSpec();
+}
+
+const char *RemoteAwarePlatform::GetHostname() {
+  if (IsHost())
+    return Platform::GetHostname();
+
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->GetHostname();
+  return nullptr;
+}
+
+const char *RemoteAwarePlatform::GetUserName(uint32_t uid) {
+  // Check the cache in Platform in case we have already looked this uid up
+  const char *user_name = Platform::GetUserName(uid);
+  if (user_name)
+    return user_name;
+
+  if (IsRemote() && m_remote_platform_sp)
+    return m_remote_platform_sp->GetUserName(uid);
+  return nullptr;
+}
+
+const char *RemoteAwarePlatform::GetGroupName(uint32_t gid) {
+  const char *group_name = Platform::GetGroupName(gid);
+  if (group_name)
+    return group_name;
+
+  if (IsRemote() && m_remote_platform_sp)
+    return m_remote_platform_sp->GetGroupName(gid);
+  return nullptr;
+}
+
+Environment RemoteAwarePlatform::GetEnvironment() {
+  if (IsRemote()) {
+    if (m_remote_platform_sp)
+      return m_remote_platform_sp->GetEnvironment();
+    return Environment();
+  }
+  return Host::GetEnvironment();
+}
+
+bool RemoteAwarePlatform::IsConnected() const {
+  if (IsHost())
+    return true;
+  else if (m_remote_platform_sp)
+    return m_remote_platform_sp->IsConnected();
+  return false;
+}
+
+bool RemoteAwarePlatform::GetProcessInfo(lldb::pid_t pid,
+                                         ProcessInstanceInfo &process_info) {
+  if (IsHost())
+    return Platform::GetProcessInfo(pid, process_info);
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->GetProcessInfo(pid, process_info);
+  return false;
+}
+
+uint32_t
+RemoteAwarePlatform::FindProcesses(const ProcessInstanceInfoMatch &match_info,
+                                   ProcessInstanceInfoList &process_infos) {
+  if (IsHost())
+    return Platform::FindProcesses(match_info, process_infos);
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->FindProcesses(match_info, process_infos);
+  return 0;
+}
+
+Status RemoteAwarePlatform::LaunchProcess(ProcessLaunchInfo &launch_info) {
+  Status error;
+
+  if (IsHost()) {
+    error = Platform::LaunchProcess(launch_info);
+  } else {
+    if (m_remote_platform_sp)
+      error = m_remote_platform_sp->LaunchProcess(launch_info);
+    else
+      error.SetErrorString("the platform is not currently connected");
+  }
+  return error;
+}