[lldb-server] Add remote platform capabilities for Windows

[asmith]

Summary

Implement a few routines for Windows to support some basic process interaction and file system operations.

[labath]

All of these functions seem identical to their PlatformPOSIX counterparts. Is that right? And I seem to remember already seeing a lot of code duplication between PlatformPOSIX and PlatformWindows.

It sounds to me like we should create a new common base class for PlatformWindows and PlatformPOSIX (RemoteAwarePlatform?), and put the common code there.

[zturner]

In D56232#1344652, @labath wrote:

All of these functions seem identical to their PlatformPOSIX counterparts. Is that right? And I seem to remember already seeing a lot of code duplication between PlatformPOSIX and PlatformWindows.

It sounds to me like we should create a new common base class for PlatformWindows and PlatformPOSIX (RemoteAwarePlatform?), and put the common code there.

Is that even necessary? If a platform is not remote aware, IsHost() will always just return true by definition. So we could put all of this in the existing Platform base class.

[zturner]

source/Plugins/Platform/Windows/PlatformWindows.cpp

176–182

Remove the else here since the if branch already has a return.

180–181

And this else too.

[labath]

In D56232#1348514, @zturner wrote:

Is that even necessary? If a platform is not remote aware, IsHost() will always just return true by definition. So we could put all of this in the existing Platform base class.

I remember looking at this a while a go and concluding against it, but i'm not sure if it was impossible of just I didn't like the result.

The issue here is that PlatformWindows and PlatformPosix already have a m_remote_platform member (which normally is an instance of PlatformRemoteGDBServer). To move the common class into the base one, we'd need to move this member too. That would mean that any platform has a "remote" member, even those that already are "remote". That sounds a bit weird.

[Hui]

In D56232#1349407, @labath wrote:

In D56232#1348514, @zturner wrote:

Is that even necessary? If a platform is not remote aware, IsHost() will always just return true by definition. So we could put all of this in the existing Platform base class.

I remember looking at this a while a go and concluding against it, but i'm not sure if it was impossible of just I didn't like the result.

The issue here is that PlatformWindows and PlatformPosix already have a m_remote_platform member (which normally is an instance of PlatformRemoteGDBServer). To move the common class into the base one, we'd need to move this member too. That would mean that any platform has a "remote" member, even those that already are "remote". That sounds a bit weird.

Yes. I think the thing is the existing design makes PlatformWindows plugin play dual roles: a "host" and "remote-windows" platform which simplily is a pass-through to PlatformRemoteGDBServer. Not quite sure about such intent of design. Maybe to avoid creating new plugin for a remote platform or just to simplifying the init/release in plugin manager. To break them apart, adding back the plugin, maybe PlatformRemoteWindows

PlatformWindows: host implementation only. Most common parts will go to the platform base.

PlatformRemoteWindows: for communicating with remote only. Could just be RemoteAwarePlatform

[labath]

RemoteAwarePlatform is a thing now, so you should be able to take the methods from PlatformPOSIX which make sense for you, and sink them into the new class.

[labath]

Looks good. Just for future patches, please make sure to only clang-format the lines you actually touch. This patch includes a lot of formatting changes to lines that haven't been substantially changed. If you're using git, there's a plugin command for it, which will allow you to do just that via something like git clang-format HEAD^. I don't know if there's such an easy equivalent for svn, but it should at least be achievable by piping the diff through clang-format.

include/lldb/Target/RemoteAwarePlatform.h

 /// 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;
