[llvm] [runtimes] Common code shared with flang-rt (PR #171610)
Michael Kruse via llvm-commits
llvm-commits at lists.llvm.org
Wed Dec 10 04:54:57 PST 2025
https://github.com/Meinersbur created https://github.com/llvm/llvm-project/pull/171610
Common CMake code to be used by flang-rt and openmp to emit Flang module files. Most of the code is not yet used within this PR.
Extracted out of #171515 for review by @petrhosek.
>From cc7a3242e91940b0bb304917fb03655599e55974 Mon Sep 17 00:00:00 2001
From: Michael Kruse <michael.kruse at amd.com>
Date: Wed, 10 Dec 2025 06:10:43 -0600
Subject: [PATCH 1/3] Move GetToolchainDirs.cmake
---
{flang-rt/cmake/modules => cmake/Modules}/GetToolchainDirs.cmake | 0
1 file changed, 0 insertions(+), 0 deletions(-)
rename {flang-rt/cmake/modules => cmake/Modules}/GetToolchainDirs.cmake (100%)
diff --git a/flang-rt/cmake/modules/GetToolchainDirs.cmake b/cmake/Modules/GetToolchainDirs.cmake
similarity index 100%
rename from flang-rt/cmake/modules/GetToolchainDirs.cmake
rename to cmake/Modules/GetToolchainDirs.cmake
>From 4ff6d124565cac0975951e5b310266543de66fa3 Mon Sep 17 00:00:00 2001
From: Michael Kruse <michael.kruse at amd.com>
Date: Wed, 10 Dec 2025 06:27:32 -0600
Subject: [PATCH 2/3] Backport runtimes files
---
cmake/Modules/GetToolchainDirs.cmake | 11 +
runtimes/CMakeLists.txt | 303 ++++++++++++++++++++++++++-
2 files changed, 303 insertions(+), 11 deletions(-)
diff --git a/cmake/Modules/GetToolchainDirs.cmake b/cmake/Modules/GetToolchainDirs.cmake
index fba12502b5946..ce2f8c294b2bc 100644
--- a/cmake/Modules/GetToolchainDirs.cmake
+++ b/cmake/Modules/GetToolchainDirs.cmake
@@ -47,6 +47,17 @@ function (get_toolchain_library_subdir outvar)
endfunction ()
+# Corresponds to Flang's ToolChain::getDefaultIntrinsicModuleDir().
+function (get_toolchain_module_subdir outvar)
+ set(outval "finclude/flang")
+
+ get_toolchain_arch_dirname(arch_dirname)
+ set(outval "${outval}/${arch_dirname}")
+
+ set(${outvar} "${outval}" PARENT_SCOPE)
+endfunction ()
+
+
# Corresponds to Clang's ToolChain::getOSLibName(). Adapted from Compiler-RT.
function (get_toolchain_os_dirname outvar)
if (ANDROID)
diff --git a/runtimes/CMakeLists.txt b/runtimes/CMakeLists.txt
index 5220b9353fed7..a5bb2d975272e 100644
--- a/runtimes/CMakeLists.txt
+++ b/runtimes/CMakeLists.txt
@@ -85,6 +85,195 @@ include(CheckLibraryExists)
include(LLVMCheckCompilerLinkerFlag)
include(CheckCCompilerFlag)
include(CheckCXXCompilerFlag)
+include(GetToolchainDirs)
+include(ExtendPath)
+
+# Check whether the Fortran compiler already access to builtin modules. Sets
+# HAVE_FORTRAN_INTRINSIC_MODS when returning.
+#
+# This must be wrapped in a function because
+# cmake_push_check_state/cmake_pop_check_state is insufficient to isolate
+# a compiler introspection environment, see
+# https://gitlab.kitware.com/cmake/cmake/-/issues/27419
+function (check_fortran_builtins_available)
+ if (CMAKE_Fortran_COMPILER_FORCED AND CMAKE_Fortran_COMPILER_ID STREQUAL "LLVMFlang")
+ # CMake's try_compile does not take a user-defined
+ # CMAKE_Fortran_PREPROCESS_SOURCE into account. Instead of test-compiling,
+ # ask Flang directly for the builtin module files.
+ if (NOT DEFINED HAVE_FORTRAN_HAS_ISO_C_BINDING_MOD)
+ message(STATUS "Performing Test ISO_C_BINDING_PATH")
+ execute_process(
+ COMMAND ${CMAKE_Fortran_COMPILER} ${CMAKE_Fortran_FLAGS} "-print-file-name=iso_c_binding.mod"
+ OUTPUT_VARIABLE ISO_C_BINDING_PATH
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ ERROR_QUIET
+ )
+ set(HAVE_FORTRAN_HAS_ISO_C_BINDING_MOD "" )
+ if (EXISTS "${ISO_C_BINDING_PATH}")
+ message(STATUS "Performing Test ISO_C_BINDING_PATH -- Success")
+ set(HAVE_FORTRAN_HAS_ISO_C_BINDING_MOD TRUE CACHE INTERNAL "Existence result of ${CMAKE_Fortran_COMPILER} -print-file-name=iso_c_binding.mod")
+ else ()
+ message(STATUS "Performing Test ISO_C_BINDING_PATH -- Failed")
+ set(HAVE_FORTRAN_HAS_ISO_C_BINDING_MOD FALSE CACHE INTERNAL "Existence result of ${CMAKE_Fortran_COMPILER} -print-file-name=iso_c_binding.mod")
+ endif ()
+ endif ()
+ else ()
+ cmake_push_check_state(RESET)
+ set(CMAKE_TRY_COMPILE_TARGET_TYPE "STATIC_LIBRARY")
+ check_fortran_source_compiles("
+ subroutine testroutine
+ use iso_c_binding
+ end subroutine
+ " HAVE_FORTRAN_HAS_ISO_C_BINDING_MOD SRC_EXT F90)
+ cmake_pop_check_state()
+ endif ()
+ set(HAVE_FORTRAN_INTRINSIC_MODS "${HAVE_FORTRAN_HAS_ISO_C_BINDING_MOD}" PARENT_SCOPE)
+endfunction ()
+
+
+# Set options to compile Fortran module files.
+#
+# Usage:
+#
+# flang_module_target(name
+# PUBLIC
+# Modules files are to be used by other Fortran sources. If a library is
+# compiled multiple times (e.g. static/shared, or msvcrt variants), only
+# one of those can be public module files; non-public modules are still
+# generated but to be forgotten deep inside the build directory to not
+# conflict with each other.
+# Also, installs the module with the toolchain.
+# )
+function (flang_module_target tgtname)
+ set(options PUBLIC)
+ cmake_parse_arguments(ARG
+ "${options}"
+ ""
+ ""
+ ${ARGN})
+
+ if (NOT RUNTIMES_FLANG_MODULES_ENABLED)
+ message(WARNING "Cannot build module files for ${tgtname} when RUNTIMES_FLANG_MODULES_ENABLED is ${RUNTIMES_FLANG_MODULES_ENABLED}")
+ return ()
+ endif ()
+
+ target_compile_options(${tgtname} PRIVATE
+ # Let non-public modules find the public module files
+ "$<$<COMPILE_LANGUAGE:Fortran>:-fintrinsic-modules-path=${RUNTIMES_OUTPUT_RESOURCE_MOD_DIR}>"
+
+ # Flang bug workaround: Reformating of cooked token buffer causes identifier to be split between lines
+ "$<$<COMPILE_LANGUAGE:Fortran>:SHELL:-Xflang;SHELL:-fno-reformat>"
+ )
+
+ if (LLVM_RUNTIMES_TARGET MATCHES "^nvptx")
+ foreach (_arch IN LISTS RUNTIMES_DEVICE_ARCHITECTURES)
+ target_compile_options(${tgtname} PRIVATE
+ "$<$<COMPILE_LANGUAGE:Fortran>:-march=${_arch}>"
+ )
+ endforeach()
+ endif ()
+
+ if (ARG_PUBLIC)
+ set_target_properties(${tgtname}
+ PROPERTIES
+ Fortran_MODULE_DIRECTORY "${RUNTIMES_OUTPUT_RESOURCE_MOD_DIR}"
+ )
+ else ()
+ set_target_properties(${tgtname}
+ PROPERTIES
+ Fortran_MODULE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/${tgtname}.mod"
+ )
+ endif ()
+endfunction ()
+
+# Check whether the build environment supports building Fortran modules
+# flang-rt and openmp are the only runtimes that contain Fortran modules.
+set(FORTRAN_MODULE_DEPS "")
+if (CMAKE_Fortran_COMPILER AND ("flang-rt" IN_LIST LLVM_ENABLE_RUNTIMES OR "openmp" IN_LIST LLVM_ENABLE_RUNTIMES))
+ cmake_path(GET CMAKE_Fortran_COMPILER STEM _Fortran_COMPILER_STEM)
+
+ if (_Fortran_COMPILER_STEM STREQUAL "flang-new" OR _Fortran_COMPILER_STEM STREQUAL "flang")
+ # CMake 3.24 is the first version of CMake that directly recognizes Flang.
+ # LLVM's requirement is only CMake 3.20, teach CMake 3.20-3.23 how to use Flang, if used.
+ if (CMAKE_VERSION VERSION_LESS "3.24")
+ include(CMakeForceCompiler)
+ CMAKE_FORCE_Fortran_COMPILER("${CMAKE_Fortran_COMPILER}" "LLVMFlang")
+
+ set(CMAKE_Fortran_COMPILER_ID "LLVMFlang")
+ set(CMAKE_Fortran_COMPILER_VERSION "${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}")
+
+ set(CMAKE_Fortran_SUBMODULE_SEP "-")
+ set(CMAKE_Fortran_SUBMODULE_EXT ".mod")
+
+ set(CMAKE_Fortran_PREPROCESS_SOURCE
+ "<CMAKE_Fortran_COMPILER> -cpp <DEFINES> <INCLUDES> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
+
+ set(CMAKE_Fortran_FORMAT_FIXED_FLAG "-ffixed-form")
+ set(CMAKE_Fortran_FORMAT_FREE_FLAG "-ffree-form")
+
+ set(CMAKE_Fortran_MODDIR_FLAG "-J")
+
+ set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_ON "-cpp")
+ set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_OFF "-nocpp")
+ set(CMAKE_Fortran_POSTPROCESS_FLAG "-ffixed-line-length-72")
+
+ set(CMAKE_Fortran_LINKER_WRAPPER_FLAG "-Wl,")
+ set(CMAKE_Fortran_LINKER_WRAPPER_FLAG_SEP ",")
+
+ set(CMAKE_Fortran_VERBOSE_FLAG "-v")
+
+ set(CMAKE_Fortran_LINK_MODE DRIVER)
+ endif ()
+
+ # Optimization flags are only passed after CMake 3.27.4
+ # https://gitlab.kitware.com/cmake/cmake/-/commit/1140087adea98bd8d8974e4c18979f4949b52c34
+ if (CMAKE_VERSION VERSION_LESS "3.27.4")
+ string(APPEND CMAKE_Fortran_FLAGS_DEBUG_INIT " -O0 -g")
+ string(APPEND CMAKE_Fortran_FLAGS_RELWITHDEBINFO_INIT " -O2 -g")
+ string(APPEND CMAKE_Fortran_FLAGS_RELEASE_INIT " -O3")
+ endif ()
+
+ # Only CMake 3.28+ pass --target= to Flang. But for cross-compiling, including
+ # to nvptx amd amdgpu targets, passing the target triple is essential.
+ # https://gitlab.kitware.com/cmake/cmake/-/commit/e9af7b968756e72553296ecdcde6f36606a0babf
+ if (CMAKE_VERSION VERSION_LESS "3.28")
+ set(CMAKE_Fortran_COMPILE_OPTIONS_TARGET "--target=")
+ endif ()
+ endif ()
+
+ include(CheckFortranSourceCompiles)
+ include(CheckLanguage)
+
+ set(RUNTIMES_FLANG_MODULES_ENABLED_default OFF)
+ check_language(Fortran)
+ if (CMAKE_Fortran_COMPILER)
+ enable_language(Fortran)
+
+ if (CMAKE_Fortran_COMPILER_ID STREQUAL "LLVMFlang" AND "flang-rt" IN_LIST LLVM_ENABLE_RUNTIMES)
+ # In a bootstrapping build (or any runtimes-build that includes flang-rt),
+ # the intrinsic modules are not built yet. Targets can depend on
+ # flang-rt-mod to ensure that flang-rt's modules are built first.
+ set(FORTRAN_MODULE_DEPS flang-rt-mod)
+ set(RUNTIMES_FLANG_MODULES_ENABLED_default ON)
+ else ()
+ # Check whether building modules works, avoid causing the entire build to
+ # fail because of Fortran. The primary situation we want to support here
+ # is Flang, or its intrinsic modules were built separately in a
+ # non-bootstrapping build.
+ check_fortran_builtins_available()
+ if (HAVE_FORTRAN_INTRINSIC_MODS)
+ set(RUNTIMES_FLANG_MODULES_ENABLED_default ON)
+ message(STATUS "${LLVM_SUBPROJECT_TITLE}: Non-bootstrapping Fortran modules build (${CMAKE_Fortran_COMPILER_ID} located at ${CMAKE_Fortran_COMPILER})")
+ else ()
+ message(STATUS "Not compiling Flang modules: Not passing smoke check")
+ endif ()
+ endif ()
+ endif ()
+
+ option(RUNTIMES_FLANG_MODULES_ENABLED "Build Fortran modules" "${RUNTIMES_FLANG_MODULES_ENABLED_default}")
+else ()
+ set(RUNTIMES_FLANG_MODULES_ENABLED NO)
+endif ()
# Determine whether we are in the runtimes/runtimes-bins directory of a
@@ -94,17 +283,6 @@ if (LLVM_LIBRARY_DIR AND LLVM_TOOLS_BINARY_DIR AND PACKAGE_VERSION)
set(LLVM_TREE_AVAILABLE ON)
endif()
-if(LLVM_TREE_AVAILABLE)
- # Setting these variables will allow the sub-build to put their outputs into
- # the library and bin directories of the top-level build.
- set(LLVM_LIBRARY_OUTPUT_INTDIR ${LLVM_LIBRARY_DIR})
- set(LLVM_RUNTIME_OUTPUT_INTDIR ${LLVM_TOOLS_BINARY_DIR})
-else()
- # Use own build directory for artifact output.
- set(LLVM_LIBRARY_OUTPUT_INTDIR "${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX}")
- set(LLVM_RUNTIME_OUTPUT_INTDIR "${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin")
-endif()
-
# CMake omits default compiler include paths, but in runtimes build, we use
# -nostdinc and -nostdinc++ and control include paths manually so this behavior
# is undesirable. Filtering CMAKE_{LANG}_IMPLICIT_INCLUDE_DIRECTORIES to remove
@@ -236,6 +414,109 @@ if(CMAKE_C_COMPILER_ID MATCHES "Clang")
endif()
endif()
+# Determine output and install paths based on LLVM_TARGET_TRIPLE
+if(LLVM_TREE_AVAILABLE)
+ # In a bootstrap build emit the libraries into a default search path in the
+ # build directory of the just-built compiler. This allows using the
+ # just-built compiler without specifying paths to runtime libraries.
+ # LLVM_LIBRARY_OUTPUT_INTDIR/LLVM_RUNTIME_OUTPUT_INTDIR is used by
+ # AddLLVM.cmake as artifact output locations.
+ set(LLVM_LIBRARY_OUTPUT_INTDIR ${LLVM_LIBRARY_DIR})
+ set(LLVM_RUNTIME_OUTPUT_INTDIR ${LLVM_TOOLS_BINARY_DIR})
+
+ # Despite Clang in the name, get_clang_resource_dir does not depend on Clang
+ # being added to the build. Flang uses the same resource dir as Clang.
+ include(GetClangResourceDir)
+ get_clang_resource_dir(RUNTIMES_OUTPUT_RESOURCE_DIR PREFIX "${LLVM_LIBRARY_OUTPUT_INTDIR}/..")
+ get_clang_resource_dir(RUNTIMES_INSTALL_RESOURCE_PATH_DEFAULT)
+else()
+ # In a standalone runtimes build, do not write into LLVM_BINARY_DIR. It may be
+ # read-only and/or shared by multiple runtimes with different build
+ # configurations (e.g. Debug/Release). Use the runtime's own lib dir like any
+ # non-toolchain library. Use own build directory for artifact output.
+ set(LLVM_LIBRARY_OUTPUT_INTDIR "${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX}")
+ set(LLVM_RUNTIME_OUTPUT_INTDIR "${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin")
+
+ # For the install prefix, still use the resource dir assuming that Flang will
+ # be installed there using the same prefix. This is to not have a difference
+ # between bootstrap and standalone runtimes builds.
+ set(RUNTIMES_OUTPUT_RESOURCE_DIR "${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX}/clang/${LLVM_VERSION_MAJOR}")
+ set(RUNTIMES_INSTALL_RESOURCE_PATH_DEFAULT "lib${LLVM_LIBDIR_SUFFIX}/clang/${LLVM_VERSION_MAJOR}")
+endif()
+
+# Determine build and install paths.
+# The build path is absolute, but the install dir is relative, CMake's install
+# command has to apply CMAKE_INSTALL_PREFIX itself.
+# FIXME: For shared libraries, the toolchain resource lib dir is not a good
+# destination because it is not a ld.so default search path.
+# The machine where the executable is eventually executed may not be the
+# machine where the Flang compiler and its resource dir is installed, so
+# setting RPath by the driver is not an solution. It should belong into
+# /usr/lib/<triple>/lib<name>.so, like e.g. libgcc_s.so.
+# But the linker as invoked by the Flang driver also requires
+# libflang_rt.so to be found when linking and the resource lib dir is
+# the only reliable location.
+get_toolchain_library_subdir(toolchain_lib_subdir)
+extend_path(RUNTIMES_OUTPUT_RESOURCE_LIB_DIR "${RUNTIMES_OUTPUT_RESOURCE_DIR}" "${toolchain_lib_subdir}")
+
+set(RUNTIMES_INSTALL_RESOURCE_PATH "${RUNTIMES_INSTALL_RESOURCE_PATH_DEFAULT}" CACHE PATH "Path to install headers, runtime libraries, and Fortran modules to (default: Clang resource dir)")
+extend_path(RUNTIMES_INSTALL_RESOURCE_LIB_PATH "${RUNTIMES_INSTALL_RESOURCE_PATH}" "${toolchain_lib_subdir}")
+
+cmake_path(NORMAL_PATH RUNTIMES_OUTPUT_RESOURCE_DIR)
+cmake_path(NORMAL_PATH RUNTIMES_INSTALL_RESOURCE_PATH)
+cmake_path(NORMAL_PATH RUNTIMES_OUTPUT_RESOURCE_LIB_DIR)
+cmake_path(NORMAL_PATH RUNTIMES_INSTALL_RESOURCE_LIB_PATH)
+
+
+if (RUNTIMES_FLANG_MODULES_ENABLED)
+ if (CMAKE_Fortran_COMPILER_ID STREQUAL "LLVMFlang")
+ # Flang expects its builtin modules in Clang's resource directory
+ get_toolchain_module_subdir(toolchain_mod_subdir)
+ extend_path(RUNTIMES_OUTPUT_RESOURCE_MOD_DIR "${RUNTIMES_OUTPUT_RESOURCE_DIR}" "${toolchain_mod_subdir}")
+ extend_path(RUNTIMES_INSTALL_RESOURCE_MOD_PATH "${RUNTIMES_INSTALL_RESOURCE_PATH}" "${toolchain_mod_subdir}")
+ else ()
+ # For non-Flang compilers, avoid the risk of Flang accidentally picking them up.
+ extend_path(RUNTIMES_OUTPUT_RESOURCE_MOD_DIR "${RUNTIMES_OUTPUT_RESOURCE_DIR}" "finclude-${CMAKE_Fortran_COMPILER_ID}")
+ extend_path(RUNTIMES_INSTALL_RESOURCE_MOD_PATH "${RUNTIMES_INSTALL_RESOURCE_PATH}" "finclude-${CMAKE_Fortran_COMPILER_ID}")
+ endif ()
+ cmake_path(NORMAL_PATH RUNTIMES_OUTPUT_RESOURCE_MOD_DIR)
+ cmake_path(NORMAL_PATH RUNTIMES_INSTALL_RESOURCE_MOD_PATH)
+
+ # No way to find out which mod files are built by a target, so install the
+ # entire output directory
+ # https://stackoverflow.com/questions/52712416/cmake-fortran-module-directory-to-be-used-with-add-library
+ set(destination "${RUNTIMES_INSTALL_RESOURCE_MOD_PATH}/..")
+ cmake_path(NORMAL_PATH destination)
+ install(DIRECTORY "${RUNTIMES_OUTPUT_RESOURCE_MOD_DIR}"
+ DESTINATION "${destination}"
+ )
+endif ()
+
+
+if (RUNTIMES_FLANG_MODULES_ENABLED)
+ set(RUNTIMES_DEVICE_ARCHITECTURES "all" CACHE STRING
+ "List of offload device architectures to be used to compile the Fortran offload code (e.g. 'gfx1103;sm_90')"
+ )
+
+ if (RUNTIMES_DEVICE_ARCHITECTURES STREQUAL "all")
+ # TODO: support auto detection on the build system.
+ set(all_amdgpu_architectures
+ "gfx700;gfx701;gfx801;gfx803;gfx900;gfx902;gfx906"
+ "gfx908;gfx90a;gfx90c;gfx940;gfx1010;gfx1030"
+ "gfx1031;gfx1032;gfx1033;gfx1034;gfx1035;gfx1036"
+ "gfx1100;gfx1101;gfx1102;gfx1103;gfx1150;gfx1151"
+ "gfx1152;gfx1153")
+ set(all_nvptx_architectures
+ "sm_35;sm_37;sm_50;sm_52;sm_53;sm_60;sm_61;sm_62"
+ "sm_70;sm_72;sm_75;sm_80;sm_86;sm_89;sm_90")
+ set(all_gpu_architectures
+ "${all_amdgpu_architectures};${all_nvptx_architectures}")
+ set(RUNTIMES_DEVICE_ARCHITECTURES ${all_gpu_architectures})
+ endif()
+ list(REMOVE_DUPLICATES RUNTIMES_DEVICE_ARCHITECTURES)
+endif ()
+
+
option(LLVM_INCLUDE_TESTS "Generate build targets for the runtimes unit tests." ON)
option(LLVM_INCLUDE_DOCS "Generate build targets for the runtimes documentation." ON)
option(LLVM_ENABLE_SPHINX "Use Sphinx to generate the runtimes documentation." OFF)
>From d4b194d6ce7e11fb565a41a78bbe0d459bea09fd Mon Sep 17 00:00:00 2001
From: Michael Kruse <michael.kruse at amd.com>
Date: Wed, 10 Dec 2025 06:45:31 -0600
Subject: [PATCH 3/3] Avoid redundancies in flang-rt CMakeLists.txt
---
flang-rt/CMakeLists.txt | 90 +------------------------
flang-rt/cmake/modules/AddFlangRT.cmake | 8 +--
flang-rt/test/lit.site.cfg.py.in | 2 +-
3 files changed, 6 insertions(+), 94 deletions(-)
diff --git a/flang-rt/CMakeLists.txt b/flang-rt/CMakeLists.txt
index 50b8e834776fb..1e492d9c4feb8 100644
--- a/flang-rt/CMakeLists.txt
+++ b/flang-rt/CMakeLists.txt
@@ -23,41 +23,6 @@ set(FLANG_RT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
set(FLANG_RT_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")
set(FLANG_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../flang")
-# CMake 3.24 is the first version of CMake that directly recognizes Flang.
-# LLVM's requirement is only CMake 3.20, teach CMake 3.20-3.23 how to use Flang.
-if (CMAKE_VERSION VERSION_LESS "3.24")
- cmake_path(GET CMAKE_Fortran_COMPILER STEM _Fortran_COMPILER_STEM)
- if (_Fortran_COMPILER_STEM STREQUAL "flang-new" OR _Fortran_COMPILER_STEM STREQUAL "flang")
- include(CMakeForceCompiler)
- CMAKE_FORCE_Fortran_COMPILER("${CMAKE_Fortran_COMPILER}" "LLVMFlang")
-
- set(CMAKE_Fortran_COMPILER_ID "LLVMFlang")
- set(CMAKE_Fortran_COMPILER_VERSION "${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}")
-
- set(CMAKE_Fortran_SUBMODULE_SEP "-")
- set(CMAKE_Fortran_SUBMODULE_EXT ".mod")
-
- set(CMAKE_Fortran_PREPROCESS_SOURCE
- "<CMAKE_Fortran_COMPILER> -cpp <DEFINES> <INCLUDES> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
-
- set(CMAKE_Fortran_FORMAT_FIXED_FLAG "-ffixed-form")
- set(CMAKE_Fortran_FORMAT_FREE_FLAG "-ffree-form")
-
- set(CMAKE_Fortran_MODDIR_FLAG "-module-dir")
-
- set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_ON "-cpp")
- set(CMAKE_Fortran_COMPILE_OPTIONS_PREPROCESS_OFF "-nocpp")
- set(CMAKE_Fortran_POSTPROCESS_FLAG "-ffixed-line-length-72")
-
- set(CMAKE_Fortran_COMPILE_OPTIONS_TARGET "--target=")
-
- set(CMAKE_Fortran_LINKER_WRAPPER_FLAG "-Wl,")
- set(CMAKE_Fortran_LINKER_WRAPPER_FLAG_SEP ",")
- endif ()
-endif ()
-enable_language(Fortran)
-
-
list(APPEND CMAKE_MODULE_PATH
"${FLANG_RT_SOURCE_DIR}/cmake/modules"
"${FLANG_SOURCE_DIR}/cmake/modules"
@@ -73,62 +38,9 @@ include(ExtendPath)
# Build Mode Introspection #
############################
-# Determine whether we are in the runtimes/runtimes-bins directory of a
-# bootstrap build.
-set(LLVM_TREE_AVAILABLE OFF)
-if (LLVM_LIBRARY_OUTPUT_INTDIR AND LLVM_RUNTIME_OUTPUT_INTDIR AND PACKAGE_VERSION)
- set(LLVM_TREE_AVAILABLE ON)
-endif()
-
# Path to LLVM development tools (FileCheck, llvm-lit, not, ...)
set(LLVM_TOOLS_DIR "${LLVM_BINARY_DIR}/bin")
-# Determine build and install paths.
-# The build path is absolute, but the install dir is relative, CMake's install
-# command has to apply CMAKE_INSTALL_PREFIX itself.
-get_toolchain_library_subdir(toolchain_lib_subdir)
-if (LLVM_TREE_AVAILABLE)
- # In a bootstrap build emit the libraries into a default search path in the
- # build directory of the just-built compiler. This allows using the
- # just-built compiler without specifying paths to runtime libraries.
- #
- # Despite Clang in the name, get_clang_resource_dir does not depend on Clang
- # being added to the build. Flang uses the same resource dir as clang.
- include(GetClangResourceDir)
- get_clang_resource_dir(FLANG_RT_OUTPUT_RESOURCE_DIR PREFIX "${LLVM_LIBRARY_OUTPUT_INTDIR}/..")
- get_clang_resource_dir(FLANG_RT_INSTALL_RESOURCE_PATH_DEFAULT)
-
- extend_path(FLANG_RT_OUTPUT_RESOURCE_LIB_DIR "${FLANG_RT_OUTPUT_RESOURCE_DIR}" "${toolchain_lib_subdir}")
-else ()
- # In a standalone runtimes build, do not write into LLVM_BINARY_DIR. It may be
- # read-only and/or shared by multiple runtimes with different build
- # configurations (e.g. Debug/Release). Use the runtime's own lib dir like any
- # non-toolchain library.
- # For the install prefix, still use the resource dir assuming that Flang will
- # be installed there using the same prefix. This is to not have a difference
- # between bootstrap and standalone runtimes builds.
- set(FLANG_RT_OUTPUT_RESOURCE_DIR "${CMAKE_CURRENT_BINARY_DIR}")
- set(FLANG_RT_INSTALL_RESOURCE_PATH_DEFAULT "lib${LLVM_LIBDIR_SUFFIX}/clang/${LLVM_VERSION_MAJOR}")
-
- extend_path(FLANG_RT_OUTPUT_RESOURCE_LIB_DIR "${FLANG_RT_OUTPUT_RESOURCE_DIR}" "lib${LLVM_LIBDIR_SUFFIX}")
-endif ()
-set(FLANG_RT_INSTALL_RESOURCE_PATH "${FLANG_RT_INSTALL_RESOURCE_PATH_DEFAULT}"
- CACHE PATH "Path to install runtime libraries to (default: clang resource dir)")
-extend_path(FLANG_RT_INSTALL_RESOURCE_LIB_PATH "${FLANG_RT_INSTALL_RESOURCE_PATH}" "${toolchain_lib_subdir}")
-cmake_path(NORMAL_PATH FLANG_RT_OUTPUT_RESOURCE_DIR)
-cmake_path(NORMAL_PATH FLANG_RT_INSTALL_RESOURCE_PATH)
-# FIXME: For the libflang_rt.so, the toolchain resource lib dir is not a good
-# destination because it is not a ld.so default search path.
-# The machine where the executable is eventually executed may not be the
-# machine where the Flang compiler and its resource dir is installed, so
-# setting RPath by the driver is not an solution. It should belong into
-# /usr/lib/<triple>/libflang_rt.so, like e.g. libgcc_s.so.
-# But the linker as invoked by the Flang driver also requires
-# libflang_rt.so to be found when linking and the resource lib dir is
-# the only reliable location.
-cmake_path(NORMAL_PATH FLANG_RT_OUTPUT_RESOURCE_LIB_DIR)
-cmake_path(NORMAL_PATH FLANG_RT_INSTALL_RESOURCE_LIB_PATH)
-
#################
# Build Options #
@@ -186,7 +98,7 @@ elseif (FLANG_RT_EXPERIMENTAL_OFFLOAD_SUPPORT STREQUAL "CUDA")
option(FLANG_RT_CUDA_RUNTIME_PTX_WITHOUT_GLOBAL_VARS "Do not compile global variables' definitions when producing PTX library" OFF)
elseif (FLANG_RT_EXPERIMENTAL_OFFLOAD_SUPPORT STREQUAL "OpenMP")
# Support for OpenMP offloading
- set(FLANG_RT_DEVICE_ARCHITECTURES "all" CACHE STRING
+ set(FLANG_RT_DEVICE_ARCHITECTURES "${RUNTIMES_DEVICE_ARCHITECTURES}" CACHE STRING
"List of OpenMP device architectures to be used to compile the Fortran runtime (e.g. 'gfx1103;sm_90')"
)
diff --git a/flang-rt/cmake/modules/AddFlangRT.cmake b/flang-rt/cmake/modules/AddFlangRT.cmake
index 923507764d691..e960e79473cbb 100644
--- a/flang-rt/cmake/modules/AddFlangRT.cmake
+++ b/flang-rt/cmake/modules/AddFlangRT.cmake
@@ -344,13 +344,13 @@ function (add_flangrt_library name)
if (ARG_INSTALL_WITH_TOOLCHAIN)
set_target_properties(${tgtname}
PROPERTIES
- ARCHIVE_OUTPUT_DIRECTORY "${FLANG_RT_OUTPUT_RESOURCE_LIB_DIR}"
- LIBRARY_OUTPUT_DIRECTORY "${FLANG_RT_OUTPUT_RESOURCE_LIB_DIR}"
+ ARCHIVE_OUTPUT_DIRECTORY "${RUNTIMES_OUTPUT_RESOURCE_LIB_DIR}"
+ LIBRARY_OUTPUT_DIRECTORY "${RUNTIMES_OUTPUT_RESOURCE_LIB_DIR}"
)
install(TARGETS ${tgtname}
- ARCHIVE DESTINATION "${FLANG_RT_INSTALL_RESOURCE_LIB_PATH}"
- LIBRARY DESTINATION "${FLANG_RT_INSTALL_RESOURCE_LIB_PATH}"
+ ARCHIVE DESTINATION "${RUNTIMES_INSTALL_RESOURCE_LIB_PATH}"
+ LIBRARY DESTINATION "${RUNTIMES_INSTALL_RESOURCE_LIB_PATH}"
)
endif ()
diff --git a/flang-rt/test/lit.site.cfg.py.in b/flang-rt/test/lit.site.cfg.py.in
index 662d076b1fe24..0e9dc08b59925 100644
--- a/flang-rt/test/lit.site.cfg.py.in
+++ b/flang-rt/test/lit.site.cfg.py.in
@@ -6,7 +6,7 @@ config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
config.flang_source_dir = "@FLANG_SOURCE_DIR@"
config.flang_rt_source_dir = "@FLANG_RT_SOURCE_DIR@"
config.flang_rt_binary_test_dir = os.path.dirname(__file__)
-config.flang_rt_output_resource_lib_dir = "@FLANG_RT_OUTPUT_RESOURCE_LIB_DIR@"
+config.flang_rt_output_resource_lib_dir = "@RUNTIMES_OUTPUT_RESOURCE_LIB_DIR@"
config.flang_rt_experimental_offload_support = "@FLANG_RT_EXPERIMENTAL_OFFLOAD_SUPPORT@"
config.cc = "@CMAKE_C_COMPILER@"
config.flang = "@CMAKE_Fortran_COMPILER@"
More information about the llvm-commits
mailing list