shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[Flang-RT] Build libflang_rt.so (#121782)

Browse Source 
Under non-Windows platforms, also create a dynamic library version of
the runtime. Build of either version of the library can be switched on
using FLANG_RT_ENABLE_STATIC=ON respectively FLANG_RT_ENABLE_SHARED=ON.
Default is to build only the static library, consistent with previous
behaviour. This is because the way the flang driver invokes the linker,
most linkers choose the dynamic library by default, if available.
Building the dynamic library therefore causes flang-built executables to
depend on `libflang_rt.so`, unless explicitly told otherwise.
This commit is contained in:
Michael Kruse 2025-02-17 12:53:12 +01:00 committed by GitHub
parent 43d308dd0d
commit 4c4fc4650f
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
9 changed files with 311 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
flang-rt/CMakeLists.txt
View File

@ -115,6 +115,15 @@ endif ()
extend_path(FLANG_RT_INSTALL_RESOURCE_LIB_PATH "${FLANG_RT_INSTALL_RESOURCE_PATH}" "${toolchain_lib_subdir}") 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_OUTPUT_RESOURCE_DIR)
cmake_path(NORMAL_PATH FLANG_RT_INSTALL_RESOURCE_PATH) 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_OUTPUT_RESOURCE_LIB_DIR)
cmake_path(NORMAL_PATH FLANG_RT_INSTALL_RESOURCE_LIB_PATH) cmake_path(NORMAL_PATH FLANG_RT_INSTALL_RESOURCE_LIB_PATH)
@ -129,6 +138,27 @@ cmake_path(NORMAL_PATH FLANG_RT_INSTALL_RESOURCE_LIB_PATH)
option(FLANG_RT_INCLUDE_TESTS "Generate build targets for the flang-rt unit and regression-tests." "${LLVM_INCLUDE_TESTS}") option(FLANG_RT_INCLUDE_TESTS "Generate build targets for the flang-rt unit and regression-tests." "${LLVM_INCLUDE_TESTS}")
option(FLANG_RT_ENABLE_STATIC "Build Flang-RT as a static library." ON)
if (WIN32)
# Windows DLL currently not implemented.
set(FLANG_RT_ENABLE_SHARED OFF)
else ()
# TODO: Enable by default to increase test coverage, and which version of the
# library should be the user's choice anyway.
# Currently, the Flang driver adds `-L"libdir" -lflang_rt` as linker
# argument, which leaves the choice which library to use to the linker.
# Since most linkers prefer the shared library, this would constitute a
# breaking change unless the driver is changed.
option(FLANG_RT_ENABLE_SHARED "Build Flang-RT as a shared library." OFF)
endif ()
if (NOT FLANG_RT_ENABLE_STATIC AND NOT FLANG_RT_ENABLE_SHARED)
message(FATAL_ERROR "
Must build at least one type of library
(FLANG_RT_ENABLE_STATIC=ON, FLANG_RT_ENABLE_SHARED=ON, or both)
")
endif ()
set(FLANG_RT_EXPERIMENTAL_OFFLOAD_SUPPORT "" CACHE STRING "Compile Flang-RT with GPU support (CUDA or OpenMP)") set(FLANG_RT_EXPERIMENTAL_OFFLOAD_SUPPORT "" CACHE STRING "Compile Flang-RT with GPU support (CUDA or OpenMP)")
set_property(CACHE FLANG_RT_EXPERIMENTAL_OFFLOAD_SUPPORT PROPERTY STRINGS set_property(CACHE FLANG_RT_EXPERIMENTAL_OFFLOAD_SUPPORT PROPERTY STRINGS
"" ""

362
flang-rt/cmake/modules/AddFlangRT.cmake
View File

@ -16,7 +16,8 @@
# STATIC # STATIC
# Build a static (.a/.lib) library # Build a static (.a/.lib) library
# OBJECT # OBJECT
# Create only object files without static/dynamic library # Always create an object library.
# Without SHARED/STATIC, build only the object library.
# INSTALL_WITH_TOOLCHAIN # INSTALL_WITH_TOOLCHAIN
# Install library into Clang's resource directory so it can be found by the # Install library into Clang's resource directory so it can be found by the
# Flang driver during compilation, including tests # Flang driver during compilation, including tests
@ -50,17 +51,73 @@ function (add_flangrt_library name)
") ")
endif () endif ()
# Forward libtype to add_library # Internal names of libraries. If called with just single type option, use
set(extra_args "") # the default name for it. Name of targets must only depend on function
if (ARG_SHARED) # arguments to be predictable for callers.
list(APPEND extra_args SHARED) set(name_static "${name}.static")
set(name_shared "${name}.shared")
set(name_object "obj.${name}")
if (ARG_STATIC AND NOT ARG_SHARED)
set(name_static "${name}")
elseif (NOT ARG_STATIC AND ARG_SHARED)
set(name_shared "${name}")
elseif (NOT ARG_STATIC AND NOT ARG_SHARED AND ARG_OBJECT)
set(name_object "${name}")
elseif (NOT ARG_STATIC AND NOT ARG_SHARED AND NOT ARG_OBJECT)
# Only one of them will actually be built.
set(name_static "${name}")
set(name_shared "${name}")
endif () endif ()
if (ARG_STATIC)
list(APPEND extra_args STATIC) # Determine what to build. If not explicitly specified, honor
# BUILD_SHARED_LIBS (e.g. for unittest libraries). If can build static and
# shared, use ENABLE_STATIC/ENABLE_SHARED setting.
if (ARG_STATIC AND ARG_SHARED)
set(build_static ${FLANG_RT_ENABLE_STATIC})
set(build_shared ${FLANG_RT_ENABLE_SHARED})
else ()
set(build_static ${ARG_STATIC})
set(build_shared ${ARG_SHARED})
endif () endif ()
if (NOT ARG_STATIC AND NOT ARG_SHARED AND NOT ARG_OBJECT)
if (BUILD_SHARED_LIBS)
set(build_shared ON)
else ()
set(build_static ON)
endif ()
endif ()
# Build an object library if building multiple libraries at once or if
# explicitly requested.
set(build_object OFF)
if (ARG_OBJECT) if (ARG_OBJECT)
list(APPEND extra_args OBJECT) set(build_object ON)
elseif (build_static AND build_shared)
set(build_object ON)
endif () endif ()
# srctargets: targets that contain source files
# libtargets: static/shared if they are built
# alltargets: any add_library target added by this function
set(srctargets "")
set(libtargets "")
set(alltargets "")
if (build_static)
list(APPEND srctargets "${name_static}")
list(APPEND libtargets "${name_static}")
list(APPEND alltargets "${name_static}")
endif ()
if (build_shared)
list(APPEND srctargets "${name_shared}")
list(APPEND libtargets "${name_shared}")
list(APPEND alltargets "${name_shared}")
endif ()
if (build_object)
set(srctargets "${name_object}")
list(APPEND alltargets "${name_object}")
endif ()
set(extra_args "")
if (ARG_EXCLUDE_FROM_ALL) if (ARG_EXCLUDE_FROM_ALL)
list(APPEND extra_args EXCLUDE_FROM_ALL) list(APPEND extra_args EXCLUDE_FROM_ALL)
endif () endif ()
@ -68,132 +125,191 @@ function (add_flangrt_library name)
# Also add header files to IDEs to list as part of the library. # Also add header files to IDEs to list as part of the library.
set_source_files_properties(${ARG_ADDITIONAL_HEADERS} PROPERTIES HEADER_FILE_ONLY ON) set_source_files_properties(${ARG_ADDITIONAL_HEADERS} PROPERTIES HEADER_FILE_ONLY ON)
add_library(${name} ${extra_args} ${ARG_ADDITIONAL_HEADERS} ${ARG_UNPARSED_ARGUMENTS}) # Create selected library types.
if (build_object)
if (ARG_INSTALL_WITH_TOOLCHAIN) add_library("${name_object}" OBJECT ${extra_args} ${ARG_ADDITIONAL_HEADERS} ${ARG_UNPARSED_ARGUMENTS})
set_target_properties(${name} PROPERTIES FOLDER "Flang-RT/Toolchain Libraries") set_target_properties(${name_object} PROPERTIES
elseif (ARG_OBJECT) POSITION_INDEPENDENT_CODE ON
set_target_properties(${name} PROPERTIES FOLDER "Flang-RT/Object Libraries") FOLDER "Flang-RT/Object Libraries"
else ()
set_target_properties(${name} PROPERTIES FOLDER "Flang-RT/Libraries")
endif ()
# Minimum required C++ version for Flang-RT, even if CMAKE_CXX_STANDARD is defined to something else.
target_compile_features(${name} PRIVATE cxx_std_17)
# Use compiler-specific options to disable exceptions and RTTI.
if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
target_compile_options(${name} PRIVATE
$<$<COMPILE_LANGUAGE:CXX>:-fno-exceptions -fno-rtti -fno-unwind-tables -fno-asynchronous-unwind-tables>
)
elseif (MSVC)
target_compile_options(${name} PRIVATE
$<$<COMPILE_LANGUAGE:CXX>:/EHs-c- /GR->
)
elseif (CMAKE_CXX_COMPILER_ID MATCHES "XL")
target_compile_options(${name} PRIVATE
$<$<COMPILE_LANGUAGE:CXX>:-qnoeh -qnortti>
) )
# Replace arguments for the libraries we are going to create.
set(ARG_ADDITIONAL_HEADERS "")
set(ARG_UNPARSED_ARGUMENTS "$<TARGET_OBJECTS:${name_object}>")
endif ()
if (build_static)
add_library("${name_static}" STATIC ${extra_args} ${ARG_ADDITIONAL_HEADERS} ${ARG_UNPARSED_ARGUMENTS})
endif ()
if (build_shared)
add_library("${name_shared}" SHARED ${extra_args} ${ARG_ADDITIONAL_HEADERS} ${ARG_UNPARSED_ARGUMENTS})
endif () endif ()
# Also for CUDA source when compiling with FLANG_RT_EXPERIMENTAL_OFFLOAD_SUPPORT=CUDA if (libtargets)
if (CMAKE_CUDA_COMPILER_ID MATCHES "NVIDIA") # Provide a default alias which exists in either setting.
# Assuming gcc as host compiler. if (BUILD_SHARED_LIBS)
target_compile_options(${name} PRIVATE if (build_shared)
$<$<COMPILE_LANGUAGE:CUDA>:--no-exceptions -Xcompiler -fno-rtti -Xcompiler -fno-unwind-tables -Xcompiler -fno-asynchronous-unwind-tables> set(default_target "${name_shared}")
) else ()
else () set(default_target "${name_static}")
# Assuming a clang-compatible CUDA compiler. endif ()
target_compile_options(${name} PRIVATE
$<$<COMPILE_LANGUAGE:CUDA>:-fno-exceptions -fno-rtti -fno-unwind-tables -fno-asynchronous-unwind-tables>
)
endif ()
# Flang-RT's public headers
target_include_directories(${name} PUBLIC "${FLANG_RT_SOURCE_DIR}/include")
# For ISO_Fortran_binding.h to be found by the runtime itself (Accessed as #include "flang/ISO_Fortran_binding.h")
# User applications can use #include <ISO_Fortran_binding.h>
target_include_directories(${name} PUBLIC "${FLANG_SOURCE_DIR}/include")
# For Flang-RT's configured config.h to be found
target_include_directories(${name} PRIVATE "${FLANG_RT_BINARY_DIR}")
# Disable libstdc++/libc++ assertions, even in an LLVM_ENABLE_ASSERTIONS
# build, to avoid an unwanted dependency on libstdc++/libc++.so.
if (FLANG_RT_SUPPORTS_UNDEFINE_FLAG)
target_compile_options(${name} PUBLIC -U_GLIBCXX_ASSERTIONS)
target_compile_options(${name} PUBLIC -U_LIBCPP_ENABLE_ASSERTIONS)
endif ()
# When building the flang runtime if LTO is enabled the archive file
# contains LLVM IR rather than object code. Currently flang is not
# LTO aware so cannot link this file to compiled Fortran code.
if (FLANG_RT_HAS_FNO_LTO_FLAG)
target_compile_options(${name} PRIVATE -fno-lto)
endif ()
# Flang/Clang (including clang-cl) -compiled programs targeting the MSVC ABI
# should only depend on msvcrt/ucrt. LLVM still emits libgcc/compiler-rt
# functions in some cases like 128-bit integer math (__udivti3, __modti3,
# __fixsfti, __floattidf, ...) that msvc does not support. We are injecting a
# dependency to Compiler-RT's builtin library where these are implemented.
if (MSVC AND CMAKE_CXX_COMPILER_ID MATCHES "Clang")
if (FLANG_RT_BUILTINS_LIBRARY)
target_compile_options(${name} PRIVATE "$<$<COMPILE_LANGUAGE:CXX,C>:-Xclang>" "$<$<COMPILE_LANGUAGE:CXX,C>:--dependent-lib=${FLANG_RT_BUILTINS_LIBRARY}>")
endif ()
endif ()
if (MSVC AND CMAKE_Fortran_COMPILER_ID STREQUAL "LLVMFlang")
if (FLANG_RT_BUILTINS_LIBRARY)
target_compile_options(${name} PRIVATE "$<$<COMPILE_LANGUAGE:Fortran>:-Xflang>" "$<$<COMPILE_LANGUAGE:Fortran>:--dependent-lib=${FLANG_RT_BUILTINS_LIBRARY}>")
else () else ()
message(WARNING "Did not find libclang_rt.builtins.lib. if (build_static)
LLVM may emit builtins that are not implemented in msvcrt/ucrt and set(default_target "${name_static}")
instead falls back to builtins from Compiler-RT. Linking with ${name} else ()
may result in a linker error.") set(default_target "${name_shared}")
endif ()
endif ()
add_library(${name}.default ALIAS "${default_target}")
# Provide a build target that builds any enabled library.
# Not intended for target_link_libraries. Either use the ${name}.static,
# ${name}.shared variants, or ${name}.default to let BUILD_SHARED_LIBS
# decide.
if (NOT TARGET ${name})
add_custom_target(${name})
add_dependencies(${name} ${libtargets})
endif () endif ()
endif () endif ()
# Non-GTest unittests depend on LLVMSupport foreach (tgtname IN LISTS libtargets)
if (ARG_LINK_TO_LLVM) if (NOT WIN32)
if (LLVM_LINK_LLVM_DYLIB) # Use same stem name for .a and .so. Common in UNIX environments.
set(llvm_libs LLVM) # Not possible in Windows environments.
else() set_target_properties(${tgtname} PROPERTIES OUTPUT_NAME "${name}")
llvm_map_components_to_libnames(llvm_libs Support) endif ()
endif()
target_link_libraries(${name} PUBLIC ${llvm_libs})
target_include_directories(${name} PUBLIC ${LLVM_INCLUDE_DIRS})
endif ()
if (ARG_INCLUDE_DIRECTORIES) if (ARG_INSTALL_WITH_TOOLCHAIN)
target_include_directories(${name} ${ARG_INCLUDE_DIRECTORIES}) set_target_properties(${tgtname} PROPERTIES FOLDER "Flang-RT/Toolchain Libraries")
endif () else ()
set_target_properties(${tgtname} PROPERTIES FOLDER "Flang-RT/Libraries")
endif ()
endforeach ()
if (ARG_LINK_LIBRARIES) # Define how to compile and link the library.
target_link_libraries(${name} PUBLIC ${ARG_LINK_LIBRARIES}) # Some conceptionally only apply to ${srctargets} or ${libtargets}, but we
endif () # apply them to ${alltargets}. In worst case, they are ignored by CMake.
foreach (tgtname IN LISTS alltargets)
# Minimum required C++ version for Flang-RT, even if CMAKE_CXX_STANDARD is defined to something else.
target_compile_features(${tgtname} PRIVATE cxx_std_17)
# If this is part of the toolchain, put it into the compiler's resource # Use compiler-specific options to disable exceptions and RTTI.
# directory. Otherwise it is part of testing and is not installed at all. if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
# TODO: Consider multi-configuration builds (MSVC_IDE, "Ninja Multi-Config") target_compile_options(${tgtname} PRIVATE
if (ARG_INSTALL_WITH_TOOLCHAIN) $<$<COMPILE_LANGUAGE:CXX>:-fno-exceptions -fno-rtti -fno-unwind-tables -fno-asynchronous-unwind-tables>
set_target_properties(${name} )
PROPERTIES elseif (MSVC)
ARCHIVE_OUTPUT_DIRECTORY "${FLANG_RT_OUTPUT_RESOURCE_LIB_DIR}" target_compile_options(${tgtname} PRIVATE
) $<$<COMPILE_LANGUAGE:CXX>:/EHs-c- /GR->
)
elseif (CMAKE_CXX_COMPILER_ID MATCHES "XL")
target_compile_options(${tgtname} PRIVATE
$<$<COMPILE_LANGUAGE:CXX>:-qnoeh -qnortti>
)
endif ()
install(TARGETS ${name} # Also for CUDA source when compiling with FLANG_RT_EXPERIMENTAL_OFFLOAD_SUPPORT=CUDA
ARCHIVE DESTINATION "${FLANG_RT_INSTALL_RESOURCE_LIB_PATH}" if (CMAKE_CUDA_COMPILER_ID MATCHES "NVIDIA")
) # Assuming gcc as host compiler.
endif () target_compile_options(${tgtname} PRIVATE
$<$<COMPILE_LANGUAGE:CUDA>:--no-exceptions -Xcompiler -fno-rtti -Xcompiler -fno-unwind-tables -Xcompiler -fno-asynchronous-unwind-tables>
)
else ()
# Assuming a clang-compatible CUDA compiler.
target_compile_options(${tgtname} PRIVATE
$<$<COMPILE_LANGUAGE:CUDA>:-fno-exceptions -fno-rtti -fno-unwind-tables -fno-asynchronous-unwind-tables>
)
endif ()
if (ARG_TARGET_PROPERTIES) # Flang-RT's public headers
set_target_properties(${name} PROPERTIES ${ARG_TARGET_PROPERTIES}) target_include_directories(${tgtname} PUBLIC "${FLANG_RT_SOURCE_DIR}/include")
endif ()
# flang-rt should build all the Flang-RT targets that are built in an # For ISO_Fortran_binding.h to be found by the runtime itself (Accessed as #include "flang/ISO_Fortran_binding.h")
# 'all' build. # User applications can use #include <ISO_Fortran_binding.h>
if (NOT ARG_EXCLUDE_FROM_ALL) target_include_directories(${tgtname} PUBLIC "${FLANG_SOURCE_DIR}/include")
add_dependencies(flang-rt ${name})
endif () # For Flang-RT's configured config.h to be found
target_include_directories(${tgtname} PRIVATE "${FLANG_RT_BINARY_DIR}")
# Disable libstdc++/libc++ assertions, even in an LLVM_ENABLE_ASSERTIONS
# build, to avoid an unwanted dependency on libstdc++/libc++.so.
if (FLANG_RT_SUPPORTS_UNDEFINE_FLAG)
target_compile_options(${tgtname} PUBLIC -U_GLIBCXX_ASSERTIONS)
target_compile_options(${tgtname} PUBLIC -U_LIBCPP_ENABLE_ASSERTIONS)
endif ()
# When building the flang runtime if LTO is enabled the archive file
# contains LLVM IR rather than object code. Currently flang is not
# LTO aware so cannot link this file to compiled Fortran code.
if (FLANG_RT_HAS_FNO_LTO_FLAG)
target_compile_options(${tgtname} PRIVATE -fno-lto)
endif ()
# Flang/Clang (including clang-cl) -compiled programs targeting the MSVC ABI
# should only depend on msvcrt/ucrt. LLVM still emits libgcc/compiler-rt
# functions in some cases like 128-bit integer math (__udivti3, __modti3,
# __fixsfti, __floattidf, ...) that msvc does not support. We are injecting a
# dependency to Compiler-RT's builtin library where these are implemented.
if (MSVC AND CMAKE_CXX_COMPILER_ID MATCHES "Clang")
if (FLANG_RT_BUILTINS_LIBRARY)
target_compile_options(${tgtname} PRIVATE "$<$<COMPILE_LANGUAGE:CXX,C>:-Xclang>" "$<$<COMPILE_LANGUAGE:CXX,C>:--dependent-lib=${FLANG_RT_BUILTINS_LIBRARY}>")
endif ()
endif ()
if (MSVC AND CMAKE_Fortran_COMPILER_ID STREQUAL "LLVMFlang")
if (FLANG_RT_BUILTINS_LIBRARY)
target_compile_options(${tgtname} PRIVATE "$<$<COMPILE_LANGUAGE:Fortran>:-Xflang>" "$<$<COMPILE_LANGUAGE:Fortran>:--dependent-lib=${FLANG_RT_BUILTINS_LIBRARY}>")
else ()
message(WARNING "Did not find libclang_rt.builtins.lib.
LLVM may emit builtins that are not implemented in msvcrt/ucrt and
instead falls back to builtins from Compiler-RT. Linking with ${tgtname}
may result in a linker error.")
endif ()
endif ()
# Non-GTest unittests depend on LLVMSupport
if (ARG_LINK_TO_LLVM)
if (LLVM_LINK_LLVM_DYLIB)
set(llvm_libs LLVM)
else()
llvm_map_components_to_libnames(llvm_libs Support)
endif()
target_link_libraries(${tgtname} PUBLIC ${llvm_libs})
target_include_directories(${tgtname} PUBLIC ${LLVM_INCLUDE_DIRS})
endif ()
if (ARG_INCLUDE_DIRECTORIES)
target_include_directories(${tgtname} ${ARG_INCLUDE_DIRECTORIES})
endif ()
if (ARG_LINK_LIBRARIES)
target_link_libraries(${tgtname} PUBLIC ${ARG_LINK_LIBRARIES})
endif ()
endforeach ()
foreach (tgtname IN LISTS libtargets)
# If this is part of the toolchain, put it into the compiler's resource
# directory. Otherwise it is part of testing and is not installed at all.
# TODO: Consider multi-configuration builds (MSVC_IDE, "Ninja Multi-Config")
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}"
)
install(TARGETS ${tgtname}
ARCHIVE DESTINATION "${FLANG_RT_INSTALL_RESOURCE_LIB_PATH}"
LIBRARY DESTINATION "${FLANG_RT_INSTALL_RESOURCE_LIB_PATH}"
)
endif ()
if (ARG_TARGET_PROPERTIES)
set_target_properties(${tgtname} PROPERTIES ${ARG_TARGET_PROPERTIES})
endif ()
# flang-rt should build all the Flang-RT targets that are built in an
# 'all' build.
if (NOT ARG_EXCLUDE_FROM_ALL)
add_dependencies(flang-rt ${tgtname})
endif ()
endforeach ()
endfunction (add_flangrt_library) endfunction (add_flangrt_library)

18
flang-rt/cmake/modules/AddFlangRTOffload.cmake
View File

@ -8,9 +8,15 @@
macro(enable_cuda_compilation name files) macro(enable_cuda_compilation name files)
if (FLANG_RT_EXPERIMENTAL_OFFLOAD_SUPPORT STREQUAL "CUDA") if (FLANG_RT_EXPERIMENTAL_OFFLOAD_SUPPORT STREQUAL "CUDA")
if (FLANG_RT_ENABLE_SHARED)
message(FATAL_ERROR
"FLANG_RT_ENABLE_SHARED is not supported for CUDA offload build of Flang-RT"
)
endif()
enable_language(CUDA) enable_language(CUDA)
set_target_properties(${name} set_target_properties(${name}.static
PROPERTIES PROPERTIES
CUDA_SEPARABLE_COMPILATION ON CUDA_SEPARABLE_COMPILATION ON
) )
@ -54,7 +60,7 @@ macro(enable_cuda_compilation name files)
# When using libcudacxx headers files, we have to use them # When using libcudacxx headers files, we have to use them
# for all files of Flang-RT. # for all files of Flang-RT.
if (EXISTS "${FLANG_RT_LIBCUDACXX_PATH}/include") if (EXISTS "${FLANG_RT_LIBCUDACXX_PATH}/include")
foreach (tgt IN ITEMS "${name}" "obj.${name}PTX") foreach (tgt IN ITEMS "${name}.static" "obj.${name}PTX")
target_include_directories(${tgt} AFTER PRIVATE "${FLANG_RT_LIBCUDACXX_PATH}/include") target_include_directories(${tgt} AFTER PRIVATE "${FLANG_RT_LIBCUDACXX_PATH}/include")
target_compile_definitions(${tgt} PRIVATE RT_USE_LIBCUDACXX=1) target_compile_definitions(${tgt} PRIVATE RT_USE_LIBCUDACXX=1)
endforeach () endforeach ()
@ -66,6 +72,12 @@ macro(enable_omp_offload_compilation name files)
if (FLANG_RT_EXPERIMENTAL_OFFLOAD_SUPPORT STREQUAL "OpenMP") if (FLANG_RT_EXPERIMENTAL_OFFLOAD_SUPPORT STREQUAL "OpenMP")
# OpenMP offload build only works with Clang compiler currently. # OpenMP offload build only works with Clang compiler currently.
if (FLANG_RT_ENABLE_SHARED)
message(FATAL_ERROR
"FLANG_RT_ENABLE_SHARED is not supported for OpenMP offload build of Flang-RT"
)
endif()
if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" AND if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" AND
"${CMAKE_C_COMPILER_ID}" MATCHES "Clang") "${CMAKE_C_COMPILER_ID}" MATCHES "Clang")
@ -84,7 +96,7 @@ macro(enable_omp_offload_compilation name files)
set_source_files_properties(${files} PROPERTIES COMPILE_OPTIONS set_source_files_properties(${files} PROPERTIES COMPILE_OPTIONS
"${OMP_COMPILE_OPTIONS}" "${OMP_COMPILE_OPTIONS}"
) )
target_link_options(${name} PUBLIC ${OMP_COMPILE_OPTIONS}) target_link_options(${name}.static PUBLIC ${OMP_COMPILE_OPTIONS})
# Enable "declare target" in the source code. # Enable "declare target" in the source code.
set_source_files_properties(${files} set_source_files_properties(${files}

2
flang-rt/examples/ExternalHelloWorld/CMakeLists.txt
View File

@ -13,5 +13,5 @@ add_llvm_example(external-hello-world
target_link_libraries(external-hello-world target_link_libraries(external-hello-world
PRIVATE PRIVATE
flang_rt.runtime flang_rt.runtime.default
) )

30
flang-rt/lib/cuda/CMakeLists.txt
View File

@ -6,8 +6,7 @@
# #
#===------------------------------------------------------------------------===# #===------------------------------------------------------------------------===#
add_flangrt_library(flang_rt.cuda STATIC SHARED
add_flangrt_library(flang_rt.cuda STATIC
allocatable.cpp allocatable.cpp
allocator.cpp allocator.cpp
descriptor.cpp descriptor.cpp
@ -17,18 +16,27 @@ add_flangrt_library(flang_rt.cuda STATIC
memory.cpp memory.cpp
registration.cpp registration.cpp
# libflang_rt.runtime depends on a certain version of CUDA. To be able to have
# multiple build of this library with different CUDA version, the version is
# added to the library name.
TARGET_PROPERTIES TARGET_PROPERTIES
# libflang_rt.runtime depends on a certain version of CUDA. To be able to have
# multiple build of this library with different CUDA version, the version is
# added to the library name.
OUTPUT_NAME "flang_rt.cuda_${CUDAToolkit_VERSION_MAJOR}" OUTPUT_NAME "flang_rt.cuda_${CUDAToolkit_VERSION_MAJOR}"
INCLUDE_DIRECTORIES INCLUDE_DIRECTORIES
PRIVATE ${CUDAToolkit_INCLUDE_DIRS} PRIVATE ${CUDAToolkit_INCLUDE_DIRS}
) )
target_link_libraries(flang_rt.cuda # For the static library, link-in the static dependencies as well.
PUBLIC if (TARGET flang_rt.cuda.static)
flang_rt.runtime target_link_libraries(flang_rt.cuda.static PUBLIC
CUDA::cudart_static flang_rt.runtime.static
) CUDA::cudart_static
)
endif ()
# For the shared library, use the shared versions of the dependencies.
if (TARGET flang_rt.cuda.shared)
target_link_libraries(flang_rt.cuda.shared PUBLIC
flang_rt.runtime.shared
CUDA::cudart
)
endif ()

9
flang-rt/lib/runtime/CMakeLists.txt
View File

@ -128,7 +128,7 @@ set(sources ${supported_sources} ${host_sources} ${f128_sources})
if (NOT WIN32) if (NOT WIN32)
add_flangrt_library(flang_rt.runtime STATIC add_flangrt_library(flang_rt.runtime STATIC SHARED
${sources} ${sources}
LINK_LIBRARIES ${Backtrace_LIBRARY} LINK_LIBRARIES ${Backtrace_LIBRARY}
INSTALL_WITH_TOOLCHAIN INSTALL_WITH_TOOLCHAIN
@ -138,10 +138,9 @@ if (NOT WIN32)
enable_cuda_compilation(flang_rt.runtime "${supported_sources}") enable_cuda_compilation(flang_rt.runtime "${supported_sources}")
enable_omp_offload_compilation(flang_rt.runtime "${supported_sources}") enable_omp_offload_compilation(flang_rt.runtime "${supported_sources}")
# For unittests that depend on flang_rt. Should link to the static version # Select a default runtime, which is used for unit and regression tests.
# of the library. get_target_property(default_target flang_rt.runtime.default ALIASED_TARGET)
add_library(flang_rt.runtime.static ALIAS flang_rt.runtime) add_library(flang_rt.runtime.unittest ALIAS "${default_target}")
add_library(flang_rt.runtime.unittest ALIAS flang_rt.runtime)
else() else()
# Target for building all versions of the runtime # Target for building all versions of the runtime
add_custom_target(flang_rt.runtime) add_custom_target(flang_rt.runtime)

2
flang-rt/test/CMakeLists.txt
View File

@ -44,8 +44,8 @@ add_custom_target(flang-rt-test-depends)
set_target_properties(flang-rt-test-depends PROPERTIES FOLDER "Flang-RT/Meta") set_target_properties(flang-rt-test-depends PROPERTIES FOLDER "Flang-RT/Meta")
add_dependencies(flang-rt-test-depends add_dependencies(flang-rt-test-depends
FlangRTUnitTests FlangRTUnitTests
flang_rt.runtime
flang_rt.runtime.unittest flang_rt.runtime.unittest
flang_rt.runtime
) )
add_lit_testsuite(check-flang-rt "Running the Flang-RT regression tests" add_lit_testsuite(check-flang-rt "Running the Flang-RT regression tests"

2
flang-rt/test/lit.cfg.py
View File

@ -92,7 +92,7 @@ config.substitutions.append(
("%include", os.path.join(config.flang_source_dir, "include")) ("%include", os.path.join(config.flang_source_dir, "include"))
) )
# Library path of libflang_rt.runtime.a (for lib search path when using non-Flang driver for linking) # Library path of libflang_rt.runtime.a/.so (for lib search path when using non-Flang driver for linking and LD_LIBRARY_PATH)
config.substitutions.append(("%libdir", config.flang_rt_output_resource_lib_dir)) config.substitutions.append(("%libdir", config.flang_rt_output_resource_lib_dir))
# For CUDA offloading, additional steps (device linking) and libraries (cudart) are needed. # For CUDA offloading, additional steps (device linking) and libraries (cudart) are needed.

2
flang-rt/unittests/Runtime/CUDA/CMakeLists.txt
View File

@ -14,5 +14,5 @@ add_flangrt_unittest(FlangCufRuntimeTests
target_link_libraries(FlangCufRuntimeTests target_link_libraries(FlangCufRuntimeTests
PRIVATE PRIVATE
flang_rt.cuda flang_rt.cuda.default
) )