[CMake] Ensure `CLANG_RESOURCE_DIR` is respected

[paperchalice]

Summary

This patch ensures all resources are installed into CLANG_RESOURCE_DIR.
Fixes: https://github.com/llvm/llvm-project/issues/59726

[paperchalice]

Use LLVM_LIBRARY_OUTPUT_INTDIR.

[mgorny]

While the general direction seems sound, I suspect this may be a real PITA given that for us:

-DCLANG_RESOURCE_DIR="../../../../lib/clang/${LLVM_MAJOR}"

I'm going to try and see later throughout the week if it's possible to keep that working with this patch.

[mgorny]

Ok, this turned out to be surprisingly painless, at least within our packaging.

However, I'd prefer if someone more experienced looked at the CMake changes.

[MaskRay]

The CMake part of this patch improves the matter. Manually constructed resource dir (many duplicates) string is replace with a library function call.

However, the introduced conditions in C++ code like

std::string path_to_clang_dir = std::string(CLANG_RESOURCE_DIR).empty()
                                    ? "/foo/bar/" LLDB_INSTALL_LIBDIR_BASENAME
                                      "/clang/" CLANG_VERSION_MAJOR_STRING
                                    : "/foo/bar/bin/" CLANG_RESOURCE_DIR;

makes me uncomfortable.

I wish that we can just replace all manually constructed CLANG_INSTALL_LIBDIR_BASENAME "/clang/" CLANG_VERSION_MAJOR_STRING with a simple CLANG_RESOURCE_DIR which is guaranteed to be non-empty.

edeaf16f2c2f02d6e43312d48d26d354d87913f3 (2011) added the CMake variable CLANG_RESOURCE_DIR but did not explain why.
In the long term, the CMake variable CLANG_RESOURCE_DIR probably should be removed.

[paperchalice]

In D141907#4094748, @MaskRay wrote:

The CMake part of this patch improves the matter. Manually constructed resource dir (many duplicates) string is replace with a library function call.

However, the introduced conditions in C++ code like

std::string path_to_clang_dir = std::string(CLANG_RESOURCE_DIR).empty()
                                    ? "/foo/bar/" LLDB_INSTALL_LIBDIR_BASENAME
                                      "/clang/" CLANG_VERSION_MAJOR_STRING
                                    : "/foo/bar/bin/" CLANG_RESOURCE_DIR;

makes me uncomfortable.

I wish that we can just replace all manually constructed CLANG_INSTALL_LIBDIR_BASENAME "/clang/" CLANG_VERSION_MAJOR_STRING with a simple CLANG_RESOURCE_DIR which is guaranteed to be non-empty.

edeaf16f2c2f02d6e43312d48d26d354d87913f3 (2011) added the CMake variable CLANG_RESOURCE_DIR but did not explain why.
In the long term, the CMake variable CLANG_RESOURCE_DIR probably should be removed.

clang::driver::Driver::GetResourcesPath would be a better choice.

[phosek]

cmake/Modules/GetClangResourceDir.cmake

18

This variable is only used once on the following line, I'd just inline it which is more idiomatic.

19

It's more idiomatic to parse arguments at the start of the function.

19

This is just a nit, but we usually use a prefix like ARGS to make it clear that these are input arguments.

[paperchalice]

• Use clang::driver::Driver::GetResourcesPath
• Use ARG as prefix

[paperchalice]

Ping.

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

56

Should be "${CMAKE_INSTALL_BINDIR}/lldb" here, but need another variable in config.h.

[tstellar]

cmake/Modules/GetClangResourceDir.cmake

13

Why is the bin prefix here?

[paperchalice]

cmake/Modules/GetClangResourceDir.cmake

13

See https://clang.llvm.org/doxygen/classclang_1_1driver_1_1Driver.html#acda8dfdf4f80efa84df98157e1779152
GetResourcesPath will return <prefix>/lib/<version> when CLANG_RESOURCE_DIR is empty, <prefix>/bin/CLANG_RESOURCE_DIR otherwise.

[tstellar]

cmake/Modules/GetClangResourceDir.cmake

13

GetResourcesPath calls sys::path::parent_path twice on the path to the clang executable which is going to give you /usr on most Linux systems, so it's returning <prefix>/CLANG_RESOURCE_DIR not <prefix>/bin/CLANG_RESOURCE_DIR.

[tstellar]

cmake/Modules/GetClangResourceDir.cmake

