[clang][lldb][cmake] Use new `*_INSTALL_LIBDIR_BASENAME` CPP macro

[Ericson2314]

Summary

Use this instead of *_LIBDIR_SUFFIX, from which it is computed.

This gets us ready for D130586, in which *_LIBDIR_SUFFIX is
deprecated.

[Ericson2314]

D130586 was approved; this is a subset; this had no test failures, so I just went ahead and landed it.

[thakis]

I fixed up the gn build after this in 804d4594cbe217ae817b6786b0e9965283f78aa2

[thakis]

(ie if you revert that, it'd be appreciated if you could revert that in the same commit)

[Ericson2314]

OK Thanks @thakis --- I was confused why the last GN fixup added but didn't remove lines. That clears it up!

[MaskRay]

In the long term we should just remove the CLANG_INSTALL_LIBDIR_BASENAME customization. This is supposed for GCC multilib lib32 lib64 names but we don't necessarily use it for Clang + compiler-rt files.

[Ericson2314]

Thanks @MaskRay that's good to know.

clang/CMakeLists.txt

 endif()
 add_subdirectory(utils/hmaptool)
 
 if(CLANG_BUILT_STANDALONE)
   llvm_distribution_add_targets()
   process_llvm_pass_plugins()
 endif()
 
+set(CLANG_INSTALL_LIBDIR_BASENAME "lib${CLANG_LIBDIR_SUFFIX}")
+
 configure_file(
   ${CLANG_SOURCE_DIR}/include/clang/Config/config.h.cmake
   ${CLANG_BINARY_DIR}/include/clang/Config/config.h)

clang/include/clang/Config/config.h.cmake

 #define CLANG_DEFAULT_OPENMP_RUNTIME "${CLANG_DEFAULT_OPENMP_RUNTIME}"
 
 /* Default architecture for OpenMP offloading to Nvidia GPUs. */
 #define CLANG_OPENMP_NVPTX_DEFAULT_ARCH "${CLANG_OPENMP_NVPTX_DEFAULT_ARCH}"
 
 /* Default architecture for SystemZ. */
 #define CLANG_SYSTEMZ_DEFAULT_ARCH "${CLANG_SYSTEMZ_DEFAULT_ARCH}"
 
-/* Multilib suffix for libdir. */
-#define CLANG_LIBDIR_SUFFIX "${CLANG_LIBDIR_SUFFIX}"
+/* Multilib basename for libdir. */
+#define CLANG_INSTALL_LIBDIR_BASENAME "${CLANG_INSTALL_LIBDIR_BASENAME}"
 
 /* Relative directory for resource files */
 #define CLANG_RESOURCE_DIR "${CLANG_RESOURCE_DIR}"
 
 /* Directories clang will search for headers */
 #define C_INCLUDE_DIRS "${C_INCLUDE_DIRS}"
 
 /* Directories clang will search for configuration files */

clang/lib/Driver/Driver.cpp

if (CustomResourceDir != "") {
     llvm::sys::path::append(P, CustomResourceDir);
   } else {
     // On Windows, libclang.dll is in bin/.
     // On non-Windows, libclang.so/.dylib is in lib/.
     // With a static-library build of libclang, LibClangPath will contain the
     // path of the embedding binary, which for LLVM binaries will be in bin/.
     // ../lib gets us to lib/ in both cases.
     P = llvm::sys::path::parent_path(Dir);
-    llvm::sys::path::append(P, Twine("lib") + CLANG_LIBDIR_SUFFIX, "clang",
+    llvm::sys::path::append(P, CLANG_INSTALL_LIBDIR_BASENAME, "clang",
                             CLANG_VERSION_STRING);
   }
 
   return std::string(P.str());
 }
 
 Driver::Driver(StringRef ClangExecutable, StringRef TargetTriple,
                DiagnosticsEngine &Diags, std::string Title,

clang/lib/Driver/ToolChains/CommonArgs.cpp

 #elif defined(__APPLE__)
     const char *Suffix = ".dylib";
 #else
     const char *Suffix = ".so";
 #endif
 
     SmallString<1024> Plugin;
     llvm::sys::path::native(
-        Twine(D.Dir) + "/../lib" CLANG_LIBDIR_SUFFIX "/LLVMgold" + Suffix,
+        Twine(D.Dir) + "/../" CLANG_INSTALL_LIBDIR_BASENAME "/LLVMgold" +
+            Suffix,
         Plugin);
     CmdArgs.push_back(Args.MakeArgString(Plugin));
   }
 
   // Try to pass driver level flags relevant to LTO code generation down to
   // the plugin.
 
   // Handle flags for selecting CPU variants.
void tools::addOpenMPRuntimeSpecificRPath(const ToolChain &TC,
                                           ArgStringList &CmdArgs) {
 
   if (Args.hasFlag(options::OPT_fopenmp_implicit_rpath,
                    options::OPT_fno_openmp_implicit_rpath, true)) {
     // Default to clang lib / lib64 folder, i.e. the same location as device
     // runtime
     SmallString<256> DefaultLibPath =
         llvm::sys::path::parent_path(TC.getDriver().Dir);
-    llvm::sys::path::append(DefaultLibPath, Twine("lib") + CLANG_LIBDIR_SUFFIX);
+    llvm::sys::path::append(DefaultLibPath, CLANG_INSTALL_LIBDIR_BASENAME);
     CmdArgs.push_back("-rpath");
     CmdArgs.push_back(Args.MakeArgString(DefaultLibPath));
   }
 }
 
 void tools::addOpenMPRuntimeLibraryPath(const ToolChain &TC,
                                         const ArgList &Args,
                                         ArgStringList &CmdArgs) {
   // Default to clang lib / lib64 folder, i.e. the same location as device
   // runtime.
   SmallString<256> DefaultLibPath =
       llvm::sys::path::parent_path(TC.getDriver().Dir);
-  llvm::sys::path::append(DefaultLibPath, Twine("lib") + CLANG_LIBDIR_SUFFIX);
+  llvm::sys::path::append(DefaultLibPath, CLANG_INSTALL_LIBDIR_BASENAME);
   CmdArgs.push_back(Args.MakeArgString("-L" + DefaultLibPath));
 }
 
 void tools::addArchSpecificRPath(const ToolChain &TC, const ArgList &Args,
                                  ArgStringList &CmdArgs) {
   // Enable -frtlib-add-rpath by default for the case of VE.
   const bool IsVE = TC.getTriple().isVE();
   bool DefaultValue = IsVE;
void tools::AddStaticDeviceLibs(Compilation *C, const Tool *T,
   }
 
   // Add directories from user-specified -L options
   for (std::string Search_Dir : DriverArgs.getAllArgValues(options::OPT_L))
     LibraryPaths.emplace_back(Search_Dir);
 
   // Add path to lib-debug folders
   SmallString<256> DefaultLibPath = llvm::sys::path::parent_path(D.Dir);
-  llvm::sys::path::append(DefaultLibPath, Twine("lib") + CLANG_LIBDIR_SUFFIX);
+  llvm::sys::path::append(DefaultLibPath, CLANG_INSTALL_LIBDIR_BASENAME);
   LibraryPaths.emplace_back(DefaultLibPath.c_str());
 
   // Build list of Static Device Libraries SDLs specified by -l option
   llvm::SmallSet<std::string, 16> SDLNames;
   static const StringRef HostOnlyArchives[] = {
       "omp", "cudart", "m", "gcc", "gcc_s", "pthread", "hip_hcc"};
   for (auto SDLName : DriverArgs.getAllArgValues(options::OPT_l)) {
     if (!HostOnlyArchives->contains(SDLName)) {
void tools::addOpenMPDeviceRTL(const Driver &D,
                                const llvm::opt::ArgList &DriverArgs,
                                llvm::opt::ArgStringList &CC1Args,
                                StringRef BitcodeSuffix,
                                const llvm::Triple &Triple) {
   SmallVector<StringRef, 8> LibraryPaths;
 
   // Add path to clang lib / lib64 folder.
   SmallString<256> DefaultLibPath = llvm::sys::path::parent_path(D.Dir);
-  llvm::sys::path::append(DefaultLibPath, Twine("lib") + CLANG_LIBDIR_SUFFIX);
+  llvm::sys::path::append(DefaultLibPath, CLANG_INSTALL_LIBDIR_BASENAME);
   LibraryPaths.emplace_back(DefaultLibPath.c_str());
 
   // Add user defined library paths from LIBRARY_PATH.
   llvm::Optional<std::string> LibPath =
       llvm::sys::Process::GetEnv("LIBRARY_PATH");
   if (LibPath) {
     SmallVector<StringRef, 8> Frags;
     const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};

clang/lib/Driver/ToolChains/Cuda.cpp

void NVPTX::OpenMPLinker::ConstructJob(Compilation &C, const JobAction &JA,
   CmdArgs.push_back(Args.MakeArgString(GPUArch));
 
   // Add paths specified in LIBRARY_PATH environment variable as -L options.
   addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
 
   // Add paths for the default clang library path.
   SmallString<256> DefaultLibPath =
       llvm::sys::path::parent_path(TC.getDriver().Dir);
-  llvm::sys::path::append(DefaultLibPath, "lib" CLANG_LIBDIR_SUFFIX);
+  llvm::sys::path::append(DefaultLibPath, CLANG_INSTALL_LIBDIR_BASENAME);
   CmdArgs.push_back(Args.MakeArgString(Twine("-L") + DefaultLibPath));
 
   for (const auto &II : Inputs) {
     if (II.getType() == types::TY_LLVM_IR ||
         II.getType() == types::TY_LTO_IR ||
         II.getType() == types::TY_LTO_BC ||
         II.getType() == types::TY_LLVM_BC) {
       C.getDriver().Diag(diag::err_drv_no_linker_llvm_support)

lldb/cmake/modules/LLDBGenerateConfig.cmake

 check_include_file(termios.h HAVE_TERMIOS_H)
 check_include_files("sys/types.h;sys/event.h" HAVE_SYS_EVENT_H)
 
 check_cxx_symbol_exists(process_vm_readv "sys/uio.h" HAVE_PROCESS_VM_READV)
 check_cxx_symbol_exists(__NR_process_vm_readv "sys/syscall.h" HAVE_NR_PROCESS_VM_READV)
 
 check_library_exists(compression compression_encode_buffer "" HAVE_LIBCOMPRESSION)
 
+set(LLDB_INSTALL_LIBDIR_BASENAME "lib${LLDB_LIBDIR_SUFFIX}")
+
 # These checks exist in LLVM's configuration, so I want to match the LLVM names
 # so that the check isn't duplicated, but we translate them into the LLDB names
 # so that I don't have to change all the uses at the moment.
 set(LLDB_ENABLE_TERMIOS ${HAVE_TERMIOS_H})
 if (UNIX)
   set(LLDB_ENABLE_POSIX ON)
 else()
   set(LLDB_ENABLE_POSIX OFF)

lldb/include/lldb/Host/Config.h.cmake

 #cmakedefine01 LLDB_ENABLE_PYTHON
 
 #cmakedefine01 LLDB_ENABLE_FBSDVMCORE
 
 #cmakedefine01 LLDB_EMBED_PYTHON_HOME
 
 #cmakedefine LLDB_PYTHON_HOME R"(${LLDB_PYTHON_HOME})"
 
-#define LLDB_LIBDIR_SUFFIX "${LLVM_LIBDIR_SUFFIX}"
+#define LLDB_INSTALL_LIBDIR_BASENAME "${LLDB_INSTALL_LIBDIR_BASENAME}"
 
 #cmakedefine LLDB_GLOBAL_INIT_DIRECTORY R"(${LLDB_GLOBAL_INIT_DIRECTORY})"
 
 #endif // #ifndef LLDB_HOST_CONFIG_H

lldb/source/Host/linux/HostInfoLinux.cpp

bool HostInfoLinux::ComputeSupportExeDirectory(FileSpec &file_spec) {
   if (HostInfoPosix::ComputeSupportExeDirectory(file_spec) &&
       file_spec.IsAbsolute() && FileSystem::Instance().Exists(file_spec))
     return true;
   file_spec.SetDirectory(GetProgramFileSpec().GetDirectory());
   return !file_spec.GetDirectory().IsEmpty();
 }
 
 bool HostInfoLinux::ComputeSystemPluginsDirectory(FileSpec &file_spec) {
-  FileSpec temp_file("/usr/lib" LLDB_LIBDIR_SUFFIX "/lldb/plugins");
+  FileSpec temp_file("/usr/" LLDB_INSTALL_LIBDIR_BASENAME "/lldb/plugins");
   FileSystem::Instance().Resolve(temp_file);
   file_spec.SetDirectory(temp_file.GetPath());
   return true;
 }
 
 bool HostInfoLinux::ComputeUserPluginsDirectory(FileSpec &file_spec) {
   // XDG Base Directory Specification
   // http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html If

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

static bool DefaultComputeClangResourceDirectory(FileSpec &lldb_shlib_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);
 
   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.
-      "lib" CLANG_LIBDIR_SUFFIX "/clang/" CLANG_VERSION_STRING,
+      CLANG_INSTALL_LIBDIR_BASENAME "/clang/" CLANG_VERSION_STRING,
       // 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_LIBDIR_SUFFIX.
-      "lib" LLDB_LIBDIR_SUFFIX "/lldb/clang",
+      // 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);
     llvm::SmallString<32> relative_path(Suffix);
     llvm::sys::path::native(relative_path);
     llvm::sys::path::append(clang_dir, relative_path);
     if (!verify || VerifyClangPath(clang_dir)) {

lldb/unittests/Expression/ClangParserTest.cpp

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/lib" LLDB_LIBDIR_SUFFIX "/clang/" CLANG_VERSION_STRING;
+  std::string path_to_clang_dir =
+      "/foo/bar/" LLDB_INSTALL_LIBDIR_BASENAME "/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 not give you path_to_clang_dir.

llvm/utils/gn/secondary/clang/include/clang/Config/BUILD.gn

values = [
     "CLANG_DEFAULT_LINKER=",
     "CLANG_DEFAULT_STD_C=",
     "CLANG_DEFAULT_STD_CXX=",
     "CLANG_DEFAULT_CXX_STDLIB=",
     "CLANG_DEFAULT_RTLIB=",
     "CLANG_DEFAULT_OBJCOPY=objcopy",
     "CLANG_DEFAULT_OPENMP_RUNTIME=libomp",
     "CLANG_DEFAULT_UNWINDLIB=",
+    "CLANG_INSTALL_LIBDIR_BASENAME=lib",
     "CLANG_OPENMP_NVPTX_DEFAULT_ARCH=sm_35",
     "CLANG_LIBDIR_SUFFIX=",
     "CLANG_RESOURCE_DIR=",
     "C_INCLUDE_DIRS=",
     "CLANG_CONFIG_FILE_SYSTEM_DIR=",
     "CLANG_CONFIG_FILE_USER_DIR=",
     "CLANG_SPAWN_CC1=",
     "CLANG_ENABLE_OPAQUE_POINTERS_INTERNAL=1",

llvm/utils/gn/secondary/lldb/include/lldb/Host/BUILD.gn

values = [
     "HAVE_NR_PROCESS_VM_READV=",
     "LLDB_ENABLE_LZMA=",
     "LLDB_ENABLE_CURSES=",
     "CURSES_HAVE_NCURSES_CURSES_H=",
     "LLDB_ENABLE_LUA=",
     "LLDB_ENABLE_PYTHON=",
     "LLDB_ENABLE_FBSDVMCORE=",
     "LLDB_EMBED_PYTHON_HOME=",
+    "LLDB_INSTALL_LIBDIR_BASENAME=lib",
     "LLDB_GLOBAL_INIT_DIRECTORY=",
 
     "LLDB_PYTHON_HOME=",
 
     "LLVM_LIBDIR_SUFFIX=",
 
     "HAVE_LIBCOMPRESSION=",
   ]

utils/bazel/llvm-project-overlay/clang/include/clang/Config/config.h

 #define CLANG_DEFAULT_OPENMP_RUNTIME "libomp"
 
 /* Default architecture for OpenMP offloading to Nvidia GPUs. */
 #define CLANG_OPENMP_NVPTX_DEFAULT_ARCH "sm_35"
 
 /* Default architecture for SystemZ. */
 #define CLANG_SYSTEMZ_DEFAULT_ARCH "z10"
 
-/* Multilib suffix for libdir. */
-#define CLANG_LIBDIR_SUFFIX ""
+/* Multilib basename for libdir. */
+#define CLANG_INSTALL_LIBDIR_BASENAME "lib"
 
 /* Relative directory for resource files */
 #define CLANG_RESOURCE_DIR ""
 
 /* Directories clang will search for headers */
 #define C_INCLUDE_DIRS ""
 
 /* Directories clang will search for configuration files */