+
+  lldb::user_id_t OpenFile(const FileSpec &file_spec, uint32_t flags,
+                           uint32_t mode, Status &error) override;
+
+  bool CloseFile(lldb::user_id_t fd, Status &error) override;
+
+  uint64_t ReadFile(lldb::user_id_t fd, uint64_t offset, void *dst,
+                    uint64_t dst_len, Status &error) override;
+
+  uint64_t WriteFile(lldb::user_id_t fd, uint64_t offset, const void *src,
+                     uint64_t src_len, Status &error) override;
+
+  lldb::user_id_t GetFileSize(const FileSpec &file_spec) override;
+
+  Status CreateSymlink(const FileSpec &src, const FileSpec &dst) override;
+
+  bool GetFileExists(const FileSpec &file_spec) override;
+
+  Status Unlink(const FileSpec &file_spec) override;
+
+  FileSpec GetRemoteWorkingDirectory() override;
+
+  bool SetRemoteWorkingDirectory(const FileSpec &working_dir) override;
+
+  Status MakeDirectory(const FileSpec &file_spec, uint32_t mode) override;
+
+  Status GetFilePermissions(const FileSpec &file_spec,
+                            uint32_t &file_permissions) override;
+
+  Status SetFilePermissions(const FileSpec &file_spec,
+                            uint32_t file_permissions) override;
+
+  bool CalculateMD5(const FileSpec &file_spec, uint64_t &low,
+                    uint64_t &high) 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;
 
+  Status RunShellCommand(const char *command, const FileSpec &working_dir,
+                         int *status_ptr, int *signo_ptr,
+                         std::string *command_output,
+                         const Timeout<std::micro> &timeout) 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;
+
+  lldb::ProcessSP ConnectProcess(llvm::StringRef connect_url,
+                                 llvm::StringRef plugin_name,
+                                 Debugger &debugger, Target *target,
+                                 Status &error) override;
+
   Status LaunchProcess(ProcessLaunchInfo &launch_info) override;
 
+  Status KillProcess(const lldb::pid_t pid) override;
+
 protected:
   lldb::PlatformSP m_remote_platform_sp;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_REMOTEAWAREPLATFORM_H

source/Plugins/Platform/POSIX/PlatformPOSIX.h

public:
   lldb_private::OptionGroupOptions *
   GetConnectionOptions(lldb_private::CommandInterpreter &interpreter) 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;
-
-  bool CloseFile(lldb::user_id_t fd, lldb_private::Status &error) override;
-
-  uint64_t ReadFile(lldb::user_id_t fd, uint64_t offset, void *dst,
-                    uint64_t dst_len, lldb_private::Status &error) override;
-
-  uint64_t WriteFile(lldb::user_id_t fd, uint64_t offset, const void *src,
-                     uint64_t src_len, lldb_private::Status &error) override;
-
-  lldb::user_id_t GetFileSize(const lldb_private::FileSpec &file_spec) override;
-
-  lldb_private::Status
-  CreateSymlink(const lldb_private::FileSpec &src,
-                const lldb_private::FileSpec &dst) override;
-
   lldb_private::Status
   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;
-
   const lldb::UnixSignalsSP &GetRemoteUnixSignals() 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 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 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
                          lldb_private::Status &error) override;
 
   lldb::ProcessSP DebugProcess(lldb_private::ProcessLaunchInfo &launch_info,
                                lldb_private::Debugger &debugger,
                                lldb_private::Target *target, // Can be nullptr,
                                                              // if nullptr
                                                              // create a new
                                                              // target, else use
                                                              // existing one
                                lldb_private::Status &error) override;
 
   std::string GetPlatformSpecificConnectionInformation() override;
 
-  bool CalculateMD5(const lldb_private::FileSpec &file_spec, uint64_t &low,
-                    uint64_t &high) override;
-
   void CalculateTrapHandlerSymbolNames() override;
 
   lldb_private::Status ConnectRemote(lldb_private::Args &args) override;
 
   lldb_private::Status DisconnectRemote() override;
 
   uint32_t DoLoadImage(lldb_private::Process *process,
                        const lldb_private::FileSpec &remote_file,
                        const std::vector<std::string> *paths,
                        lldb_private::Status &error,
                        lldb_private::FileSpec *loaded_image) override;
 
   lldb_private::Status UnloadImage(lldb_private::Process *process,
                                    uint32_t image_token) override;
 
