Remove Platform references from the Host module

[labath]

Summary

These were used by Host::LaunchProcess to "resolve" the executable it
was about to launch. The only parts of Platform::ResolveExecutable, which
seem to be relevant here are the FileSpec::ResolvePath and
ResolveExecutableLocation calls.

The rest (most) of that function deals with selecting an architecture
out of a fat binary and making sure we are able to create a Module with that
slice. These are reasonable actions when selecting a binary to debug,
but not for a generic process launching framework (it's technically even
wrong because we should be able to launch a binary with execute
permissions only, but trying to parse such file will obviously fail).

I remove the platform call by inlining the relevant FileSpec calls and
ignoring the rest of the Platform::ResolveExecutable code. The
architecture found by the slice-searching code is being ignored already
anyway, as we use the one specified in the LaunchInfo, so the only
effect of this should be a different error message in case the
executable does not contain the requested architecture -- before we
would get an error message from the Platform class, but now we will get
an error from the actual posix_spawn syscall (this is only relevant on
mac, as it's the only target supporting fat binaries).

Launching targets for debugging should not be affected as here the
executable is pre-resolved at the point when the Target is created.

[davide]

This LGTM but please wait for a second opinion.

[clayborg]

As long as:

% lldb /path/to/Foo.app
(lldb) r

Still works, then I am fine with this. The resolve executable should find the executable down inside the app bundle (like "/path/to/Foo.app/Contents/MacOS/Foo" for desktop apps and "/path/to/Foo.app/Foo" for iOS apps).

[zturner]

In D41902#972614, @clayborg wrote:

As long as:

% lldb /path/to/Foo.app
(lldb) r

Still works, then I am fine with this. The resolve executable should find the executable down inside the app bundle (like "/path/to/Foo.app/Contents/MacOS/Foo" for desktop apps and "/path/to/Foo.app/Foo" for iOS apps).

This sounds like something that would be pretty easy to write a test for with lldb-test.

[davide]

In D41902#972619, @zturner wrote:

In D41902#972614, @clayborg wrote:

As long as:

% lldb /path/to/Foo.app
(lldb) r

Still works, then I am fine with this. The resolve executable should find the executable down inside the app bundle (like "/path/to/Foo.app/Contents/MacOS/Foo" for desktop apps and "/path/to/Foo.app/Foo" for iOS apps).

This sounds like something that would be pretty easy to write a test for with lldb-test.

Yes, please add a test.

[labath]

Add back bundle resolution to the mac launcher

source/Host/common/MonitoringProcessLauncher.cpp

 //===-- MonitoringProcessLauncher.cpp ---------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/MonitoringProcessLauncher.h"
-#include "lldb/Core/Module.h"
-#include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/HostProcess.h"
-#include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 
 #include "llvm/Support/FileSystem.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 MonitoringProcessLauncher::MonitoringProcessLauncher(
     std::unique_ptr<ProcessLauncher> delegate_launcher)
     : m_delegate_launcher(std::move(delegate_launcher)) {}
 
 HostProcess
 MonitoringProcessLauncher::LaunchProcess(const ProcessLaunchInfo &launch_info,
                                          Status &error) {
   ProcessLaunchInfo resolved_info(launch_info);
 
   error.Clear();
-  char exe_path[PATH_MAX];
-
-  PlatformSP host_platform_sp(Platform::GetHostPlatform());
-
-  const ArchSpec &arch_spec = resolved_info.GetArchitecture();
 
   FileSpec exe_spec(resolved_info.GetExecutableFile());
 
   llvm::sys::fs::file_status stats;
   status(exe_spec.GetPath(), stats);
-  if (!is_regular_file(stats)) {
-    ModuleSpec module_spec(exe_spec, arch_spec);
-    lldb::ModuleSP exe_module_sp;
-    error =
-        host_platform_sp->ResolveExecutable(module_spec, exe_module_sp, NULL);
-
-    if (error.Fail())
-      return HostProcess();
-
-    if (exe_module_sp) {
-      exe_spec = exe_module_sp->GetFileSpec();
-      status(exe_spec.GetPath(), stats);
-    }
+  if (!exists(stats)) {
+    exe_spec.ResolvePath();
+  if (!exists(stats)) {
+    exe_spec.ResolveExecutableLocation();
+    status(exe_spec.GetPath(), stats);
   }
 
-  if (exists(stats)) {
-    exe_spec.GetPath(exe_path, sizeof(exe_path));
-  } else {
-    resolved_info.GetExecutableFile().GetPath(exe_path, sizeof(exe_path));
-    error.SetErrorStringWithFormat("executable doesn't exist: '%s'", exe_path);
+  if (!exists(stats)) {
+    error.SetErrorStringWithFormatv("executable doesn't exist: '{0}'",
+                                    exe_spec);
     return HostProcess();
   }
 
   resolved_info.SetExecutableFile(exe_spec, false);
   assert(!resolved_info.GetFlags().Test(eLaunchFlagLaunchInTTY));
 
   HostProcess process =
       m_delegate_launcher->LaunchProcess(resolved_info, error);

source/Host/freebsd/Host.cpp

 #include <stdio.h>
 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Module.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/CleanUp.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/NameMatches.h"
 #include "lldb/Utility/Status.h"

source/Host/macosx/Host.mm

 #include <stdlib.h>
 #include <sys/proc.h>
 #include <sys/stat.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include "lldb/Core/Communication.h"
-#include "lldb/Core/Module.h"
-#include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/ThreadLauncher.h"
-#include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/CleanUp.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
#if !NO_XPC_SERVICES
   }
 #endif
 
   return result;
 }
 
 Status Host::LaunchProcess(ProcessLaunchInfo &launch_info) {
   Status error;
-  char exe_path[PATH_MAX];
-  PlatformSP host_platform_sp(Platform::GetHostPlatform());
+  FileSpec exe_spec(launch_info.GetExecutableFile());
 
-  ModuleSpec exe_module_spec(launch_info.GetExecutableFile(),
-                             launch_info.GetArchitecture());
-
-  if (!llvm::sys::fs::is_regular_file(
-          exe_module_spec.GetFileSpec().GetPath())) {
-    lldb::ModuleSP exe_module_sp;
-    error = host_platform_sp->ResolveExecutable(exe_module_spec, exe_module_sp,
-                                                NULL);
-
-    if (error.Fail())
-      return error;
-
-    if (exe_module_sp)
-      exe_module_spec.GetFileSpec() = exe_module_sp->GetFileSpec();
-  }
-
-  if (exe_module_spec.GetFileSpec().Exists()) {
-    exe_module_spec.GetFileSpec().GetPath(exe_path, sizeof(exe_path));
-  } else {
-    launch_info.GetExecutableFile().GetPath(exe_path, sizeof(exe_path));
-    error.SetErrorStringWithFormat("executable doesn't exist: '%s'", exe_path);
+  llvm::sys::fs::file_status stats;
+  status(exe_spec.GetPath(), stats);
+  if (!exists(stats)) {
+    exe_spec.ResolvePath();
+    status(exe_spec.GetPath(), stats);
+  }
+  if (!exists(stats)) {
+    exe_spec.ResolveExecutableLocation();
+    status(exe_spec.GetPath(), stats);
+  }
+  ResolveExecutableInBundle(exe_spec);
+  status(exe_spec.GetPath(), stats);
+  if (!exists(stats)) {
+    error.SetErrorStringWithFormatv("executable doesn't exist: '{0}'",
+                                    launch_info.GetExecutableFile());
     return error;
   }
 
   if (launch_info.GetFlags().Test(eLaunchFlagLaunchInTTY)) {
 #if !defined(__arm__) && !defined(__arm64__) && !defined(__aarch64__)
-    return LaunchInNewTerminalWithAppleScript(exe_path, launch_info);
+    return LaunchInNewTerminalWithAppleScript(exe_spec.GetPath().c_str(),
+                                              launch_info);
 #else
     error.SetErrorString("launching a process in a new terminal is not "
                          "supported on iOS devices");
     return error;
 #endif
   }
 
   lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
 
   if (ShouldLaunchUsingXPC(launch_info)) {
-    error = LaunchProcessXPC(exe_path, launch_info, pid);
+    error = LaunchProcessXPC(exe_spec.GetPath().c_str(), launch_info, pid);
   } else {
-    error = LaunchProcessPosixSpawn(exe_path, launch_info, pid);
+    error =
+        LaunchProcessPosixSpawn(exe_spec.GetPath().c_str(), launch_info, pid);
   }
 
   if (pid != LLDB_INVALID_PROCESS_ID) {
     // If all went well, then set the process ID into the launch info
     launch_info.SetProcessID(pid);
 
     // Make sure we reap any processes we spawn or we will have zombies.
     if (!launch_info.MonitorProcess()) {

source/Host/netbsd/Host.cpp

 #include <sys/ptrace.h>
 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Module.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/CleanUp.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/NameMatches.h"
 #include "lldb/Utility/Status.h"

source/Host/openbsd/Host.cpp

 #include <stdio.h>
 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Module.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/CleanUp.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/NameMatches.h"
 #include "lldb/Utility/Status.h"