[ExpressionParser] Implement ComputeClangResourceDir for Windows

[xiaobai]

Summary

This function is useful for expression evaluation, especially when doing swift debugging on windows.

[labath]

lgtm

[stella.stamenova]

This broke the Windows bot because now one of the TestPaths tests passes on Windows:

http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/2394

There's also this comment in the test file:

1. TODO: Merge into test_path when GetClangResourceDir is implemented on
2. windows

[xiaobai]

In D59072#1422059, @stella.stamenova wrote:

This broke the Windows bot because now one of the TestPaths tests passes on Windows:

http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/2394

There's also this comment in the test file:

1. TODO: Merge into test_path when GetClangResourceDir is implemented on
2. windows

Submitted a forward fix with rL355648

lldb/trunk/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);
+
 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 ComputeUserPluginsDirectory(FileSpec &file_spec);
 
   static void ComputeHostArchitectureSupport(ArchSpec &arch_32,
                                              ArchSpec &arch_64);
 };
 }
 
 #endif

lldb/trunk/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);
-
   static UserIDResolver &GetUserIDResolver();
 
 protected:
   static bool ComputeSupportExeDirectory(FileSpec &file_spec);
   static bool ComputeHeaderDirectory(FileSpec &file_spec);
 };
 }
 
 #endif

lldb/trunk/source/Host/common/HostInfoBase.cpp

if (normalized_triple.getVendorName().empty())
     normalized_triple.setVendor(host_triple.getVendor());
   if (normalized_triple.getOSName().empty())
     normalized_triple.setOS(host_triple.getOS());
   if (normalized_triple.getEnvironmentName().empty())
     normalized_triple.setEnvironment(host_triple.getEnvironment());
   return ArchSpec(normalized_triple);
 }
 