-  lldb::ProcessSP ConnectProcess(llvm::StringRef connect_url,
-                                 llvm::StringRef plugin_name,
-                                 lldb_private::Debugger &debugger,
-                                 lldb_private::Target *target,
-                                 lldb_private::Status &error) override;
-
   size_t ConnectToWaitingProcesses(lldb_private::Debugger &debugger,
                                    lldb_private::Status &error) override;
 
   lldb_private::ConstString GetFullNameForDylib(lldb_private::ConstString basename) override;
 
 protected:
   std::unique_ptr<lldb_private::OptionGroupPlatformRSync>
       m_option_group_platform_rsync;

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

if (iter == end) {
     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();
 }
 
-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
-        *command_output, // Pass NULL if you don't want the command output
-    const Timeout<std::micro> &timeout) {
-  if (IsHost())
-    return Host::RunShellCommand(command, working_dir, status_ptr, signo_ptr,
-                                 command_output, timeout);
-  else {
-    if (m_remote_platform_sp)
-      return m_remote_platform_sp->RunShellCommand(
-          command, working_dir, status_ptr, signo_ptr, command_output, timeout);
-    else
-      return Status("unable to run a remote command without a platform");
-  }
-}
-
 Status
 PlatformPOSIX::ResolveExecutable(const ModuleSpec &module_spec,
                                  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];
// it another try.
         }
       }
     }
   }
 
   return error;
 }
 
-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);
-}
-
-Status PlatformPOSIX::GetFilePermissions(const FileSpec &file_spec,
-                                         uint32_t &file_permissions) {
-  if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetFilePermissions(file_spec,
-                                                    file_permissions);
-  else
-    return Platform::GetFilePermissions(file_spec, file_permissions);
-}
-
-Status PlatformPOSIX::SetFilePermissions(const FileSpec &file_spec,
-                                         uint32_t file_permissions) {
-  if (m_remote_platform_sp)
-    return m_remote_platform_sp->SetFilePermissions(file_spec,
-                                                    file_permissions);
-  else
-    return Platform::SetFilePermissions(file_spec, file_permissions);
-}
-
-lldb::user_id_t PlatformPOSIX::OpenFile(const FileSpec &file_spec,
-                                        uint32_t flags, uint32_t mode,
-                                        Status &error) {
-  if (IsHost())
-    return FileCache::GetInstance().OpenFile(file_spec, flags, mode, error);
-  else if (m_remote_platform_sp)
-    return m_remote_platform_sp->OpenFile(file_spec, flags, mode, error);
-  else
-    return Platform::OpenFile(file_spec, flags, mode, error);
-}
-
-bool PlatformPOSIX::CloseFile(lldb::user_id_t fd, Status &error) {
-  if (IsHost())
-    return FileCache::GetInstance().CloseFile(fd, error);
-  else if (m_remote_platform_sp)
-    return m_remote_platform_sp->CloseFile(fd, error);
-  else
-    return Platform::CloseFile(fd, error);
-}
-
-uint64_t PlatformPOSIX::ReadFile(lldb::user_id_t fd, uint64_t offset, void *dst,
-                                 uint64_t dst_len, Status &error) {
-  if (IsHost())
-    return FileCache::GetInstance().ReadFile(fd, offset, dst, dst_len, error);
-  else if (m_remote_platform_sp)
-    return m_remote_platform_sp->ReadFile(fd, offset, dst, dst_len, error);
-  else
-    return Platform::ReadFile(fd, offset, dst, dst_len, error);
-}
-
-uint64_t PlatformPOSIX::WriteFile(lldb::user_id_t fd, uint64_t offset,
-                                  const void *src, uint64_t src_len,
-                                  Status &error) {
-  if (IsHost())
-    return FileCache::GetInstance().WriteFile(fd, offset, src, src_len, error);
-  else if (m_remote_platform_sp)
-    return m_remote_platform_sp->WriteFile(fd, offset, src, src_len, error);
-  else
-    return Platform::WriteFile(fd, offset, src, src_len, error);
-}
-
 static uint32_t chown_file(Platform *platform, const char *path,
                            uint32_t uid = UINT32_MAX,
                            uint32_t gid = UINT32_MAX) {
   if (!platform || !path || *path == 0)
     return UINT32_MAX;
 
   if (uid == UINT32_MAX && gid == UINT32_MAX)
     return 0; // pretend I did chown correctly - actually I just didn't care
if (GetSupportsRSync()) {
       }
       // if we are still here rsync has failed - let's try the slow way before
       // giving up
     }
   }
   return Platform::PutFile(source, destination, uid, gid);
 }
 