13

Sorry, you are correct. I was looking at the wrong branch. It's really strange that it does that.

[tstellar]

cmake/Modules/GetClangResourceDir.cmake

13

@paperchalice Can you update the description of the CLANG_RESOURCE_DIR cache variable in clang/CMakeLists.txt to mention that the path should be relative to the directory with the clang executable.

[paperchalice]

cmake/Modules/GetClangResourceDir.cmake

13

Already in codebase:

set(CLANG_RESOURCE_DIR "" CACHE STRING
  "Relative directory from the Clang binary to its resource files.")

[tstellar]

Thanks for the patch. I've tested this and it works for my build configuration. LGTM.

[tstellar]

@paperchalice Do you need someone to commit this for you?

[paperchalice]

In D141907#4355228, @tstellar wrote:

@paperchalice Do you need someone to commit this for you?

Sure, I don't have the commit access.

[tstellar]

In D141907#4355229, @paperchalice wrote:

In D141907#4355228, @tstellar wrote:

@paperchalice Do you need someone to commit this for you?

Sure, I don't have the commit access.

What name / email address do you want me to use for the commit author field?

[paperchalice]

In D141907#4361594, @tstellar wrote:

In D141907#4355229, @paperchalice wrote:

In D141907#4355228, @tstellar wrote:

@paperchalice Do you need someone to commit this for you?

Sure, I don't have the commit access.

What name / email address do you want me to use for the commit author field?

Sorry for the late, the information in phabricator is OK, and GetClangResourceDir.cmake is not landed correctly. Ping @tstellar

[protze.joachim]

The review should not be closed, since the patch was reverted and should be recommitted (this time possibly with a reference to this review?)

[paperchalice]

In D141907#4398196, @protze.joachim wrote:

The review should not be closed, since the patch was reverted and should be recommitted (this time possibly with a reference to this review?)

This is recommitted as 0beffb854209a41f31beb18f9631258349a99299, but break some lldb builds, so I created https://reviews.llvm.org/D152225 .

[sebastian-ne]

cmake/Modules/GetClangResourceDir.cmake

15

This fails in our downstream project.
We use add_subdirectory() to include LLVM and our parent project already sets PACKAGE_VERSION to something that is not the LLVM version.

Parsing PACKAGE_VERSION only if CLANG_VERSION_MAJOR is not already known seems to work:

if (NOT CLANG_VERSION_MAJOR)
  string(REGEX MATCH "^[0-9]+" CLANG_VERSION_MAJOR ${PACKAGE_VERSION})
endif()

[MaskRay]

In D141907#4094748, @MaskRay wrote:

[...]
edeaf16f2c2f02d6e43312d48d26d354d87913f3 (2011) added the CMake variable CLANG_RESOURCE_DIR but did not explain why.
In the long term, the CMake variable CLANG_RESOURCE_DIR probably should be removed.

