Move GetXcode*Directory into HostInfo (NFC)

[aprantl]

Summary

These functions really don't belong into PlatformDarwin, since they actually query state of the Host and not of the remote platform.

[JDevlieghere]

LGTM

[aprantl]

3d7b926dd16ff9ff264337793b76080681636f15

lldb/include/lldb/Host/HostInfoBase.h

public:
   /// If the triple does not specify the vendor, os, and environment parts, we
   /// "augment" these using information from the host and return the resulting
   /// ArchSpec object.
   static ArchSpec GetAugmentedArchSpec(llvm::StringRef triple);
 
   static bool ComputePathRelativeToLibrary(FileSpec &file_spec,
                                            llvm::StringRef dir);
 
+  static FileSpec GetXcodeContentsDirectory() { return {}; }
+  static FileSpec GetXcodeDeveloperDirectory() { return {}; }
+  
   /// Return the directory containing a specific Xcode SDK.
   static llvm::StringRef GetXcodeSDKPath(XcodeSDK sdk) { return {}; }
 
 protected:
   static bool ComputeSharedLibraryDirectory(FileSpec &file_spec);
   static bool ComputeSupportExeDirectory(FileSpec &file_spec);
   static bool ComputeProcessTempFileDirectory(FileSpec &file_spec);
   static bool ComputeGlobalTempFileDirectory(FileSpec &file_spec);

lldb/include/lldb/Host/macosx/HostInfoMacOSX.h

private:
   ~HostInfoMacOSX() = delete;
 
 public:
   static llvm::VersionTuple GetOSVersion();
   static llvm::VersionTuple GetMacCatalystVersion();
   static bool GetOSBuildString(std::string &s);
   static bool GetOSKernelDescription(std::string &s);
   static FileSpec GetProgramFileSpec();
-  static std::string FindXcodeContentsDirectoryInPath(llvm::StringRef path);
+  static FileSpec GetXcodeContentsDirectory();
+  static FileSpec GetXcodeDeveloperDirectory();
 
   /// Query xcrun to find an Xcode SDK directory.
   static llvm::StringRef GetXcodeSDKPath(XcodeSDK sdk);
 protected:
   static bool ComputeSupportExeDirectory(FileSpec &file_spec);
   static void ComputeHostArchitectureSupport(ArchSpec &arch_32,
                                              ArchSpec &arch_64);
   static bool ComputeHeaderDirectory(FileSpec &file_spec);
   static bool ComputeSystemPluginsDirectory(FileSpec &file_spec);
   static bool ComputeUserPluginsDirectory(FileSpec &file_spec);
 };
 }
 
 #endif

lldb/include/lldb/Utility/XcodeSDK.h

public:
 
   /// Whether LLDB feels confident importing Clang modules from this SDK.
   static bool SDKSupportsModules(Type type, llvm::VersionTuple version);
   static bool SDKSupportsModules(Type desired_type, const FileSpec &sdk_path);
   /// Return the canonical SDK name, such as "macosx" for the macOS SDK.
   static std::string GetCanonicalName(Info info);
   /// Return the best-matching SDK type for a specific triple.
   static XcodeSDK::Type GetSDKTypeForTriple(const llvm::Triple &triple);
+
+  static std::string FindXcodeContentsDirectoryInPath(llvm::StringRef path);
 };
 
 } // namespace lldb_private
 
 #endif

lldb/source/Host/macosx/objcxx/HostInfoMacOSX.mm

 #else
       arch_32.GetTriple().setOS(llvm::Triple::IOS);
 #endif
       arch_64.Clear();
     }
   }
 }
 
