Remove dependency from Host to clang

[zturner]

Summary

The idea is to move the discovery of the clang resource directory into a more appropriate place, such as the clang expression parser. By continuing with this pattern we can isolate all clang interactions to the clang expression parser. There is a little edge case here in that there is a public enumeration which is used in conjunction with SBHostOS to get a generic LLDB directory. So as not to break the public API, I just special case this particular value of the enumeration and don't pass it through to Host, rather passing it through to the clang expression parser plugin.

I'm not able to test this on OSX, so I expect there may be some easy to fix up compilation errors. Davide, would you mind helping me out with that?

[labath]

+Adrian.

I remember looking at the path computation code a while ago (I think it was in the context of python though) and concluding that something like this would be needed. Overall the patch seems fine to me, but I want to make sure it gets enough visibility, so I've added Adrian as he was working on this code recently.

I think that a nice cleanup here would be to replace the private HostInfoBase::GetLLDBPath function with a sequence of functions for accessing individual path types (so basically do s/HostInfo::GetLLDBPath(ePathTypeXXX/HostInfo::GetXXXPath(/). All the private users of this function are calling it with a fixed enum value anyway, so this would be a slight simplification on their side anyway. Then the only place dealing with this enum would be the SBHostOS class, which could to the dispatch on the full set of enum values. This would allow us to avoid having a function which does not make sense for certain enum values (which is even more important, as sooner or later, we will need to do a similar patch for ePathTypePythonDir).

lldb/source/Plugins/ExpressionParser/Clang/ClangHost.h

17–20

If I understand this correctly, this function is only in the header because of testing (and it's ifdef APPLE because the tests are also ifdef APPLE). If that is the case could we add a comment explaining that?

lldb/unittests/Host/HostInfoTest.cpp

53–101

I guess this test should move to mirror the change in code being tested (unittests/Expression/Clang ?).

[aprantl]

Generally I'm fine with improving the layering. I just wanted to point out that the Swift language plugin also wants know the clang resource directory (it calls HostInfo::GetLLDBPath(ePathTypeClangDir, clang_dir_spec)) since Swift embeds Clang. That said it makes no sense to build an LLDB that supports Swift and not also support lang, so moving things into the Clang plugin should be fine.

[mclow.lists]

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangHost.cpp

77 ↗

(On Diff #149805)

This line fails to build on my old Mac Pro (Mac OS X 10.11, apple-clang-8), complaining that std::next requires a forward iterator, and rev_it is not one.

changing this code to:

auto parent = rev_it;
std::advance(parent, 1);

fixes the compile error.

Note that these are the most recent OS and tools for this computer.

lldb/include/lldb/Host/HostInfoBase.h

 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);
   static bool ComputeTempFileBaseDirectory(FileSpec &file_spec);
   static bool ComputeHeaderDirectory(FileSpec &file_spec);
   static bool ComputeSystemPluginsDirectory(FileSpec &file_spec);
-  static bool ComputeClangDirectory(FileSpec &file_spec);
   static bool ComputeUserPluginsDirectory(FileSpec &file_spec);
 
   static void ComputeHostArchitectureSupport(ArchSpec &arch_32,
                                              ArchSpec &arch_64);
 };
 }
 
 #endif

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

public:
   static FileSpec GetProgramFileSpec();
 
 protected:
   static bool ComputeSupportExeDirectory(FileSpec &file_spec);
   static void ComputeHostArchitectureSupport(ArchSpec &arch_32,
                                              ArchSpec &arch_64);
   static bool ComputeHeaderDirectory(FileSpec &file_spec);
   static bool ComputePythonDirectory(FileSpec &file_spec);
-  static bool ComputeClangDirectory(FileSpec &file_spec);
-  static bool ComputeClangDirectory(FileSpec &lldb_shlib_spec,
-                                    FileSpec &file_spec, bool verify);
   static bool ComputeSystemPluginsDirectory(FileSpec &file_spec);
   static bool ComputeUserPluginsDirectory(FileSpec &file_spec);
 };
 }
 
 #endif