My feeling stays the same. In the long term, we should try removing the CMake variable CLANG_RESOURCE_DIR.
Customizing the variable in a special way will make some clang/test/Driver tests fail, I don't know it's healthy for contributors to be aware of this yet-another configure variable for clang/test/Driver tests. The CLANG_RESOURCE_DIR users should be served by specifying -resource-dir= in a configuration file (https://clang.llvm.org/docs/UsersManual.html#configuration-files)

[tstellar]

In D141907#4409973, @MaskRay wrote:

In D141907#4094748, @MaskRay wrote:

[...]
edeaf16f2c2f02d6e43312d48d26d354d87913f3 (2011) added the CMake variable CLANG_RESOURCE_DIR but did not explain why.
In the long term, the CMake variable CLANG_RESOURCE_DIR probably should be removed.

My feeling stays the same. In the long term, we should try removing the CMake variable CLANG_RESOURCE_DIR.
Customizing the variable in a special way will make some clang/test/Driver tests fail, I don't know it's healthy for contributors to be aware of this yet-another configure variable for clang/test/Driver tests. The CLANG_RESOURCE_DIR users should be served by specifying -resource-dir= in a configuration file (https://clang.llvm.org/docs/UsersManual.html#configuration-files)

I agree with this

In D141907#4409973, @MaskRay wrote:

In D141907#4094748, @MaskRay wrote:

[...]
edeaf16f2c2f02d6e43312d48d26d354d87913f3 (2011) added the CMake variable CLANG_RESOURCE_DIR but did not explain why.
In the long term, the CMake variable CLANG_RESOURCE_DIR probably should be removed.

My feeling stays the same. In the long term, we should try removing the CMake variable CLANG_RESOURCE_DIR.
Customizing the variable in a special way will make some clang/test/Driver tests fail, I don't know it's healthy for contributors to be aware of this yet-another configure variable for clang/test/Driver tests. The CLANG_RESOURCE_DIR users should be served by specifying -resource-dir= in a configuration file (https://clang.llvm.org/docs/UsersManual.html#configuration-files)

I think I agree with you here. The other problem I see with CLANG_RESOURCE_DIR is that it depends on the value of LLVM_LIBDIR_SUFFIX, so it's still configurable even without the CLANG_RESOURCE_DIR variable. I think it would make sense to standardize it to /usr/lib/clang rather than /usr/lib${LLVM_LBDIR_SUFFIX}/clang. This is how gcc works and it also ensures that clang can find the 32-bit compiler-rt libraries.

[mgorny]

This is the final version that was pushed, correct? (the commits don't link the revision)

I've raised some concerns about the resulting API in https://reviews.llvm.org/D156270#4557902. I'd appreciate if you could take a look.

clang/lib/Headers/CMakeLists.txt

set(openmp_wrapper_files
   openmp_wrappers/cmath
   openmp_wrappers/complex.h
   openmp_wrappers/complex
   openmp_wrappers/__clang_openmp_device_functions.h
   openmp_wrappers/complex_cmath.h
   openmp_wrappers/new
 )
 
-set(output_dir ${LLVM_LIBRARY_OUTPUT_INTDIR}/clang/${CLANG_VERSION_MAJOR}/include)
+include(GetClangResourceDir)
+get_clang_resource_dir(output_dir PREFIX ${LLVM_LIBRARY_OUTPUT_INTDIR}/.. SUBDIR include)
 set(out_files)
 set(generated_files)
 
 set(arm_common_generated_files)
 set(arm_only_generated_files)
 set(aarch64_only_generated_files)
 set(riscv_generated_files)
 

 
 # Other header groupings
 add_header_target("hlsl-resource-headers" ${hlsl_files})
 add_header_target("opencl-resource-headers" ${opencl_files})
 add_header_target("openmp-resource-headers" ${openmp_wrapper_files})
 add_header_target("windows-resource-headers" ${windows_only_files})
 add_header_target("utility-resource-headers" ${utility_files})
 
-set(header_install_dir lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION_MAJOR}/include)
+get_clang_resource_dir(header_install_dir SUBDIR include)
 
 #############################################################
 # Install rules for the catch-all clang-resource-headers target
 install(
   FILES ${files} ${generated_files}
   DESTINATION ${header_install_dir}
   COMPONENT clang-resource-headers)
 

clang/lib/Tooling/CMakeLists.txt

else()
 
   set(skip_expensive_processing $<OR:$<CONFIG:Debug>,$<NOT:$<BOOL:${CLANG_TOOLING_BUILD_AST_INTROSPECTION}>>>)
 
   set(implicitDirs)
   foreach(implicitDir ${CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES})
     list(APPEND implicitDirs -I ${implicitDir})
   endforeach()
 
+  include(GetClangResourceDir)
+  get_clang_resource_dir(resource_dir PREFIX ${LLVM_BINARY_DIR})
   add_custom_command(
       COMMENT Generate ASTNodeAPI.json
       OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/ASTNodeAPI.json
       DEPENDS clang-ast-dump clang-resource-headers
       COMMAND
       $<TARGET_FILE:clang-ast-dump>
         # Skip this in debug mode because parsing AST.h is too slow
         --skip-processing=${skip_expensive_processing}
-        -I ${LLVM_BINARY_DIR}/lib/clang/${CLANG_VERSION_MAJOR}/include
+        -I ${resource_dir}/include
         -I ${CLANG_SOURCE_DIR}/include
         -I ${LLVM_BINARY_DIR}/tools/clang/include
         -I ${LLVM_BINARY_DIR}/include
         -I ${LLVM_SOURCE_DIR}/include
         ${implicitDirs}
         --json-output-path ${CMAKE_CURRENT_BINARY_DIR}/ASTNodeAPI.json
   )
 

clang/runtime/CMakeLists.txt

if(LLVM_BUILD_EXTERNAL_COMPILER_RT AND EXISTS ${COMPILER_RT_SRC_ROOT}/)
   set(compiler_rt_configure_deps)
   if(TARGET cxx-headers)
     list(APPEND compiler_rt_configure_deps "cxx-headers")
   endif()
   if(LLVM_INCLUDE_TESTS)
     list(APPEND compiler_rt_configure_deps LLVMTestingSupport)
   endif()
 
+  include(GetClangResourceDir)
+  get_clang_resource_dir(output_resource_dir PREFIX ${LLVM_BINARY_DIR})
+  get_clang_resource_dir(install_resource_dir)
   ExternalProject_Add(compiler-rt
     DEPENDS llvm-config clang ${compiler_rt_configure_deps}
     PREFIX ${COMPILER_RT_PREFIX}
     SOURCE_DIR ${COMPILER_RT_SRC_ROOT}
     STAMP_DIR ${STAMP_DIR}
     BINARY_DIR ${BINARY_DIR}
     CMAKE_ARGS ${CLANG_COMPILER_RT_CMAKE_ARGS}
                -DCMAKE_C_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang
                -DCMAKE_CXX_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang++
                -DCMAKE_ASM_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang
                -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
                -DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}
                -DCMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER}
                -DCMAKE_CXX_COMPILER_LAUNCHER=${CMAKE_CXX_COMPILER_LAUNCHER}
                -DLLVM_CONFIG_PATH=${LLVM_RUNTIME_OUTPUT_INTDIR}/llvm-config
                -DLLVM_LIT_ARGS=${LLVM_LIT_ARGS}
-               -DCOMPILER_RT_OUTPUT_DIR=${LLVM_LIBRARY_OUTPUT_INTDIR}/clang/${CLANG_VERSION_MAJOR}
+               -DCOMPILER_RT_OUTPUT_DIR=${output_resource_dir}
                -DCOMPILER_RT_EXEC_OUTPUT_DIR=${LLVM_RUNTIME_OUTPUT_INTDIR}
-               -DCOMPILER_RT_INSTALL_PATH:PATH=lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION_MAJOR}
+               -DCOMPILER_RT_INSTALL_PATH:PATH=${install_resource_dir}
                -DCOMPILER_RT_INCLUDE_TESTS=${LLVM_INCLUDE_TESTS}
                -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}
                -DLLVM_LIBDIR_SUFFIX=${LLVM_LIBDIR_SUFFIX}
                -DLLVM_RUNTIME_OUTPUT_INTDIR=${LLVM_RUNTIME_OUTPUT_INTDIR}
                -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}
                -DCMAKE_OSX_SYSROOT:PATH=${CMAKE_OSX_SYSROOT}
                ${COMPILER_RT_PASSTHROUGH_VARIABLES}
     INSTALL_COMMAND ""