+bool HostInfoBase::ComputePathRelativeToLibrary(FileSpec &file_spec,
+                                                llvm::StringRef dir) {
+  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
+
+  FileSpec lldb_file_spec = GetShlibDir();
+  if (!lldb_file_spec)
+    return false;
+
+  std::string raw_path = lldb_file_spec.GetPath();
+  if (log)
+    log->Printf("HostInfo::%s() attempting to "
+                "derive the path %s relative to liblldb install path: %s",
+                __FUNCTION__, dir.data(), raw_path.c_str());
+
+  // Drop bin (windows) or lib
+  llvm::StringRef parent_path = llvm::sys::path::parent_path(raw_path);
+  if (parent_path.empty()) {
+    if (log)
+      log->Printf("HostInfo::%s() failed to find liblldb within the shared "
+                  "lib path",
+                  __FUNCTION__);
+    return false;
+  }
+
+  raw_path = (parent_path + dir).str();
+  if (log)
+    log->Printf("HostInfo::%s() derived the path as: %s", __FUNCTION__,
+                raw_path.c_str());
+  file_spec.GetDirectory().SetString(raw_path);
+  return (bool)file_spec.GetDirectory();
+}
+
 bool HostInfoBase::ComputeSharedLibraryDirectory(FileSpec &file_spec) {
   // To get paths related to LLDB we get the path to the executable that
   // contains this function. On MacOSX this will be "LLDB.framework/.../LLDB".
   // On other posix systems, we will get .../lib(64|32)?/liblldb.so.
 
   FileSpec lldb_file_spec(Host::GetModuleFileSpecForHostAddress(
       reinterpret_cast<void *>(reinterpret_cast<intptr_t>(
           HostInfoBase::ComputeSharedLibraryDirectory))));

lldb/trunk/source/Host/posix/HostInfoPosix.cpp

 uint32_t HostInfoPosix::GetGroupID() { return getgid(); }
 
 uint32_t HostInfoPosix::GetEffectiveUserID() { return geteuid(); }
 
 uint32_t HostInfoPosix::GetEffectiveGroupID() { return getegid(); }
 
 FileSpec HostInfoPosix::GetDefaultShell() { return FileSpec("/bin/sh"); }
 
-bool HostInfoPosix::ComputePathRelativeToLibrary(FileSpec &file_spec,
-                                                 llvm::StringRef dir) {
-  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
-
-  FileSpec lldb_file_spec = GetShlibDir();
-  if (!lldb_file_spec)
-    return false;
-
-  std::string raw_path = lldb_file_spec.GetPath();
-  // drop library directory
-  llvm::StringRef parent_path = llvm::sys::path::parent_path(raw_path);
-
-  // Most Posix systems (e.g. Linux/*BSD) will attempt to replace a */lib with
-  // */bin as the base directory for helper exe programs.  This will fail if
-  // the /lib and /bin directories are rooted in entirely different trees.
-  if (log)
-    log->Printf("HostInfoPosix::ComputePathRelativeToLibrary() attempting to "
-                "derive the %s path from this path: %s",
-                dir.data(), raw_path.c_str());
-
-  if (!parent_path.empty()) {
-    // Now write in bin in place of lib.
-    raw_path = (parent_path + dir).str();
-
-    if (log)
-      log->Printf("Host::%s() derived the bin path as: %s", __FUNCTION__,
-                  raw_path.c_str());
-  } else {
-    if (log)
-      log->Printf("Host::%s() failed to find /lib/liblldb within the shared "
-                  "lib path, bailing on bin path construction",
-                  __FUNCTION__);
-  }
-  file_spec.GetDirectory().SetString(raw_path);
-  return (bool)file_spec.GetDirectory();
-}
-
 bool HostInfoPosix::ComputeSupportExeDirectory(FileSpec &file_spec) {
   return ComputePathRelativeToLibrary(file_spec, "/bin");
 }
 
 bool HostInfoPosix::ComputeHeaderDirectory(FileSpec &file_spec) {
   FileSpec temp_file("/opt/local/include/lldb");
   file_spec.GetDirectory().SetCString(temp_file.GetPath().c_str());
   return true;

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

 //===-- ClangHost.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_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGHOST_H
 #define LLDB_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGHOST_H
 
 namespace lldb_private {
 
 class FileSpec;
 
-#if !defined(_WIN32)
 bool ComputeClangResourceDirectory(FileSpec &lldb_shlib_spec,
                                    FileSpec &file_spec, bool verify);
-#endif
 
 FileSpec GetClangResourceDir();
 
 } // namespace lldb_private
 
 #endif

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

 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
-#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 ComputeClangResourceDirectory(FileSpec &lldb_shlib_spec,
-                                          FileSpec &file_spec, bool verify) {
-  return false;
-}
-#else
 static bool VerifyClangPath(const llvm::Twine &clang_path) {
   if (FileSystem::Instance().IsDirectory(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());
static bool DefaultComputeClangResourceDirectory(FileSpec &lldb_shlib_spec,
 
   llvm::sys::path::append(clang_dir, relative_path);
   if (!verify || VerifyClangPath(clang_dir)) {
     file_spec.GetDirectory().SetString(clang_dir);
     FileSystem::Instance().Resolve(file_spec);
     return true;
   }
 
-  return HostInfoPosix::ComputePathRelativeToLibrary(file_spec, relative_path);
+  return HostInfo::ComputePathRelativeToLibrary(file_spec, relative_path);
 }
 
 bool lldb_private::ComputeClangResourceDirectory(FileSpec &lldb_shlib_spec,
                                          FileSpec &file_spec, bool verify) {
 #if !defined(__APPLE__)
   return DefaultComputeClangResourceDirectory(lldb_shlib_spec, file_spec,
                                               verify);
 #else
#else
 
   // Fall back to the Clang resource directory inside the framework.
   raw_path.append("LLDB.framework/Resources/Clang");
   file_spec.SetFile(raw_path.c_str(), FileSpec::Style::native);
   FileSystem::Instance().Resolve(file_spec);
   return true;
 #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, []() {
     if (FileSpec lldb_file_spec = HostInfo::GetShlibDir())
       ComputeClangResourceDirectory(lldb_file_spec, g_cached_resource_dir,
                                     true);
     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/trunk/unittests/Expression/ClangParserTest.cpp

struct ClangHostTest : public testing::Test {
   }
   static void TearDownTestCase() {
     HostInfo::Terminate();
     FileSystem::Terminate();
   }
 };
 } // namespace
 
-#if !defined(_WIN32)
 static std::string ComputeClangResourceDir(std::string lldb_shlib_path,
                                            bool verify = false) {
   FileSpec clang_dir;
   FileSpec lldb_shlib_spec(lldb_shlib_path);
   ComputeClangResourceDirectory(lldb_shlib_spec, clang_dir, verify);
   return clang_dir.GetPath();
 }
 
 TEST_F(ClangHostTest, ComputeClangResourceDirectory) {
+#if !defined(_WIN32)
   std::string path_to_liblldb = "/foo/bar/lib/";
   std::string path_to_clang_dir = "/foo/bar/lib/clang/" CLANG_VERSION_STRING;
+#else
+  std::string path_to_liblldb = "C:\\foo\\bar\\lib";
+  std::string path_to_clang_dir = "C:\\foo\\bar\\lib\\clang\\" CLANG_VERSION_STRING;
+#endif
   EXPECT_EQ(ComputeClangResourceDir(path_to_liblldb), path_to_clang_dir);
 
   // The path doesn't really exist, so setting verify to true should make
   // ComputeClangResourceDir to not give you path_to_clang_dir.
   EXPECT_NE(ComputeClangResourceDir(path_to_liblldb, true),
             ComputeClangResourceDir(path_to_liblldb));
 }
 
std::string cltools_clang =
       "LLDB.framework/Resources/Clang";
   EXPECT_EQ(ComputeClangResourceDir(cltools), cltools_clang);
 
   // Test that a bogus path is detected.
   EXPECT_NE(ComputeClangResourceDir(GetInputFilePath(xcode), true),
             ComputeClangResourceDir(GetInputFilePath(xcode)));
 }
 #endif // __APPLE__
-#endif // !_WIN32