+FileSpec HostInfoMacOSX::GetXcodeContentsDirectory() {
+  static FileSpec g_xcode_contents_path;
+  static std::once_flag g_once_flag;
+  std::call_once(g_once_flag, [&]() {
+    // Try the shlib dir first.
+    if (FileSpec fspec = HostInfo::GetShlibDir()) {
+      if (FileSystem::Instance().Exists(fspec)) {
+        std::string xcode_contents_dir =
+            XcodeSDK::FindXcodeContentsDirectoryInPath(fspec.GetPath());
+        if (!xcode_contents_dir.empty()) {
+          g_xcode_contents_path = FileSpec(xcode_contents_dir);
+          return;
+        }
+      }
+    }
+
+    if (const char *developer_dir_env_var = getenv("DEVELOPER_DIR")) {
+      FileSpec fspec(developer_dir_env_var);
+      if (FileSystem::Instance().Exists(fspec)) {
+        // FIXME: This looks like it couldn't possibly work!
+        std::string xcode_contents_dir =
+            XcodeSDK::FindXcodeContentsDirectoryInPath(fspec.GetPath());
+        if (!xcode_contents_dir.empty()) {
+          g_xcode_contents_path = FileSpec(xcode_contents_dir);
+          return;
+        }
+      }
+    }
+
+    FileSpec fspec(HostInfo::GetXcodeSDKPath(XcodeSDK::GetAnyMacOS()));
+    if (fspec) {
+      if (FileSystem::Instance().Exists(fspec)) {
+        std::string xcode_contents_dir =
+            XcodeSDK::FindXcodeContentsDirectoryInPath(fspec.GetPath());
+        if (!xcode_contents_dir.empty()) {
+          g_xcode_contents_path = FileSpec(xcode_contents_dir);
+          return;
+        }
+      }
+    }
+  });
+  return g_xcode_contents_path;
+}
+
+lldb_private::FileSpec HostInfoMacOSX::GetXcodeDeveloperDirectory() {
+  static lldb_private::FileSpec g_developer_directory;
+  static llvm::once_flag g_once_flag;
+  llvm::call_once(g_once_flag, []() {
+    if (FileSpec fspec = GetXcodeContentsDirectory()) {
+      fspec.AppendPathComponent("Developer");
+      if (FileSystem::Instance().Exists(fspec))
+        g_developer_directory = fspec;
+    }
+  });
+  return g_developer_directory;
+}
+
 static std::string GetXcodeSDK(XcodeSDK sdk) {
   XcodeSDK::Info info = sdk.Parse();
   std::string sdk_name = XcodeSDK::GetCanonicalName(info);
   auto find_sdk = [](std::string sdk_name) -> std::string {
     std::string xcrun_cmd = "xcrun --show-sdk-path --sdk " + sdk_name;
     int status = 0;
     int signo = 0;
     std::string output_str;

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

 
 #if defined(__APPLE__)
 #include <dlfcn.h>
 #endif
 
 #include <mutex>
 #include <thread>
 #include "lldb/Host/PseudoTerminal.h"
+#include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 #include "llvm/Support/Threading.h"
 
 using namespace lldb;
 using namespace lldb_private;

 }
 
 void PlatformAppleSimulator::GetStatus(Stream &strm) {
 #if defined(__APPLE__)
   // This will get called by subclasses, so just output status on the current
   // simulator
   PlatformAppleSimulator::LoadCoreSimulator();
 
-  std::string developer_dir = GetXcodeDeveloperDirectory().GetPath();
+  std::string developer_dir = HostInfo::GetXcodeDeveloperDirectory().GetPath();
   CoreSimulatorSupport::DeviceSet devices =
       CoreSimulatorSupport::DeviceSet::GetAvailableDevices(
           developer_dir.c_str());
   const size_t num_devices = devices.GetNumDevices();
   if (num_devices) {
     strm.Printf("Available devices:\n");
     for (size_t i = 0; i < num_devices; ++i) {
       CoreSimulatorSupport::Device device = devices.GetDeviceAtIndex(i);
#if defined(__APPLE__)
   Status error;
   if (args.GetArgumentCount() == 1) {
     if (m_device)
       DisconnectRemote();
     PlatformAppleSimulator::LoadCoreSimulator();
     const char *arg_cstr = args.GetArgumentAtIndex(0);
     if (arg_cstr) {
       std::string arg_str(arg_cstr);
-      std::string developer_dir = GetXcodeDeveloperDirectory().GetPath();
+      std::string developer_dir = HostInfo::GetXcodeDeveloperDirectory().GetPath();
       CoreSimulatorSupport::DeviceSet devices =
           CoreSimulatorSupport::DeviceSet::GetAvailableDevices(
               developer_dir.c_str());
       devices.ForEach(
           [this, &arg_str](const CoreSimulatorSupport::Device &device) -> bool {
             if (arg_str == device.GetUDID() || arg_str == device.GetName()) {
               m_device = device;
               return false; // Stop iterating
#else
   return ProcessSP();
 #endif
 }
 
 FileSpec PlatformAppleSimulator::GetCoreSimulatorPath() {
 #if defined(__APPLE__)
   std::lock_guard<std::mutex> guard(m_core_sim_path_mutex);
   if (!m_core_simulator_framework_path.hasValue()) {
-    if (FileSpec fspec = GetXcodeDeveloperDirectory()) {
+    if (FileSpec fspec = HostInfo::GetXcodeDeveloperDirectory()) {
       std::string developer_dir = fspec.GetPath();
       StreamString cs_path;
       cs_path.Printf(
           "%s/Library/PrivateFrameworks/CoreSimulator.framework/CoreSimulator",
           developer_dir.c_str());
       m_core_simulator_framework_path = FileSpec(cs_path.GetData());
       FileSystem::Instance().Resolve(*m_core_simulator_framework_path);
     }

 #endif
 }
 
 #if defined(__APPLE__)
 CoreSimulatorSupport::Device PlatformAppleSimulator::GetSimulatorDevice() {
   if (!m_device.hasValue()) {
     const CoreSimulatorSupport::DeviceType::ProductFamilyID dev_id =
         CoreSimulatorSupport::DeviceType::ProductFamilyID::iPhone;
-    std::string developer_dir = GetXcodeDeveloperDirectory().GetPath();
+    std::string developer_dir = HostInfo::GetXcodeDeveloperDirectory().GetPath();
     m_device = CoreSimulatorSupport::DeviceSet::GetAvailableDevices(
                    developer_dir.c_str())
                    .GetFanciest(dev_id);
   }
 
   if (m_device.hasValue())
     return m_device.getValue();
   else
     return CoreSimulatorSupport::Device();
 }
 #endif

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

if (ft == llvm::sys::fs::file_type::directory_file) {
     }
   }
   return FileSystem::eEnumerateDirectoryResultNext;
 }
 
 const char *PlatformAppleTVSimulator::GetSDKDirectoryAsCString() {
   std::lock_guard<std::mutex> guard(m_sdk_dir_mutex);
   if (m_sdk_directory.empty()) {
-    if (FileSpec fspec = GetXcodeDeveloperDirectory()) {
+    if (FileSpec fspec = HostInfo::GetXcodeDeveloperDirectory()) {
       std::string developer_dir = fspec.GetPath();
       char sdks_directory[PATH_MAX];
       char sdk_dirname[PATH_MAX];
       sdk_dirname[0] = '\0';
       snprintf(sdks_directory, sizeof(sdks_directory),
                "%s/Platforms/AppleTVSimulator.platform/Developer/SDKs",
                developer_dir.c_str());
       FileSpec simulator_sdk_spec;

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

if (ft == llvm::sys::fs::file_type::directory_file) {
     }
   }
   return FileSystem::eEnumerateDirectoryResultNext;
 }
 
 const char *PlatformAppleWatchSimulator::GetSDKDirectoryAsCString() {
   std::lock_guard<std::mutex> guard(m_sdk_dir_mutex);
   if (m_sdk_directory.empty()) {
-    if (FileSpec fspec = GetXcodeDeveloperDirectory()) {
+    if (FileSpec fspec = HostInfo::GetXcodeDeveloperDirectory()) {
       std::string developer_dir = fspec.GetPath();
       char sdks_directory[PATH_MAX];
       char sdk_dirname[PATH_MAX];
       sdk_dirname[0] = '\0';
       snprintf(sdks_directory, sizeof(sdks_directory),
                "%s/Platforms/AppleWatchSimulator.platform/Developer/SDKs",
                developer_dir.c_str());
       FileSpec simulator_sdk_spec;

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

public:
   LaunchProcess(lldb_private::ProcessLaunchInfo &launch_info) override;
 
   static std::tuple<llvm::VersionTuple, llvm::StringRef>
   ParseVersionBuildDir(llvm::StringRef str);
 
   llvm::Expected<lldb_private::StructuredData::DictionarySP>
   FetchExtendedCrashInformation(lldb_private::Process &process) override;
 
-  static lldb_private::FileSpec GetXcodeContentsDirectory();
-  static lldb_private::FileSpec GetXcodeDeveloperDirectory();
-
   /// Return the toolchain directory the current LLDB instance is located in.
   static lldb_private::FileSpec GetCurrentToolchainDirectory();
 
   /// Return the command line tools directory the current LLDB instance is
   /// located in.
   static lldb_private::FileSpec GetCurrentCommandLineToolsDirectory();
 
 protected:
protected:
   lldb_private::Status FindBundleBinaryInExecSearchPaths(
       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);
 
   static std::string FindComponentInPath(llvm::StringRef path,
                                          llvm::StringRef component);
-  static std::string FindXcodeContentsDirectoryInPath(llvm::StringRef path);
 
   std::string m_developer_directory;
   llvm::StringMap<std::string> m_sdk_path;
   std::mutex m_sdk_path_mutex;
 
 private:
   PlatformDarwin(const PlatformDarwin &) = delete;
   const PlatformDarwin &operator=(const PlatformDarwin &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMDARWIN_H

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

if (FileSystem::Instance().Exists(xcode_select_cmd)) {
         g_xcode_select_filespec = FileSpec(command_output);
       }
     }
   }
 
   return g_xcode_select_filespec;
 }
 
-lldb_private::FileSpec PlatformDarwin::GetXcodeDeveloperDirectory() {
-  static lldb_private::FileSpec g_developer_directory;
-  static llvm::once_flag g_once_flag;
-  llvm::call_once(g_once_flag, []() {
-    if (FileSpec fspec = GetXcodeContentsDirectory()) {
-      fspec.AppendPathComponent("Developer");
-      if (FileSystem::Instance().Exists(fspec))
-        g_developer_directory = fspec;
-    }
-  });
-  return g_developer_directory;
-}
-
 BreakpointSP PlatformDarwin::SetThreadCreationBreakpoint(Target &target) {
   BreakpointSP bp_sp;
   static const char *g_bp_names[] = {
       "start_wqthread", "_pthread_wqthread", "_pthread_start",
   };
 
   static const char *g_bp_modules[] = {"libsystem_c.dylib",
                                        "libSystem.B.dylib"};
FileSpec PlatformDarwin::FindSDKInXcodeForModules(XcodeSDK::Type sdk_type,
 
   if (FileSystem::Instance().IsDirectory(enumerator_info.found_path))
     return enumerator_info.found_path;
   else
     return FileSpec();
 }
 
 FileSpec PlatformDarwin::GetSDKDirectoryForModules(XcodeSDK::Type sdk_type) {
-  FileSpec sdks_spec = GetXcodeContentsDirectory();
+  FileSpec sdks_spec = HostInfo::GetXcodeContentsDirectory();
   sdks_spec.AppendPathComponent("Developer");
   sdks_spec.AppendPathComponent("Platforms");
 
   switch (sdk_type) {
   case XcodeSDK::Type::MacOSX:
     sdks_spec.AppendPathComponent("MacOSX.platform");
     break;
   case XcodeSDK::Type::iPhoneSimulator:
lldb_private::FileSpec PlatformDarwin::LocateExecutable(const char *basename) {
   static std::vector<FileSpec> g_executable_dirs;
 
   // Find the global list of directories that we will search for executables
   // once so we don't keep doing the work over and over.
   static llvm::once_flag g_once_flag;
   llvm::call_once(g_once_flag, []() {
 
     // When locating executables, trust the DEVELOPER_DIR first if it is set
-    FileSpec xcode_contents_dir = GetXcodeContentsDirectory();
+    FileSpec xcode_contents_dir = HostInfo::GetXcodeContentsDirectory();
     if (xcode_contents_dir) {
       FileSpec xcode_lldb_resources = xcode_contents_dir;
       xcode_lldb_resources.AppendPathComponent("SharedFrameworks");
       xcode_lldb_resources.AppendPathComponent("LLDB.framework");
       xcode_lldb_resources.AppendPathComponent("Resources");
       if (FileSystem::Instance().Exists(xcode_lldb_resources)) {
         FileSpec dir;
         dir.GetDirectory().SetCString(xcode_lldb_resources.GetPath().c_str());
if (it->contains(component)) {
       llvm::sys::path::append(buffer, begin, ++it,
                               llvm::sys::path::Style::posix);
       return buffer.str().str();
     }
   }
   return {};
 }
 
-std::string
-PlatformDarwin::FindXcodeContentsDirectoryInPath(llvm::StringRef path) {
-  auto begin = llvm::sys::path::begin(path);
-  auto end = llvm::sys::path::end(path);
-
-  // Iterate over the path components until we find something that ends with
-  // .app. If the next component is Contents then we've found the Contents
-  // directory.
-  for (auto it = begin; it != end; ++it) {
-    if (it->endswith(".app")) {
-      auto next = it;
-      if (++next != end && *next == "Contents") {
-        llvm::SmallString<128> buffer;
-        llvm::sys::path::append(buffer, begin, ++next,
-                                llvm::sys::path::Style::posix);
-        return buffer.str().str();
-      }
-    }
-  }
-
-  return {};
-}
-
-FileSpec PlatformDarwin::GetXcodeContentsDirectory() {
-  static FileSpec g_xcode_contents_path;
-  static std::once_flag g_once_flag;
-  std::call_once(g_once_flag, [&]() {
-    // Try the shlib dir first.
-    if (FileSpec fspec = HostInfo::GetShlibDir()) {
-      if (FileSystem::Instance().Exists(fspec)) {
-        std::string xcode_contents_dir =
-            FindXcodeContentsDirectoryInPath(fspec.GetPath());
-        if (!xcode_contents_dir.empty()) {
-          g_xcode_contents_path = FileSpec(xcode_contents_dir);
-          return;
-        }
-      }
-    }
-
-    if (const char *developer_dir_env_var = getenv("DEVELOPER_DIR")) {
-      FileSpec fspec(developer_dir_env_var);
-      if (FileSystem::Instance().Exists(fspec)) {
-        std::string xcode_contents_dir =
-            FindXcodeContentsDirectoryInPath(fspec.GetPath());
-        if (!xcode_contents_dir.empty()) {
-          g_xcode_contents_path = FileSpec(xcode_contents_dir);
-          return;
-        }
-      }
-    }
-
-    FileSpec fspec(HostInfo::GetXcodeSDKPath(XcodeSDK::GetAnyMacOS()));
-    if (fspec) {
-      if (FileSystem::Instance().Exists(fspec)) {
-        std::string xcode_contents_dir =
-            FindXcodeContentsDirectoryInPath(fspec.GetPath());
-        if (!xcode_contents_dir.empty()) {
-          g_xcode_contents_path = FileSpec(xcode_contents_dir);
-          return;
-        }
-      }
-    }
-  });
-  return g_xcode_contents_path;
-}
-
 FileSpec PlatformDarwin::GetCurrentToolchainDirectory() {
   if (FileSpec fspec = HostInfo::GetShlibDir())
     return FileSpec(FindComponentInPath(fspec.GetPath(), ".xctoolchain"));
   return {};
 }
 
 FileSpec PlatformDarwin::GetCurrentCommandLineToolsDirectory() {
   if (FileSpec fspec = HostInfo::GetShlibDir())
     return FileSpec(FindComponentInPath(fspec.GetPath(), "CommandLineTools"));
   return {};
 }

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

#if defined(__APPLE__) // This Plugin uses the Mac-specific
                        // source/Host/macosx/cfcpp utilities
 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Host/HostInfo.h"
 #include "lldb/Interpreter/OptionValueFileSpecList.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"

 void PlatformDarwinKernel::CollectKextAndKernelDirectories() {
   // Differentiate between "ios debug session" and "mac debug session" so we
   // don't index kext bundles that won't be used in this debug session.  If
   // this is an ios kext debug session, looking in /System/Library/Extensions
   // is a waste of stat()s, for example.
 
   // DeveloperDirectory is something like
   // "/Applications/Xcode.app/Contents/Developer"
-  std::string developer_dir = GetXcodeDeveloperDirectory().GetPath();
+  std::string developer_dir = HostInfo::GetXcodeDeveloperDirectory().GetPath();
   if (developer_dir.empty())
     developer_dir = "/Applications/Xcode.app/Contents/Developer";
 
   if (m_ios_debug_session != eLazyBoolNo) {
     AddSDKSubdirsToSearchPaths(developer_dir +
                                "/Platforms/iPhoneOS.platform/Developer/SDKs");
     AddSDKSubdirsToSearchPaths(developer_dir +
                                "/Platforms/AppleTVOS.platform/Developer/SDKs");

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

ConstString PlatformMacOSX::GetSDKDirectory(lldb_private::Target &target) {
   if (!objfile)
     return {};
 
   llvm::VersionTuple version = objfile->GetSDKVersion();
   if (version.empty())
     return {};
 
   // First try to find an SDK that matches the given SDK version.
-  if (FileSpec fspec = GetXcodeContentsDirectory()) {
+  if (FileSpec fspec = HostInfo::GetXcodeContentsDirectory()) {
     StreamString sdk_path;
     sdk_path.Printf("%s/Developer/Platforms/MacOSX.platform/Developer/"
                     "SDKs/MacOSX%u.%u.sdk",
                     fspec.GetPath().c_str(), version.getMajor(),
                     version.getMinor().getValue());
     if (FileSystem::Instance().Exists(fspec))
       return ConstString(sdk_path.GetString());
   }

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

 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Host/HostInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
if (max != m_sdk_directory_infos.end())
       result = &*max;
   }
   return result;
 }
 
 const char *PlatformRemoteDarwinDevice::GetDeviceSupportDirectory() {
   std::string platform_dir = "/Platforms/" + GetPlatformName() + "/DeviceSupport";
   if (m_device_support_directory.empty()) {
-    if (FileSpec fspec = GetXcodeDeveloperDirectory()) {
+    if (FileSpec fspec = HostInfo::GetXcodeDeveloperDirectory()) {
       m_device_support_directory = fspec.GetPath();
       m_device_support_directory.append(platform_dir.c_str());
     } else {
       // Assign a single NULL character so we know we tried to find the device
       // support directory and we don't keep trying to find it over and over.
       m_device_support_directory.assign(1, '\0');
     }
   }

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

if (ft == llvm::sys::fs::file_type::directory_file) {
     }
   }
   return FileSystem::eEnumerateDirectoryResultNext;
 }
 
 const char *PlatformiOSSimulator::GetSDKDirectoryAsCString() {
   std::lock_guard<std::mutex> guard(m_sdk_dir_mutex);
   if (m_sdk_directory.empty()) {
-    if (FileSpec fspec = GetXcodeDeveloperDirectory()) {
+    if (FileSpec fspec = HostInfo::GetXcodeDeveloperDirectory()) {
       std::string developer_dir = fspec.GetPath();
       char sdks_directory[PATH_MAX];
       char sdk_dirname[PATH_MAX];
       sdk_dirname[0] = '\0';
       snprintf(sdks_directory, sizeof(sdks_directory),
                "%s/Platforms/iPhoneSimulator.platform/Developer/SDKs",
                developer_dir.c_str());
       FileSpec simulator_sdk_spec;

lldb/source/Utility/XcodeSDK.cpp

if (triple.getEnvironment() == Triple::Simulator)
       return XcodeSDK::WatchSimulator;
     return XcodeSDK::watchOS;
   case Triple::Linux:
     return XcodeSDK::Linux;
   default:
     return XcodeSDK::unknown;
   }
 }
+
+std::string XcodeSDK::FindXcodeContentsDirectoryInPath(llvm::StringRef path) {
+  auto begin = llvm::sys::path::begin(path);
+  auto end = llvm::sys::path::end(path);
+
+  // Iterate over the path components until we find something that ends with
+  // .app. If the next component is Contents then we've found the Contents
+  // directory.
+  for (auto it = begin; it != end; ++it) {
+    if (it->endswith(".app")) {
+      auto next = it;
+      if (++next != end && *next == "Contents") {
+        llvm::SmallString<128> buffer;
+        llvm::sys::path::append(buffer, begin, ++next,
+                                llvm::sys::path::Style::posix);
+        return buffer.str().str();
+      }
+    }
+  }
+
+  return {};
+}

lldb/unittests/Platform/PlatformDarwinTest.cpp

 #include <tuple>
 
 using namespace lldb;
 using namespace lldb_private;
 
 struct PlatformDarwinTester : public PlatformDarwin {
 public:
   using PlatformDarwin::FindComponentInPath;
-  using PlatformDarwin::FindXcodeContentsDirectoryInPath;
 };
 
 TEST(PlatformDarwinTest, TestParseVersionBuildDir) {
   llvm::VersionTuple V;
   llvm::StringRef D;
 
   std::tie(V, D) = PlatformDarwin::ParseVersionBuildDir("1.2.3 (test1)");
   EXPECT_EQ(llvm::VersionTuple(1, 2, 3), V);
TEST(PlatformDarwinTest, TestParseVersionBuildDir) {
   std::tie(V, D) = PlatformDarwin::ParseVersionBuildDir("2.3.4 test");
   EXPECT_EQ(llvm::VersionTuple(2, 3, 4), V);
   EXPECT_EQ("", D);
 
   std::tie(V, D) = PlatformDarwin::ParseVersionBuildDir("3.4.5");
   EXPECT_EQ(llvm::VersionTuple(3, 4, 5), V);
 }
 
-TEST(PlatformDarwinTest, FindXcodeContentsDirectoryInPath) {
-  std::string standard =
-      "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/"
-      "Developer/SDKs/MacOSX.sdk";
-  EXPECT_EQ("/Applications/Xcode.app/Contents",
-            PlatformDarwinTester::FindXcodeContentsDirectoryInPath(standard));
-
-  std::string standard_version =
-      "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/"
-      "Developer/SDKs/MacOSX10.15.sdk";
-  EXPECT_EQ(
-      "/Applications/Xcode.app/Contents",
-      PlatformDarwinTester::FindXcodeContentsDirectoryInPath(standard_version));
-
-  std::string beta = "/Applications/Xcode-beta.app/Contents/Developer/"
-                     "Platforms/MacOSX.platform/"
-                     "Developer/SDKs/MacOSX10.15.sdk";
-  EXPECT_EQ("/Applications/Xcode-beta.app/Contents",
-            PlatformDarwinTester::FindXcodeContentsDirectoryInPath(beta));
-
-  std::string no_app =
-      "/Applications/Xcode/Contents/Developer/Platforms/MacOSX.platform/"
-      "Developer/SDKs/MacOSX10.15.sdk";
-  EXPECT_EQ("", PlatformDarwinTester::FindXcodeContentsDirectoryInPath(no_app));
-
-  std::string no_contents =
-      "/Applications/Xcode.app/Developer/Platforms/MacOSX.platform/"
-      "Developer/SDKs/MacOSX10.15.sdk";
-  EXPECT_EQ(
-      "", PlatformDarwinTester::FindXcodeContentsDirectoryInPath(no_contents));
-
-  std::string no_capitalization =
-      "/Applications/Xcode.app/contents/Developer/Platforms/MacOSX.platform/"
-      "Developer/SDKs/MacOSX10.15.sdk";
-  EXPECT_EQ("", PlatformDarwinTester::FindXcodeContentsDirectoryInPath(
-                    no_capitalization));
-}
-
 TEST(PlatformDarwinTest, FindComponentInPath) {
   EXPECT_EQ("/path/to/foo",
             PlatformDarwinTester::FindComponentInPath("/path/to/foo/", "foo"));
 
   EXPECT_EQ("/path/to/foo",
             PlatformDarwinTester::FindComponentInPath("/path/to/foo", "foo"));
 
   EXPECT_EQ("/path/to/foobar", PlatformDarwinTester::FindComponentInPath(
                                    "/path/to/foobar", "foo"));
 
   EXPECT_EQ("/path/to/foobar", PlatformDarwinTester::FindComponentInPath(
                                    "/path/to/foobar", "bar"));
 
   EXPECT_EQ("",
             PlatformDarwinTester::FindComponentInPath("/path/to/foo", "bar"));
 }

lldb/unittests/Utility/XcodeSDKTest.cpp

EXPECT_EQ(XcodeSDK::GetSDKTypeForTriple(
             XcodeSDK::Type::WatchSimulator);
   EXPECT_EQ(XcodeSDK::GetSDKTypeForTriple(llvm::Triple("arm64-apple-watchos")),
             XcodeSDK::Type::watchOS);
   EXPECT_EQ(XcodeSDK::GetSDKTypeForTriple(llvm::Triple("x86_64-unknown-linux")),
             XcodeSDK::Type::Linux);
   EXPECT_EQ(XcodeSDK::GetSDKTypeForTriple(llvm::Triple("i386-unknown-netbsd")),
             XcodeSDK::Type::unknown);
 }
+
+TEST(XcodeSDKTest, FindXcodeContentsDirectoryInPath) {
+  std::string standard =
+      "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/"
+      "Developer/SDKs/MacOSX.sdk";
+  EXPECT_EQ("/Applications/Xcode.app/Contents",
+            XcodeSDK::FindXcodeContentsDirectoryInPath(standard));
+
+  std::string standard_version =
+      "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/"
+      "Developer/SDKs/MacOSX10.15.sdk";
+  EXPECT_EQ("/Applications/Xcode.app/Contents",
+            XcodeSDK::FindXcodeContentsDirectoryInPath(standard_version));
+
+  std::string beta = "/Applications/Xcode-beta.app/Contents/Developer/"
+                     "Platforms/MacOSX.platform/"
+                     "Developer/SDKs/MacOSX10.15.sdk";
+  EXPECT_EQ("/Applications/Xcode-beta.app/Contents",
+            XcodeSDK::FindXcodeContentsDirectoryInPath(beta));
+
+  std::string no_app =
+      "/Applications/Xcode/Contents/Developer/Platforms/MacOSX.platform/"
+      "Developer/SDKs/MacOSX10.15.sdk";
+  EXPECT_EQ("", XcodeSDK::FindXcodeContentsDirectoryInPath(no_app));
+
+  std::string no_contents =
+      "/Applications/Xcode.app/Developer/Platforms/MacOSX.platform/"
+      "Developer/SDKs/MacOSX10.15.sdk";
+  EXPECT_EQ("", XcodeSDK::FindXcodeContentsDirectoryInPath(no_contents));
+
+  std::string no_capitalization =
+      "/Applications/Xcode.app/contents/Developer/Platforms/MacOSX.platform/"
+      "Developer/SDKs/MacOSX10.15.sdk";
+  EXPECT_EQ("", XcodeSDK::FindXcodeContentsDirectoryInPath(no_capitalization));
+}