cmake/Modules/GetClangResourceDir.cmake

+# get clang resource directory
+#
+# usage:
+#  get_clang_resource_dir(out_var [PREFIX prefix] [SUBDIR subdirectory])
+#
+# user can use `PREFIX` to prepend some path to it or use `SUBDIR` to
+# get subdirectory under clang resource dir
+
+function(get_clang_resource_dir out_var)
+  cmake_parse_arguments(ARG "" "PREFIX;SUBDIR" "" ${ARGN})
+
+  if(DEFINED CLANG_RESOURCE_DIR AND NOT CLANG_RESOURCE_DIR STREQUAL "")
+    set(ret_dir bin/${CLANG_RESOURCE_DIR})
+  else()
+    string(REGEX MATCH "^[0-9]+" CLANG_VERSION_MAJOR ${PACKAGE_VERSION})
+    set(ret_dir lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION_MAJOR})
+  endif()
+
+  if(ARG_PREFIX)
+    set(ret_dir ${ARG_PREFIX}/${ret_dir})
+  endif()
+  if(ARG_SUBDIR)
+    set(ret_dir ${ret_dir}/${ARG_SUBDIR})
+  endif()
+
+  set(${out_var} ${ret_dir} PARENT_SCOPE)
+endfunction()

compiler-rt/cmake/base-config-ix.cmake

 # The CompilerRT build system requires CMake version 2.8.8 or higher in order
 # to use its support for building convenience "libraries" as a collection of
 # .o files. This is particularly useful in producing larger, more complex
 # runtime libraries.
 
 include(BuiltinTests)
 include(CheckIncludeFile)
 include(CheckCXXSourceCompiles)
 include(GNUInstallDirs)