-lldb::user_id_t PlatformPOSIX::GetFileSize(const FileSpec &file_spec) {
-  if (IsHost()) {
-    uint64_t Size;
-    if (llvm::sys::fs::file_size(file_spec.GetPath(), Size))
-      return 0;
-    return Size;
-  } else if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetFileSize(file_spec);
-  else
-    return Platform::GetFileSize(file_spec);
-}
-
-Status PlatformPOSIX::CreateSymlink(const FileSpec &src, const FileSpec &dst) {
-  if (IsHost())
-    return FileSystem::Instance().Symlink(src, dst);
-  else if (m_remote_platform_sp)
-    return m_remote_platform_sp->CreateSymlink(src, dst);
-  else
-    return Platform::CreateSymlink(src, dst);
-}
-
-bool PlatformPOSIX::GetFileExists(const FileSpec &file_spec) {
-  if (IsHost())
-    return FileSystem::Instance().Exists(file_spec);
-  else if (m_remote_platform_sp)
-    return m_remote_platform_sp->GetFileExists(file_spec);
-  else
-    return Platform::GetFileExists(file_spec);
-}
-
-Status PlatformPOSIX::Unlink(const FileSpec &file_spec) {
-  if (IsHost())
-    return llvm::sys::fs::remove(file_spec.GetPath());
-  else if (m_remote_platform_sp)
-    return m_remote_platform_sp->Unlink(file_spec);
-  else
-    return Platform::Unlink(file_spec);
-}
-
 lldb_private::Status PlatformPOSIX::GetFile(
     const lldb_private::FileSpec &source,      // remote file path
     const lldb_private::FileSpec &destination) // local file path
 {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
 
   // Check the args, first.
   std::string src_path(source.GetPath());
std::string PlatformPOSIX::GetPlatformSpecificConnectionInformation() {
   if (GetLocalCacheDirectory() && *GetLocalCacheDirectory())
     stream.Printf("cache dir: %s", GetLocalCacheDirectory());
   if (stream.GetSize())
     return stream.GetString();
   else
     return "";
 }
 
-bool PlatformPOSIX::CalculateMD5(const FileSpec &file_spec, uint64_t &low,
-                                 uint64_t &high) {
-  if (IsHost())
-    return Platform::CalculateMD5(file_spec, low, high);
-  if (m_remote_platform_sp)
-    return m_remote_platform_sp->CalculateMD5(file_spec, low, high);
-  return false;
-}
-
 const lldb::UnixSignalsSP &PlatformPOSIX::GetRemoteUnixSignals() {
   if (IsRemote() && m_remote_platform_sp)
     return m_remote_platform_sp->GetRemoteUnixSignals();
   return Platform::GetRemoteUnixSignals();
 }
 
-FileSpec PlatformPOSIX::GetRemoteWorkingDirectory() {
-  if (IsRemote() && m_remote_platform_sp)
-    return m_remote_platform_sp->GetRemoteWorkingDirectory();
-  else
-    return Platform::GetRemoteWorkingDirectory();
-}
-
-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);
-}
-
 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;
 }
 
