HostInfoMacOS: Add a utility function for finding an SDK-specific tool

[aprantl]

Summary

This is an API needed by swift-lldb.

[JDevlieghere]

LGTM

lldb/unittests/Host/HostInfoTest.cpp

90

LOL

[mib]

lldb/unittests/Host/HostInfoTest.cpp

90

^^

lldb/include/lldb/Host/HostInfoBase.h

 
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/UUID.h"
 #include "lldb/Utility/UserIDResolver.h"
 #include "lldb/Utility/XcodeSDK.h"
 #include "lldb/lldb-enumerations.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Errc.h"
 
 #include <cstdint>
 
 #include <optional>
 #include <string>
 
 namespace lldb_private {
 
public:
   static FileSpec GetXcodeContentsDirectory() { return {}; }
   static FileSpec GetXcodeDeveloperDirectory() { return {}; }
   
   /// Return the directory containing a specific Xcode SDK.
   static llvm::Expected<llvm::StringRef> GetXcodeSDKPath(XcodeSDK sdk) {
     return "";
   }
 
+  /// Return the path to a specific tool in the specified Xcode SDK.
+  static llvm::Expected<llvm::StringRef> FindSDKTool(XcodeSDK sdk,
+                                                     llvm::StringRef tool) {
+    return llvm::errorCodeToError(llvm::errc::no_such_file_or_directory);
+  }
+
   /// Return information about module \p image_name if it is loaded in
   /// the current process's address space.
   static SharedCacheImageInfo
   GetSharedCacheImageInfo(llvm::StringRef image_name) {
     return {};
   }
 
   /// Returns the distribution id of the host

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

 //===-- HostInfoMacOSX.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_HOST_MACOSX_HOSTINFOMACOSX_H
 #define LLDB_HOST_MACOSX_HOSTINFOMACOSX_H
 
 #include "lldb/Host/posix/HostInfoPosix.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/XcodeSDK.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/VersionTuple.h"
 #include <optional>
 
 namespace lldb_private {
 
 class ArchSpec;
 
 class HostInfoMacOSX : public HostInfoPosix {
   friend class HostInfoBase;
 
 public:
   static llvm::VersionTuple GetOSVersion();
   static llvm::VersionTuple GetMacCatalystVersion();
   static std::optional<std::string> GetOSBuildString();
   static FileSpec GetProgramFileSpec();
   static FileSpec GetXcodeContentsDirectory();
   static FileSpec GetXcodeDeveloperDirectory();
 
-  /// Query xcrun to find an Xcode SDK directory.
   static llvm::Expected<llvm::StringRef> GetXcodeSDKPath(XcodeSDK sdk);
+  static llvm::Expected<llvm::StringRef> FindSDKTool(XcodeSDK sdk,
+                                                     llvm::StringRef tool);
 
   /// Shared cache utilities
   static SharedCacheImageInfo
   GetSharedCacheImageInfo(llvm::StringRef image_name);
 
 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/source/Host/macosx/objcxx/HostInfoMacOSX.mm

static llvm::Expected<std::string> GetXcodeSDK(XcodeSDK sdk) {
   if (!FileSystem::Instance().Exists(path)) {
     LLDB_LOGF(log, "SDK returned by xcrun doesn't exist");
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "SDK returned by xcrun doesn't exist");
   }
   return path;
 }
 
-llvm::Expected<llvm::StringRef> HostInfoMacOSX::GetXcodeSDKPath(XcodeSDK sdk) {
-  struct ErrorOrPath {
-    std::string str;
-    bool is_error;
-  };
-  static llvm::StringMap<ErrorOrPath> g_sdk_path;
-  static std::mutex g_sdk_path_mutex;
+namespace {
+} // namespace
 
-  std::lock_guard<std::mutex> guard(g_sdk_path_mutex);
+static llvm::Expected<llvm::StringRef>
+find_cached_path(llvm::StringMap<ErrorOrPath> &cache, std::mutex &mutex,
+                 llvm::StringRef key,
+                 std::function<llvm::Expected<std::string>(void)> compute) {
+  std::lock_guard<std::mutex> guard(mutex);
   LLDB_SCOPED_TIMER();
 
-  auto key = sdk.GetString();
-  auto it = g_sdk_path.find(key);
-  if (it != g_sdk_path.end()) {
+  auto it = cache.find(key);
+  if (it != cache.end()) {
     if (it->second.is_error)
       return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                      it->second.str);
-    else
-      return it->second.str;
   }
-  auto path_or_err = GetXcodeSDK(sdk);
+  auto path_or_err = compute();
   if (!path_or_err) {
     std::string error = toString(path_or_err.takeError());
-    g_sdk_path.insert({key, {error, true}});
+    cache.insert({key, {error, true}});
     return llvm::createStringError(llvm::inconvertibleErrorCode(), error);
   }
-  auto it_new = g_sdk_path.insert({key, {*path_or_err, false}});
+  auto it_new = cache.insert({key, {*path_or_err, false}});
   return it_new.first->second.str;
 }
 
+llvm::Expected<llvm::StringRef> HostInfoMacOSX::GetXcodeSDKPath(XcodeSDK sdk) {
+  static llvm::StringMap<ErrorOrPath> g_sdk_path;
+  static std::mutex g_sdk_path_mutex;
+  auto key = sdk.GetString();
+  return find_cached_path(g_sdk_path, g_sdk_path_mutex, key, [&](){
+    return GetXcodeSDK(sdk);
+  });
+}
+
+llvm::Expected<llvm::StringRef>
+HostInfoMacOSX::FindSDKTool(XcodeSDK sdk, llvm::StringRef tool) {
+  static llvm::StringMap<ErrorOrPath> g_tool_path;
+  static std::mutex g_tool_path_mutex;
+  std::string key;
+  llvm::raw_string_ostream(key) << sdk.GetString() << ":" << tool;
+  return find_cached_path(
+      g_tool_path, g_tool_path_mutex, key,
+      [&]() -> llvm::Expected<std::string> {
+        std::string sdk_name = XcodeSDK::GetCanonicalName(sdk.Parse());
+        if (sdk_name.empty())
+          return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                         "Unrecognized SDK type: " +
+                                             sdk.GetString());
+        llvm::SmallVector<llvm::StringRef, 2> find = {"-find", tool};
+        return xcrun(sdk_name, find);
+      });
+}
+
 namespace {
 struct dyld_shared_cache_dylib_text_info {
   uint64_t version; // current version 1
   // following fields all exist in version 1
   uint64_t loadAddressUnslid;
   uint64_t textSegmentSize;
   uuid_t dylibUuid;
   const char *path; // pointer invalid at end of iterations

lldb/unittests/Host/HostInfoTest.cpp

auto get_sdk = [](std::string sdk, bool error = false) -> llvm::StringRef {
     return {};
   };
   EXPECT_FALSE(get_sdk("MacOSX.sdk").empty());
   // These are expected to fall back to an available version.
   EXPECT_FALSE(get_sdk("MacOSX9999.sdk").empty());
   // This is expected to fail.
   EXPECT_TRUE(get_sdk("CeciNestPasUnOS.sdk", true).empty());
 }
+
+TEST_F(HostInfoTest, FindSDKTool) {
+  auto find_tool = [](std::string sdk, llvm::StringRef tool,
+                      bool error = false) -> llvm::StringRef {
+    auto sdk_path_or_err =
+        HostInfo::FindSDKTool(XcodeSDK(std::move(sdk)), tool);
+    if (!error) {
+      EXPECT_TRUE((bool)sdk_path_or_err);
+      return *sdk_path_or_err;
+    }
+    EXPECT_FALSE((bool)sdk_path_or_err);
+    llvm::consumeError(sdk_path_or_err.takeError());
+    return {};
+  };
+  EXPECT_FALSE(find_tool("MacOSX.sdk", "clang").empty());
+  EXPECT_TRUE(find_tool("MacOSX.sdk", "CeciNestPasUnOutil").empty());
+}
 #endif
 
 TEST(HostInfoTestInitialization, InitTwice) {
   llvm::VersionTuple Version;
   {
     SubsystemRAII<FileSystem, HostInfo> subsystems;
     Version = HostInfo::GetOSVersion();
   }
 
   {
     SubsystemRAII<FileSystem, HostInfo> subsystems;
     EXPECT_EQ(Version, HostInfo::GetOSVersion());
   }
 }