+include(GetClangResourceDir)
 include(ExtendPath)
 
 check_include_file(unwind.h HAVE_UNWIND_H)
 
 # Used by sanitizer_common and tests.
 check_include_file(rpc/xdr.h HAVE_RPC_XDR_H)
 if (NOT HAVE_RPC_XDR_H)
   set(HAVE_RPC_XDR_H 0)

 
 # Setting these variables from an LLVM build is sufficient that compiler-rt can
 # construct the output paths, so it can behave as if it were in-tree here.
 if (LLVM_LIBRARY_OUTPUT_INTDIR AND LLVM_RUNTIME_OUTPUT_INTDIR AND PACKAGE_VERSION)
   set(LLVM_TREE_AVAILABLE On)
 endif()
 
 if (LLVM_TREE_AVAILABLE)
-  # Compute the Clang version from the LLVM version.
-  # FIXME: We should be able to reuse CLANG_VERSION_MAJOR variable calculated
-  #        in Clang cmake files, instead of copying the rules here.
-  string(REGEX MATCH "^[0-9]+" CLANG_VERSION_MAJOR
-         ${PACKAGE_VERSION})
   # Setup the paths where compiler-rt runtimes and headers should be stored.
-  set(COMPILER_RT_OUTPUT_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/clang/${CLANG_VERSION_MAJOR})
+  get_clang_resource_dir(COMPILER_RT_OUTPUT_DIR PREFIX ${LLVM_LIBRARY_OUTPUT_INTDIR}/..)
   set(COMPILER_RT_EXEC_OUTPUT_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR})
-  set(COMPILER_RT_INSTALL_PATH lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION_MAJOR})
+  get_clang_resource_dir(COMPILER_RT_INSTALL_PATH)
   option(COMPILER_RT_INCLUDE_TESTS "Generate and build compiler-rt unit tests."
          ${LLVM_INCLUDE_TESTS})
   option(COMPILER_RT_ENABLE_WERROR "Fail and stop if warning is triggered"
          ${LLVM_ENABLE_WERROR})
 
   # Use just-built Clang to compile/link tests on all platforms.
   if (CMAKE_CROSSCOMPILING)
     if (CMAKE_HOST_WIN32)

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

 //===-- ClangHost.cpp -----------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangHost.h"
 
 #include "clang/Basic/Version.h"
 #include "clang/Config/config.h"
+#include "clang/Driver/Driver.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 
 #include "lldb/Host/Config.h"
 #include "lldb/Host/FileSystem.h"

 /// This mode is only used for testing.
 ///
 static bool DefaultComputeClangResourceDirectory(FileSpec &lldb_shlib_spec,
                                                  FileSpec &file_spec,
                                                  bool verify) {
   Log *log = GetLog(LLDBLog::Host);
   std::string raw_path = lldb_shlib_spec.GetPath();
   llvm::StringRef parent_dir = llvm::sys::path::parent_path(raw_path);
+  const std::string clang_resource_path =
+      clang::driver::Driver::GetResourcesPath("bin/lldb", CLANG_RESOURCE_DIR);
 
   static const llvm::StringRef kResourceDirSuffixes[] = {
       // LLVM.org's build of LLDB uses the clang resource directory placed
-      // in $install_dir/lib{,64}/clang/$clang_version.
-      CLANG_INSTALL_LIBDIR_BASENAME "/clang/" CLANG_VERSION_MAJOR_STRING,
+      // in $install_dir/lib{,64}/clang/$clang_version or
+      // $install_dir/bin/$CLANG_RESOURCE_DIR
+      clang_resource_path,
       // swift-lldb uses the clang resource directory copied from swift, which
       // by default is placed in $install_dir/lib{,64}/lldb/clang. LLDB places
       // it there, so we use LLDB_INSTALL_LIBDIR_BASENAME.
       LLDB_INSTALL_LIBDIR_BASENAME "/lldb/clang",
   };
 
   for (const auto &Suffix : kResourceDirSuffixes) {
     llvm::SmallString<256> clang_dir(parent_dir);
if (!verify || VerifyClangPath(clang_dir)) {
       return true;
     }
   }
 
   return false;
 }
 
 bool lldb_private::ComputeClangResourceDirectory(FileSpec &lldb_shlib_spec,
-                                         FileSpec &file_spec, bool verify) {
+                                                 FileSpec &file_spec,
+                                                 bool verify) {
 #if !defined(__APPLE__)
   return DefaultComputeClangResourceDirectory(lldb_shlib_spec, file_spec,
                                               verify);
 #else
   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);