-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");
-}
-
 lldb::ProcessSP PlatformPOSIX::Attach(ProcessAttachInfo &attach_info,
                                       Debugger &debugger, Target *target,
                                       Status &error) {
   lldb::ProcessSP process_sp;
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
 
   if (IsHost()) {
     if (target == NULL) {
Status PlatformPOSIX::UnloadImage(lldb_private::Process *process,
   if (result_valobj_sp->ResolveValue(scalar)) {
     if (scalar.UInt(1))
       return Status("expression failed: \"%s\"", expr.GetData());
     process->ResetImageToken(image_token);
   }
   return Status();
 }
 
-lldb::ProcessSP PlatformPOSIX::ConnectProcess(llvm::StringRef connect_url,
-                                              llvm::StringRef plugin_name,
-                                              lldb_private::Debugger &debugger,
-                                              lldb_private::Target *target,
-                                              lldb_private::Status &error) {
-  if (m_remote_platform_sp)
-    return m_remote_platform_sp->ConnectProcess(connect_url, plugin_name,
-                                                debugger, target, error);
-
-  return Platform::ConnectProcess(connect_url, plugin_name, debugger, target,
-                                  error);
-}
-
 llvm::StringRef
 PlatformPOSIX::GetLibdlFunctionDeclarations(lldb_private::Process *process) {
   return R"(
               extern "C" void* dlopen(const char*, int);
               extern "C" void* dlsym(void*, const char*);
               extern "C" int   dlclose(void*);
               extern "C" char* dlerror(void);
              )";

source/Plugins/Platform/Windows/PlatformWindows.h

lldb::ProcessSP DebugProcess(lldb_private::ProcessLaunchInfo &launch_info,
                                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
-  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;
 
   // FIXME not sure what the _sigtramp equivalent would be on this platform

source/Plugins/Platform/Windows/PlatformWindows.cpp

 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 (IsHost()) {
     // if we cant resolve the executable loation based on the current path
     // variables
     if (!FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec())) {
       resolved_module_spec.GetFileSpec().GetPath(exe_path, sizeof(exe_path));
       resolved_module_spec.GetFileSpec().SetFile(exe_path,
                                                  FileSpec::Style::native);
       FileSystem::Instance().Resolve(resolved_module_spec.GetFileSpec());
     }
 
     if (!FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec()))
       FileSystem::Instance().ResolveExecutableLocation(
           resolved_module_spec.GetFileSpec());
 
     if (FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec()))
       error.Clear();
     else {
       ms.GetFileSpec().GetPath(exe_path, sizeof(exe_path));
       error.SetErrorStringWithFormat("unable to find executable for '%s'",
                                      exe_path);
     }
   } else {
     if (m_remote_platform_sp) {
-      error = GetCachedExecutable(resolved_module_spec, exe_module_sp, nullptr,
-                                  *m_remote_platform_sp);
+      error =
+          GetCachedExecutable(resolved_module_spec, exe_module_sp,
+                              module_search_paths_ptr, *m_remote_platform_sp);
     } else {
       // We may connect to a process and use the provided executable (Don't use
       // local $PATH).
       if (FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec()))
         error.Clear();
       else
         error.SetErrorStringWithFormat("the platform is not currently "
                                        "connected, and '%s' doesn't exist in "
if (resolved_module_spec.GetArchitecture().IsValid()) {
       // No valid architecture was specified, ask the platform for the
       // architectures that we should be using (in the correct order) and see
       // if we can find a match that way
       StreamString arch_names;
       for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
                idx, resolved_module_spec.GetArchitecture());
            ++idx) {
         error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
-                                            nullptr, nullptr, nullptr);
+                                            module_search_paths_ptr, nullptr,
+                                            nullptr);
         // Did we find an executable using one of the
         if (error.Success()) {
           if (exe_module_sp && exe_module_sp->GetObjectFile())
             break;
           else
             error.SetErrorToGenericError();
         }
 
ProcessSP PlatformWindows::DebugProcess(ProcessLaunchInfo &launch_info,
   // argument to CreateProcess() that you're going to debug the process.  So we
   // override DebugProcess here to handle this.  Launch operations go directly
   // to the process plugin, and attach operations almost go directly to the
   // process plugin (but we hijack the events first).  In essence, we
   // encapsulate all the logic of Launching and Attaching in the process
   // plugin, and PlatformWindows::DebugProcess is just a pass-through to get to
   // the process plugin.
 
+  if (IsRemote()) {
+    if (m_remote_platform_sp)
+      return m_remote_platform_sp->DebugProcess(launch_info, debugger, target,
+                                                error);
+    else
+      error.SetErrorString("the platform is not currently connected");
+  }
+
   if (launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID) {
     // This is a process attach.  Don't need to launch anything.
     ProcessAttachInfo attach_info(launch_info);
     return Attach(attach_info, debugger, target, error);
   } else {
     ProcessSP process_sp = target->CreateProcess(
         launch_info.GetListener(), launch_info.GetProcessPluginName(), nullptr);
 
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;
 }
 
-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()) {
-    // If we have a remote platform always, let it try and locate the shared
-    // module first.
-    if (m_remote_platform_sp) {
-      error = m_remote_platform_sp->GetSharedModule(
-          module_spec, process, module_sp, module_search_paths_ptr,
-          old_module_sp_ptr, did_create_ptr);
-    }
-  }
-
-  if (!module_sp) {
-    // Fall back to the local platform and find the file locally
-    error = Platform::GetSharedModule(module_spec, process, module_sp,
-                                      module_search_paths_ptr,
-                                      old_module_sp_ptr, did_create_ptr);
-  }
-  if (module_sp)
-    module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
-  return error;
-}
-
 bool PlatformWindows::GetSupportedArchitectureAtIndex(uint32_t idx,
                                                       ArchSpec &arch) {
   static SupportedArchList architectures;
 
   if (idx >= architectures.Count())
     return false;
   arch = architectures[idx];
   return true;
 }
 
 void PlatformWindows::GetStatus(Stream &strm) {
   Platform::GetStatus(strm);
 
 #ifdef _WIN32
   llvm::VersionTuple version = HostInfo::GetOSVersion();
-  strm << "Host: Windows " << version.getAsString() << '\n';
+  strm << "      Host: Windows " << version.getAsString() << '\n';
 #endif
 }
 
 bool PlatformWindows::CanDebugProcess() { return true; }
 
 ConstString PlatformWindows::GetFullNameForDylib(ConstString basename) {
   if (basename.IsEmpty())
     return basename;
 
   StreamString stream;
   stream.Printf("%s.dll", basename.GetCString());
   return ConstString(stream.GetString());
 }

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/FileCache.h"
+#include "lldb/Host/FileSystem.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::RunShellCommand(
+    const char *command, const FileSpec &working_dir, int *status_ptr,
+    int *signo_ptr, std::string *command_output,
+    const Timeout<std::micro> &timeout) {
+  if (IsHost())
+    return Host::RunShellCommand(command, working_dir, status_ptr, signo_ptr,
+                                 command_output, timeout);
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->RunShellCommand(
+        command, working_dir, status_ptr, signo_ptr, command_output, timeout);
+  return Status("unable to run a remote command without a platform");
+}
+
+Status RemoteAwarePlatform::MakeDirectory(const FileSpec &file_spec,
+                                          uint32_t file_permissions) {
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->MakeDirectory(file_spec, file_permissions);
+  return Platform::MakeDirectory(file_spec, file_permissions);
+}
+
+Status RemoteAwarePlatform::GetFilePermissions(const FileSpec &file_spec,
+                                               uint32_t &file_permissions) {
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->GetFilePermissions(file_spec,
+                                                    file_permissions);
+  return Platform::GetFilePermissions(file_spec, file_permissions);
+}
+
+Status RemoteAwarePlatform::SetFilePermissions(const FileSpec &file_spec,
+                                               uint32_t file_permissions) {
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->SetFilePermissions(file_spec,
+                                                    file_permissions);
+  return Platform::SetFilePermissions(file_spec, file_permissions);
+}
+
+lldb::user_id_t RemoteAwarePlatform::OpenFile(const FileSpec &file_spec,
+                                              uint32_t flags, uint32_t mode,
+                                              Status &error) {
+  if (IsHost())
+    return FileCache::GetInstance().OpenFile(file_spec, flags, mode, error);
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->OpenFile(file_spec, flags, mode, error);
+  return Platform::OpenFile(file_spec, flags, mode, error);
+}
+
+bool RemoteAwarePlatform::CloseFile(lldb::user_id_t fd, Status &error) {
+  if (IsHost())
+    return FileCache::GetInstance().CloseFile(fd, error);
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->CloseFile(fd, error);
+  return Platform::CloseFile(fd, error);
+}
+
+uint64_t RemoteAwarePlatform::ReadFile(lldb::user_id_t fd, uint64_t offset,
+                                       void *dst, uint64_t dst_len,
+                                       Status &error) {
+  if (IsHost())
+    return FileCache::GetInstance().ReadFile(fd, offset, dst, dst_len, error);
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->ReadFile(fd, offset, dst, dst_len, error);
+  return Platform::ReadFile(fd, offset, dst, dst_len, error);
+}
+
+uint64_t RemoteAwarePlatform::WriteFile(lldb::user_id_t fd, uint64_t offset,
+                                        const void *src, uint64_t src_len,
+                                        Status &error) {
+  if (IsHost())
+    return FileCache::GetInstance().WriteFile(fd, offset, src, src_len, error);
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->WriteFile(fd, offset, src, src_len, error);
+  return Platform::WriteFile(fd, offset, src, src_len, error);
+}
+
+lldb::user_id_t RemoteAwarePlatform::GetFileSize(const FileSpec &file_spec) {
+  if (IsHost()) {
+    uint64_t Size;
+    if (llvm::sys::fs::file_size(file_spec.GetPath(), Size))
+      return 0;
+    return Size;
+  }
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->GetFileSize(file_spec);
+  return Platform::GetFileSize(file_spec);
+}
+
+Status RemoteAwarePlatform::CreateSymlink(const FileSpec &src,
+                                          const FileSpec &dst) {
+  if (IsHost())
+    return FileSystem::Instance().Symlink(src, dst);
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->CreateSymlink(src, dst);
+  return Platform::CreateSymlink(src, dst);
+}
+
+bool RemoteAwarePlatform::GetFileExists(const FileSpec &file_spec) {
+  if (IsHost())
+    return FileSystem::Instance().Exists(file_spec);
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->GetFileExists(file_spec);
+  return Platform::GetFileExists(file_spec);
+}
+
+Status RemoteAwarePlatform::Unlink(const FileSpec &file_spec) {
+  if (IsHost())
+    return llvm::sys::fs::remove(file_spec.GetPath());
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->Unlink(file_spec);
+  return Platform::Unlink(file_spec);
+}
+
+bool RemoteAwarePlatform::CalculateMD5(const FileSpec &file_spec, uint64_t &low,
+                                       uint64_t &high) {
+  if (IsHost())
+    return Platform::CalculateMD5(file_spec, low, high);
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->CalculateMD5(file_spec, low, high);
+  return false;
+}
+
+FileSpec RemoteAwarePlatform::GetRemoteWorkingDirectory() {
+  if (IsRemote() && m_remote_platform_sp)
+    return m_remote_platform_sp->GetRemoteWorkingDirectory();
+  return Platform::GetRemoteWorkingDirectory();
+}
+
+bool RemoteAwarePlatform::SetRemoteWorkingDirectory(
+    const FileSpec &working_dir) {
+  if (IsRemote() && m_remote_platform_sp)
+    return m_remote_platform_sp->SetRemoteWorkingDirectory(working_dir);
+  return Platform::SetRemoteWorkingDirectory(working_dir);
+}
+
 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
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);
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;
 }
 
+lldb::ProcessSP RemoteAwarePlatform::ConnectProcess(llvm::StringRef connect_url,
+                                                    llvm::StringRef plugin_name,
+                                                    Debugger &debugger,
+                                                    Target *target,
+                                                    Status &error) {
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->ConnectProcess(connect_url, plugin_name,
+                                                debugger, target, error);
+  return Platform::ConnectProcess(connect_url, plugin_name, debugger, target,
+                                  error);
+}
+
 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;
 }
+
+Status RemoteAwarePlatform::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");
+}