lldb/include/lldb/Host/posix/HostInfoPosix.h

public:
   static uint32_t GetGroupID();
   static uint32_t GetEffectiveUserID();
   static uint32_t GetEffectiveGroupID();
 
   static FileSpec GetDefaultShell();
 
   static bool GetEnvironmentVar(const std::string &var_name, std::string &var);
 
+  static bool ComputePathRelativeToLibrary(FileSpec &file_spec,
+                                           llvm::StringRef dir);
+
  protected:
   static bool ComputeSupportExeDirectory(FileSpec &file_spec);
   static bool ComputeHeaderDirectory(FileSpec &file_spec);
   static bool ComputePythonDirectory(FileSpec &file_spec);
-  static bool ComputeClangDirectory(FileSpec &file_spec);
-  static bool ComputePathRelativeToLibrary(FileSpec &file_spec,
-                                           llvm::StringRef dir);
 };
 }
 
 #endif

lldb/source/API/SBHostOS.cpp

 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/HostNativeThread.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 
+#include "Plugins/ExpressionParser/Clang/ClangHost.h"
+
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Path.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBFileSpec SBHostOS::GetProgramFileSpec() {
   SBFileSpec sb_filespec;
   sb_filespec.SetFileSpec(HostInfo::GetProgramFileSpec());
   return sb_filespec;
 }
 
 SBFileSpec SBHostOS::GetLLDBPythonPath() {
   SBFileSpec sb_lldb_python_filespec;
   FileSpec lldb_python_spec;
   if (HostInfo::GetLLDBPath(ePathTypePythonDir, lldb_python_spec)) {
     sb_lldb_python_filespec.SetFileSpec(lldb_python_spec);
   }
   return sb_lldb_python_filespec;
 }
 
 SBFileSpec SBHostOS::GetLLDBPath(lldb::PathType path_type) {
   SBFileSpec sb_fspec;
   FileSpec fspec;
-  if (HostInfo::GetLLDBPath(path_type, fspec))
-    sb_fspec.SetFileSpec(fspec);
+  bool Success = true;
+  if (path_type == ePathTypeClangDir)
+    fspec = GetClangResourceDir();
+  else
+    Success = HostInfo::GetLLDBPath(path_type, fspec);
+  if (Success) sb_fspec.SetFileSpec(fspec);
   return sb_fspec;
 }
 
 SBFileSpec SBHostOS::GetUserHomeDirectory() {
   SBFileSpec sb_fspec;
 
   llvm::SmallString<64> home_dir_path;
   llvm::sys::path::home_directory(home_dir_path);

lldb/source/Host/common/HostInfoBase.cpp

return llvm::StringSwitch<llvm::Optional<ArchitectureKind>>(kind)
       .Case(LLDB_ARCH_DEFAULT_32BIT, eArchKind32)
       .Case(LLDB_ARCH_DEFAULT_64BIT, eArchKind64)
       .Default(llvm::None);
 }
 
 bool HostInfoBase::GetLLDBPath(lldb::PathType type, FileSpec &file_spec) {
   file_spec.Clear();
 
+  assert(type != lldb::ePathTypeClangDir);
+
 #if defined(LLDB_DISABLE_PYTHON)
   if (type == lldb::ePathTypePythonDir)
     return false;
 #endif
 
   FileSpec *result = nullptr;
   switch (type) {
   case lldb::ePathTypeLLDBShlibDir: {
llvm::call_once(g_once_flag, []() {
       Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
       if (log)
         log->Printf("HostInfoBase::GetLLDBPath(ePathTypePythonDir) => '%s'",
                     g_fields->m_lldb_python_dir.GetPath().c_str());
     });
     if (success)
       result = &g_fields->m_lldb_python_dir;
   } break;
-  case lldb::ePathTypeClangDir: {
-    static llvm::once_flag g_once_flag;
-    static bool success = false;
-    llvm::call_once(g_once_flag, []() {
-      success =
-          HostInfo::ComputeClangDirectory(g_fields->m_lldb_clang_resource_dir);
-      Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
-      if (log)
-        log->Printf(
-            "HostInfoBase::GetLLDBPath(ePathTypeClangResourceDir) => '%s'",
-            g_fields->m_lldb_clang_resource_dir.GetPath().c_str());
-    });
-    if (success)
-      result = &g_fields->m_lldb_clang_resource_dir;
-  } break;
   case lldb::ePathTypeLLDBSystemPlugins: {
     static llvm::once_flag g_once_flag;
     static bool success = false;
     llvm::call_once(g_once_flag, []() {
       success = HostInfo::ComputeSystemPluginsDirectory(
           g_fields->m_lldb_system_plugin_dir);
       Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
       if (log)
llvm::call_once(g_once_flag, []() {
       if (log)
         log->Printf("HostInfoBase::GetLLDBPath("
                     "ePathTypeGlobalLLDBTempSystemDir) => '%s'",
                     g_fields->m_lldb_global_tmp_dir.GetPath().c_str());
     });
     if (success)
       result = &g_fields->m_lldb_global_tmp_dir;
   } break;
+  default:
+    llvm_unreachable("Unreachable!");
   }
 
   if (!result)
     return false;
   file_spec = *result;
   return true;
 }
 

 }
 
 bool HostInfoBase::ComputeSystemPluginsDirectory(FileSpec &file_spec) {
   // TODO(zturner): Figure out how to compute the system plugins directory for
   // all platforms.
   return false;
 }
 
-bool HostInfoBase::ComputeClangDirectory(FileSpec &file_spec) { return false; }
-
 bool HostInfoBase::ComputeUserPluginsDirectory(FileSpec &file_spec) {
   // TODO(zturner): Figure out how to compute the user plugins directory for
   // all platforms.
   return false;
 }
 
 void HostInfoBase::ComputeHostArchitectureSupport(ArchSpec &arch_32,
                                                   ArchSpec &arch_64) {

lldb/source/Host/macosx/HostInfoMacOSX.mm

#ifndef LLDB_DISABLE_PYTHON
   file_spec.GetDirectory().SetString(
       llvm::StringRef(raw_path.c_str(), raw_path.size()));
   return true;
 #else
   return false;
 #endif
 }
 
-static bool VerifyClangPath(const llvm::Twine &clang_path) {
-  if (llvm::sys::fs::is_directory(clang_path))
-    return true;
-  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
-  if (log)
-    log->Printf("HostInfoMacOSX::ComputeClangDirectory(): "
-                "failed to stat clang resource directory at \"%s\"",
-                clang_path.str().c_str());
-  return false;
-}
-
-bool HostInfoMacOSX::ComputeClangDirectory(FileSpec &file_spec) {
-  FileSpec lldb_file_spec;
-  if (!GetLLDBPath(lldb::ePathTypeLLDBShlibDir, lldb_file_spec))
-    return false;
-  return ComputeClangDirectory(lldb_file_spec, file_spec, true);
-}
-
-bool HostInfoMacOSX::ComputeClangDirectory(FileSpec &lldb_shlib_spec,
-                                           FileSpec &file_spec, bool verify) {
-  std::string raw_path = lldb_shlib_spec.GetPath();
-
-  auto rev_it = llvm::sys::path::rbegin(raw_path);
-  auto r_end = llvm::sys::path::rend(raw_path);
-
-  // Check for a Posix-style build of LLDB.
-  while (rev_it != r_end) {
-    if (*rev_it == "LLDB.framework")
-      break;
-    ++rev_it;
-  }
-
-  if (rev_it == r_end)
-    return HostInfoPosix::ComputeClangDirectory(file_spec);
-
-  // Inside Xcode and in Xcode toolchains LLDB is always in lockstep
-  // with the Swift compiler, so it can reuse its Clang resource
-  // directory. This allows LLDB and the Swift compiler to share the
-  // same Clang module cache.
-  llvm::SmallString<256> clang_path;
-  const char *swift_clang_resource_dir = "usr/lib/swift/clang";
-  auto parent = std::next(rev_it);
-  if (parent != r_end && *parent == "SharedFrameworks") {
-    // This is the top-level LLDB in the Xcode.app bundle.
-    // E.g., "Xcode.app/Contents/SharedFrameworks/LLDB.framework/Versions/A"
-    raw_path.resize(parent - r_end);
-    llvm::sys::path::append(clang_path, raw_path,
-                            "Developer/Toolchains/XcodeDefault.xctoolchain",
-                            swift_clang_resource_dir);
-    if (!verify || VerifyClangPath(clang_path)) {
-      file_spec.SetFile(clang_path.c_str(), true);
-      return true;
-    }
-  } else if (parent != r_end && *parent == "PrivateFrameworks" &&
-             std::distance(parent, r_end) > 2) {
-    ++parent;
-    ++parent;
-    if (*parent == "System") {
-      // This is LLDB inside an Xcode toolchain.
-      // E.g., "Xcode.app/Contents/Developer/Toolchains/"               \
-      //       "My.xctoolchain/System/Library/PrivateFrameworks/LLDB.framework"
-      raw_path.resize(parent - r_end);
-      llvm::sys::path::append(clang_path, raw_path, swift_clang_resource_dir);
-      if (!verify || VerifyClangPath(clang_path)) {
-        file_spec.SetFile(clang_path.c_str(), true);
-        return true;
-      }
-      raw_path = lldb_shlib_spec.GetPath();
-    }
-    raw_path.resize(rev_it - r_end);
-  } else {
-    raw_path.resize(rev_it - r_end);
-  }
-
-  // Fall back to the Clang resource directory inside the framework.
-  raw_path.append("LLDB.framework/Resources/Clang");
-  file_spec.SetFile(raw_path.c_str(), true);
-  return true;
-}
-
 bool HostInfoMacOSX::ComputeSystemPluginsDirectory(FileSpec &file_spec) {
   FileSpec lldb_file_spec;
   if (!GetLLDBPath(lldb::ePathTypeLLDBShlibDir, lldb_file_spec))
     return false;
 
   std::string raw_path = lldb_file_spec.GetPath();
 
   size_t framework_pos = raw_path.find("LLDB.framework");

lldb/source/Host/posix/HostInfoPosix.cpp

 //===-- HostInfoPosix.cpp ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #if !defined(LLDB_DISABLE_PYTHON)
 #include "Plugins/ScriptInterpreter/Python/lldb-python.h"
 #endif
 
 #include "lldb/Host/posix/HostInfoPosix.h"
 #include "lldb/Utility/Log.h"
 
-#include "clang/Basic/Version.h"
-#include "clang/Config/config.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <grp.h>
 #include <limits.h>
 #include <mutex>
bool HostInfoPosix::ComputePathRelativeToLibrary(FileSpec &file_spec,
   file_spec.GetDirectory().SetString(raw_path);
   return (bool)file_spec.GetDirectory();
 }
 
 bool HostInfoPosix::ComputeSupportExeDirectory(FileSpec &file_spec) {
   return ComputePathRelativeToLibrary(file_spec, "/bin");
 }
 
-bool HostInfoPosix::ComputeClangDirectory(FileSpec &file_spec) {
-  return ComputePathRelativeToLibrary(
-      file_spec, (llvm::Twine("/lib") + CLANG_LIBDIR_SUFFIX + "/clang/" +
-                  CLANG_VERSION_STRING)
-                     .str());
-}
-
 bool HostInfoPosix::ComputeHeaderDirectory(FileSpec &file_spec) {
   FileSpec temp_file("/opt/local/include/lldb", false);
   file_spec.GetDirectory().SetCString(temp_file.GetPath().c_str());
   return true;
 }
 
 bool HostInfoPosix::ComputePythonDirectory(FileSpec &file_spec) {
 #ifndef LLDB_DISABLE_PYTHON

lldb/source/Plugins/ExpressionParser/Clang/CMakeLists.txt

 if(NOT LLDB_BUILT_STANDALONE)
   set(tablegen_deps intrinsics_gen)
 endif()
 
 add_lldb_library(lldbPluginExpressionParserClang PLUGIN
   ASTDumper.cpp
   ASTResultSynthesizer.cpp
   ASTStructExtractor.cpp
   ClangASTSource.cpp
   ClangExpressionDeclMap.cpp
   ClangExpressionParser.cpp
   ClangExpressionVariable.cpp
   ClangFunctionCaller.cpp
+  ClangHost.cpp
   ClangModulesDeclVendor.cpp
   ClangPersistentVariables.cpp
   ClangUserExpression.cpp
   ClangUtilityFunction.cpp
   IRForTarget.cpp
 
   DEPENDS
   ${tablegen_deps}

lldb/source/Plugins/ExpressionParser/Clang/ClangHost.h

+//===-- ClangHost.h ---------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGHOST_H
+#define LLDB_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGHOST_H
+
+namespace lldb_private {
+
+class FileSpec;
+
+#if defined(__APPLE__)
+bool ComputeClangDirectory(FileSpec &lldb_shlib_spec, FileSpec &file_spec,
+                           bool verify);
+#endif
+
+FileSpec GetClangResourceDir();
+
+}  // namespace lldb_private
+
+#endif

lldb/source/Plugins/ExpressionParser/Clang/ClangHost.cpp

+//===-- ClangHost.cpp -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ClangHost.h"
+
+#include "clang/Basic/Version.h"
+#include "clang/Config/config.h"
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Threading.h"
+
+// Project includes
+#if !defined(_WIN32)
+#include "lldb/Host/posix/HostInfoPosix.h"
+#endif
+#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/Log.h"
+
+#include <string>
+
+using namespace lldb_private;
+
+#if defined(_WIN32)
+static bool ComputeClangDirectory(FileSpec &file_spec) { return false; }
+#else
+static bool DefaultComputeClangDirectory(FileSpec &file_spec) {
+  return HostInfoPosix::ComputePathRelativeToLibrary(
+      file_spec, (llvm::Twine("/lib") + CLANG_LIBDIR_SUFFIX + "/clang/" +
+                  CLANG_VERSION_STRING)
+                     .str());
+}
+
+#if defined(__APPLE__)
+
+static bool VerifyClangPath(const llvm::Twine &clang_path) {
+  if (llvm::sys::fs::is_directory(clang_path)) return true;
+  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
+  if (log)
+    log->Printf(
+        "VerifyClangPath(): "
+        "failed to stat clang resource directory at \"%s\"",
+        clang_path.str().c_str());
+  return false;
+}
+
+bool lldb_private::ComputeClangDirectory(FileSpec &lldb_shlib_spec,
+                                         FileSpec &file_spec, bool verify) {
+  std::string raw_path = lldb_shlib_spec.GetPath();
+
+  auto rev_it = llvm::sys::path::rbegin(raw_path);
+  auto r_end = llvm::sys::path::rend(raw_path);
+
+  // Check for a Posix-style build of LLDB.
+  while (rev_it != r_end) {
+    if (*rev_it == "LLDB.framework") break;
+    ++rev_it;
+  }
+
+  if (rev_it == r_end) return DefaultComputeClangDirectory(file_spec);
+
+  // Inside Xcode and in Xcode toolchains LLDB is always in lockstep
+  // with the Swift compiler, so it can reuse its Clang resource
+  // directory. This allows LLDB and the Swift compiler to share the
+  // same Clang module cache.
+  llvm::SmallString<256> clang_path;
+  const char *swift_clang_resource_dir = "usr/lib/swift/clang";
+  auto parent = std::next(rev_it);
+  if (parent != r_end && *parent == "SharedFrameworks") {
+    // This is the top-level LLDB in the Xcode.app bundle.
+    // E.g., "Xcode.app/Contents/SharedFrameworks/LLDB.framework/Versions/A"
+    raw_path.resize(parent - r_end);
+    llvm::sys::path::append(clang_path, raw_path,
+                            "Developer/Toolchains/XcodeDefault.xctoolchain",
+                            swift_clang_resource_dir);
+    if (!verify || VerifyClangPath(clang_path)) {
+      file_spec.SetFile(clang_path.c_str(), true);
+      return true;
+    }
+  } else if (parent != r_end && *parent == "PrivateFrameworks" &&
+             std::distance(parent, r_end) > 2) {
+    ++parent;
+    ++parent;
+    if (*parent == "System") {
+      // This is LLDB inside an Xcode toolchain.
+      // E.g., "Xcode.app/Contents/Developer/Toolchains/"               \
+      //       "My.xctoolchain/System/Library/PrivateFrameworks/LLDB.framework"
+      raw_path.resize(parent - r_end);
+      llvm::sys::path::append(clang_path, raw_path, swift_clang_resource_dir);
+      if (!verify || VerifyClangPath(clang_path)) {
+        file_spec.SetFile(clang_path.c_str(), true);
+        return true;
+      }
+      raw_path = lldb_shlib_spec.GetPath();
+    }
+    raw_path.resize(rev_it - r_end);
+  } else {
+    raw_path.resize(rev_it - r_end);
+  }
+
+  // Fall back to the Clang resource directory inside the framework.
+  raw_path.append("LLDB.framework/Resources/Clang");
+  file_spec.SetFile(raw_path.c_str(), true);
+  return true;
+}
+
+static bool ComputeClangDirectory(FileSpec &file_spec) {
+  FileSpec lldb_file_spec;
+  if (!HostInfo::GetLLDBPath(lldb::ePathTypeLLDBShlibDir, lldb_file_spec))
+    return false;
+  return ComputeClangDirectory(lldb_file_spec, file_spec, true);
+}
+#else   // __APPLE__
+
+// All non-Apple posix systems.
+static bool ComputeClangDirectory(FileSpec &file_spec) {
+  return DefaultComputeClangDirectory(file_spec);
+}
+#endif  // __APPLE__
+#endif  // _WIN32
+
+FileSpec lldb_private::GetClangResourceDir() {
+  static FileSpec g_cached_resource_dir;
+  static llvm::once_flag g_once_flag;
+  llvm::call_once(g_once_flag, []() {
+    ::ComputeClangDirectory(g_cached_resource_dir);
+    Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
+    if (log)
+      log->Printf("GetClangResourceDir() => '%s'",
+                  g_cached_resource_dir.GetPath().c_str());
+  });
+  return g_cached_resource_dir;
+}

lldb/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

 #include "clang/Parse/Parser.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Serialization/ASTReader.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Threading.h"
 
 // Project includes
+#include "ClangHost.h"
 #include "ClangModulesDeclVendor.h"
 
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/FileSpec.h"
default:
       error_stream.PutChar('\n');
       break;
     case clang::DiagnosticsEngine::Level::Ignored:
       break;
     }
   }
 }
 
-static FileSpec GetResourceDir() {
-  static FileSpec g_cached_resource_dir;
-
-  static llvm::once_flag g_once_flag;
-
-  llvm::call_once(g_once_flag, []() {
-    HostInfo::GetLLDBPath(lldb::ePathTypeClangDir, g_cached_resource_dir);
-  });
-
-  return g_cached_resource_dir;
-}
-
 ClangModulesDeclVendor::ClangModulesDeclVendor() {}
 
 ClangModulesDeclVendor::~ClangModulesDeclVendor() {}
 
 ClangModulesDeclVendorImpl::ClangModulesDeclVendorImpl(
     llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diagnostics_engine,
     std::shared_ptr<clang::CompilerInvocation> compiler_invocation,
     std::unique_ptr<clang::CompilerInstance> compiler_instance,
for (size_t spi = 0, spe = module_search_paths.GetSize(); spi < spe; ++spi) {
 
     std::string search_path_argument = "-I";
     search_path_argument.append(search_path.GetPath());
 
     compiler_invocation_arguments.push_back(search_path_argument);
   }
 
   {
-    FileSpec clang_resource_dir = GetResourceDir();
+    FileSpec clang_resource_dir = GetClangResourceDir();
 
     if (llvm::sys::fs::is_directory(clang_resource_dir.GetPath())) {
       compiler_invocation_arguments.push_back("-resource-dir");
       compiler_invocation_arguments.push_back(clang_resource_dir.GetPath());
     }
   }
 
   llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diagnostics_engine =

lldb/unittests/Host/HostInfoTest.cpp

TEST_F(HostInfoTest, GetAugmentedArchSpec) {
   EXPECT_EQ(spec.GetTriple().getEnvironment(), triple.getEnvironment());
 
   // Test LLDB_ARCH_DEFAULT
   EXPECT_EQ(HostInfo::GetAugmentedArchSpec(LLDB_ARCH_DEFAULT).GetTriple(),
             HostInfo::GetArchitecture(HostInfo::eArchKindDefault).GetTriple());
 }
 
 
 #ifdef __APPLE__
 
-struct HostInfoMacOSXTest : public HostInfoMacOSX {
-  static std::string ComputeClangDir(std::string lldb_shlib_path,
-                                     bool verify = false) {
-    FileSpec clang_dir;
-    FileSpec lldb_shlib_spec(lldb_shlib_path, false);
-    ComputeClangDirectory(lldb_shlib_spec, clang_dir, verify);
-    return clang_dir.GetPath();
-  }
-};
-
 
 TEST_F(HostInfoTest, MacOSX) {
   // This returns whatever the POSIX fallback returns.
   std::string posix = "/usr/lib/liblldb.dylib";
-  EXPECT_FALSE(HostInfoMacOSXTest::ComputeClangDir(posix).empty());
+  EXPECT_FALSE(ComputeClangDir(posix).empty());
 
   std::string build =
     "/lldb-macosx-x86_64/Library/Frameworks/LLDB.framework/Versions/A";
   std::string build_clang =
     "/lldb-macosx-x86_64/Library/Frameworks/LLDB.framework/Resources/Clang";
-  EXPECT_EQ(HostInfoMacOSXTest::ComputeClangDir(build), build_clang);
+  EXPECT_EQ(ComputeClangDir(build), build_clang);
 
   std::string xcode =
     "/Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Versions/A";
   std::string xcode_clang =
     "/Applications/Xcode.app/Contents/Developer/Toolchains/"
     "XcodeDefault.xctoolchain/usr/lib/swift/clang";
-  EXPECT_EQ(HostInfoMacOSXTest::ComputeClangDir(xcode), xcode_clang);
+  EXPECT_EQ(ComputeClangDir(xcode), xcode_clang);
 
   std::string toolchain =
       "/Applications/Xcode.app/Contents/Developer/Toolchains/"
       "Swift-4.1-development-snapshot.xctoolchain/System/Library/"
       "PrivateFrameworks/LLDB.framework";
   std::string toolchain_clang =
       "/Applications/Xcode.app/Contents/Developer/Toolchains/"
       "Swift-4.1-development-snapshot.xctoolchain/usr/lib/swift/clang";
-  EXPECT_EQ(HostInfoMacOSXTest::ComputeClangDir(toolchain), toolchain_clang);
+  EXPECT_EQ(ComputeClangDir(toolchain), toolchain_clang);
 
   std::string cltools = "/Library/Developer/CommandLineTools/Library/"
                         "PrivateFrameworks/LLDB.framework";
   std::string cltools_clang =
       "/Library/Developer/CommandLineTools/Library/PrivateFrameworks/"
       "LLDB.framework/Resources/Clang";
-  EXPECT_EQ(HostInfoMacOSXTest::ComputeClangDir(cltools), cltools_clang);
-
+  EXPECT_EQ(ComputeClangDir(cltools), cltools_clang);
 
   // Test that a bogus path is detected.
-  EXPECT_NE(HostInfoMacOSXTest::ComputeClangDir(GetInputFilePath(xcode), true),
-            HostInfoMacOSXTest::ComputeClangDir(GetInputFilePath(xcode)));
+  EXPECT_NE(ComputeClangDir(GetInputFilePath(xcode), true),
+            ComputeClangDir(GetInputFilePath(xcode)));
 }
 #endif