lldb/unittests/Expression/ClangParserTest.cpp

 //===-- ClangParserTest.cpp -----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Basic/Version.h"
+#include "clang/Config/config.h"
+#include "clang/Driver/Driver.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangHost.h"
 #include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/TestUtilities.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Utility/FileSpec.h"
static std::string ComputeClangResourceDir(std::string lldb_shlib_path,
   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/" LLDB_INSTALL_LIBDIR_BASENAME "/clang/" CLANG_VERSION_MAJOR_STRING;
 #else
-  std::string path_to_liblldb = "C:\\foo\\bar\\lib";
-  std::string path_to_clang_dir =
-      "C:\\foo\\bar\\lib\\clang\\" CLANG_VERSION_MAJOR_STRING;
+  std::string path_to_liblldb = "C:\\foo\\bar\\lib\\";
 #endif
+  std::string path_to_clang_dir = clang::driver::Driver::GetResourcesPath(
+      path_to_liblldb + "liblldb", CLANG_RESOURCE_DIR);
   EXPECT_EQ(ComputeClangResourceDir(path_to_liblldb), path_to_clang_dir);
 
   // The path doesn't really exist, so setting verify to true should make
   // ComputeClangResourceDir not give you path_to_clang_dir.
   EXPECT_NE(ComputeClangResourceDir(path_to_liblldb, true), path_to_clang_dir);
 }
 
 #if defined(__APPLE__)

llvm/cmake/modules/LLVMExternalProjectUtils.cmake

set(compiler_args -DCMAKE_ASM_COMPILER=${CMAKE_ASM_COMPILER}
                       -DCMAKE_OBJDUMP=${CMAKE_OBJDUMP}
                       -DCMAKE_STRIP=${CMAKE_STRIP}
                       -DCMAKE_READELF=${CMAKE_READELF})
     set(llvm_config_path ${LLVM_CONFIG_PATH})
 
     if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
       string(REGEX MATCH "^[0-9]+" CLANG_VERSION_MAJOR
              ${PACKAGE_VERSION})
+      if(DEFINED CLANG_RESOURCE_DIR AND NOT CLANG_RESOURCE_DIR STREQUAL "")
+        set(resource_dir ${LLVM_TOOLS_BINARY_DIR}/${CLANG_RESOURCE_DIR})
+      else()
         set(resource_dir "${LLVM_LIBRARY_DIR}/clang/${CLANG_VERSION_MAJOR}")
+      endif()
       set(flag_types ASM C CXX MODULE_LINKER SHARED_LINKER EXE_LINKER)
       foreach(type ${flag_types})
         set(${type}_flag -DCMAKE_${type}_FLAGS=-resource-dir=${resource_dir})
       endforeach()
       string(REPLACE ";" "|" flag_string "${flag_types}")
       foreach(arg ${ARG_CMAKE_ARGS})
         if(arg MATCHES "^-DCMAKE_(${flag_string})_FLAGS")
           foreach(type ${flag_types})

openmp/CMakeLists.txt

 option(OPENMP_ENABLE_LIBOMPTARGET "Enable building libomptarget for offloading."
        ${ENABLE_LIBOMPTARGET})
 option(OPENMP_ENABLE_LIBOMP_PROFILING "Enable time profiling for libomp." OFF)
 
 # Header install location
 if(${OPENMP_STANDALONE_BUILD})
   set(LIBOMP_HEADERS_INSTALL_PATH "${CMAKE_INSTALL_INCLUDEDIR}")
 else()
-  string(REGEX MATCH "[0-9]+" CLANG_VERSION ${PACKAGE_VERSION})
-  set(LIBOMP_HEADERS_INSTALL_PATH "${OPENMP_INSTALL_LIBDIR}/clang/${CLANG_VERSION}/include")
+  include(GetClangResourceDir)
+  get_clang_resource_dir(LIBOMP_HEADERS_INSTALL_PATH SUBDIR include)
 endif()
 
 # Build host runtime library, after LIBOMPTARGET variables are set since they are needed
 # to enable time profiling support in the OpenMP runtime.
 add_subdirectory(runtime)
 
 if (OPENMP_ENABLE_LIBOMPTARGET)
   # Check that the library can actually be built.