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

Reapply "[Flang] Remove FLANG_INCLUDE_RUNTIME (#124126)"

Browse Source 
This reverts commit 27539c3f903be26c487703943d3c27d45d4542b2. Retry
with new buildbot configuration after master restart.

Original message:

Remove the FLANG_INCLUDE_RUNTIME option which was replaced by
LLVM_ENABLE_RUNTIMES=flang-rt.

The FLANG_INCLUDE_RUNTIME option was added in #122336 which disables the
non-runtimes build instructions for the Flang runtime so they do not
conflict with the LLVM_ENABLE_RUNTIMES=flang-rt option added in #110217.
In order to not maintain multiple build instructions for the same thing,
this PR completely removes the old build instructions (effectively
forcing FLANG_INCLUDE_RUNTIME=OFF).

As per discussion in
https://discourse.llvm.org/t/buildbot-changes-with-llvm-enable-runtimes-flang-rt/83571/2
we now implicitly add LLVM_ENABLE_RUNTIMES=flang-rt whenever Flang is
compiled in a bootstrapping (non-standalone) build. Because it is
possible to build Flang-RT separately, this behavior can be disabled
using `-DFLANG_ENABLE_FLANG_RT=OFF`. Also see the discussion an
implicitly adding runtimes/projects in #123964.
This commit is contained in:
Michael Kruse 2025-04-30 09:45:04 +02:00
parent 6ae7177de8
commit 77581e2751
17 changed files with 19 additions and 902 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
flang-rt/README.md
View File

@ -91,7 +91,12 @@ can be any compiler supporting the same ABI.
In addition to the compiler, the build must be able to find LLVM development In addition to the compiler, the build must be able to find LLVM development
tools such as `lit` and `FileCheck` that are not found in an LLVM's install tools such as `lit` and `FileCheck` that are not found in an LLVM's install
directory. Use `CMAKE_BINARY_DIR` to point to directory where LLVM has directory. Use `CMAKE_BINARY_DIR` to point to directory where LLVM has
been built. A simple build configuration might look like the following: been built. When building Flang as part of a bootstrapping build
(`LLVM_ENABLE_PROJECTS=flang`), Flang-RT is automatically added
unless configured with `-DFLANG_ENABLE_FLANG_RT=OFF`. Add that option to avoid
having two conflicting versions of the same library.
A simple build configuration might look like the following:
```bash ```bash
cmake -S <path-to-llvm-project-source>/runtimes \ cmake -S <path-to-llvm-project-source>/runtimes \

33
flang/CMakeLists.txt
View File

@ -23,7 +23,6 @@ if (LLVM_ENABLE_EH)
endif() endif()
set(FLANG_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}) set(FLANG_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
set(FLANG_RT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../flang-rt")
# Python is needed for symbol extracting tool # Python is needed for symbol extracting tool
set(LLVM_MINIMUM_PYTHON_VERSION 3.8) set(LLVM_MINIMUM_PYTHON_VERSION 3.8)
@ -259,24 +258,10 @@ else()
include_directories(SYSTEM ${MLIR_TABLEGEN_OUTPUT_DIR}) include_directories(SYSTEM ${MLIR_TABLEGEN_OUTPUT_DIR})
endif() endif()
set(FLANG_INCLUDE_RUNTIME_default ON) if (FLANG_STANDALONE_BUILD)
if ("flang-rt" IN_LIST LLVM_ENABLE_RUNTIMES) message(STATUS "Not building Flang-RT. For a usable Fortran toolchain, compile a standalone Flang-RT.")
set(FLANG_INCLUDE_RUNTIME_default OFF) elseif (NOT "flang-rt" IN_LIST LLVM_ENABLE_RUNTIMES)
endif () message(STATUS "Not building Flang-RT. For a usable Fortran toolchain, either set FLANG_ENABLE_FLANG_RT=ON, add LLVM_ENABLE_RUNTIMES=flang-rt, or compile a standalone Flang-RT.")
option(FLANG_INCLUDE_RUNTIME "Build the runtime in-tree (deprecated; to be replaced with LLVM_ENABLE_RUNTIMES=flang-rt)" ${FLANG_INCLUDE_RUNTIME_default})
if (FLANG_INCLUDE_RUNTIME)
if ("flang-rt" IN_LIST LLVM_ENABLE_RUNTIMES)
message(WARNING "Building Flang-RT using LLVM_ENABLE_RUNTIMES. FLANG_INCLUDE_RUNTIME=${FLANG_INCLUDE_RUNTIME} ignored.")
set(FLANG_INCLUDE_RUNTIME OFF)
else ()
message(STATUS "Building Flang-RT in-tree")
endif ()
else ()
if ("flang-rt" IN_LIST LLVM_ENABLE_RUNTIMES)
message(STATUS "Building Flang-RT using LLVM_ENABLE_RUNTIMES")
else ()
message(STATUS "Not building Flang-RT. For a usable Fortran toolchain, either add LLVM_ENABLE_RUNTIMES=flang-rt, or compile a standalone Flang-RT.")
endif ()
endif () endif ()
set(FLANG_TOOLS_INSTALL_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH set(FLANG_TOOLS_INSTALL_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH
@ -510,12 +495,6 @@ if (FLANG_INCLUDE_TESTS)
add_compile_definitions(FLANG_INCLUDE_TESTS=1) add_compile_definitions(FLANG_INCLUDE_TESTS=1)
endif() endif()
option(FLANG_CUF_RUNTIME
"Compile CUDA Fortran runtime sources" OFF)
if (FLANG_CUF_RUNTIME)
find_package(CUDAToolkit REQUIRED)
endif()
add_subdirectory(include) add_subdirectory(include)
add_subdirectory(lib) add_subdirectory(lib)
add_subdirectory(cmake/modules) add_subdirectory(cmake/modules)
@ -526,10 +505,6 @@ if (FLANG_BUILD_TOOLS)
add_subdirectory(tools) add_subdirectory(tools)
endif() endif()
if (FLANG_INCLUDE_RUNTIME)
add_subdirectory(runtime)
endif ()
if (LLVM_INCLUDE_EXAMPLES) if (LLVM_INCLUDE_EXAMPLES)
add_subdirectory(examples) add_subdirectory(examples)
endif() endif()

146
flang/cmake/modules/AddFlangOffloadRuntime.cmake
View File

@ -1,146 +0,0 @@
option(FLANG_EXPERIMENTAL_CUDA_RUNTIME
"Compile Fortran runtime as CUDA sources (experimental)" OFF
)
option(FLANG_CUDA_RUNTIME_PTX_WITHOUT_GLOBAL_VARS
"Do not compile global variables' definitions when producing PTX library" OFF
)
set(FLANG_LIBCUDACXX_PATH "" CACHE PATH "Path to libcu++ package installation")
set(FLANG_EXPERIMENTAL_OMP_OFFLOAD_BUILD "off" CACHE STRING
"Compile Fortran runtime as OpenMP target offload sources (experimental). Valid options are 'off', 'host_device', 'nohost'")
set(FLANG_OMP_DEVICE_ARCHITECTURES "all" CACHE STRING
"List of OpenMP device architectures to be used to compile the Fortran runtime (e.g. 'gfx1103;sm_90')")
macro(enable_cuda_compilation name files)
if (FLANG_EXPERIMENTAL_CUDA_RUNTIME)
if (BUILD_SHARED_LIBS)
message(FATAL_ERROR
"BUILD_SHARED_LIBS is not supported for CUDA build of Fortran runtime"
)
endif()
enable_language(CUDA)
# TODO: figure out how to make target property CUDA_SEPARABLE_COMPILATION
# work, and avoid setting CMAKE_CUDA_SEPARABLE_COMPILATION.
set(CMAKE_CUDA_SEPARABLE_COMPILATION ON)
# Treat all supported sources as CUDA files.
set_source_files_properties(${files} PROPERTIES LANGUAGE CUDA)
set(CUDA_COMPILE_OPTIONS)
if ("${CMAKE_CUDA_COMPILER_ID}" MATCHES "Clang")
# Allow varargs.
set(CUDA_COMPILE_OPTIONS
-Xclang -fcuda-allow-variadic-functions
)
endif()
if ("${CMAKE_CUDA_COMPILER_ID}" MATCHES "NVIDIA")
set(CUDA_COMPILE_OPTIONS
--expt-relaxed-constexpr
# Disable these warnings:
# 'long double' is treated as 'double' in device code
-Xcudafe --diag_suppress=20208
-Xcudafe --display_error_number
)
endif()
set_source_files_properties(${files} PROPERTIES COMPILE_OPTIONS
"${CUDA_COMPILE_OPTIONS}"
)
if (EXISTS "${FLANG_LIBCUDACXX_PATH}/include")
# When using libcudacxx headers files, we have to use them
# for all files of F18 runtime.
include_directories(AFTER ${FLANG_LIBCUDACXX_PATH}/include)
add_compile_definitions(RT_USE_LIBCUDACXX=1)
endif()
# Add an OBJECT library consisting of CUDA PTX.
llvm_add_library(${name}PTX OBJECT PARTIAL_SOURCES_INTENDED ${files})
set_property(TARGET obj.${name}PTX PROPERTY CUDA_PTX_COMPILATION ON)
if (FLANG_CUDA_RUNTIME_PTX_WITHOUT_GLOBAL_VARS)
target_compile_definitions(obj.${name}PTX
PRIVATE FLANG_RUNTIME_NO_GLOBAL_VAR_DEFS
)
endif()
endif()
endmacro()
macro(enable_omp_offload_compilation files)
if (NOT FLANG_EXPERIMENTAL_OMP_OFFLOAD_BUILD STREQUAL "off")
# 'host_device' build only works with Clang compiler currently.
# The build is done with the CMAKE_C/CXX_COMPILER, i.e. it does not use
# the in-tree built Clang. We may have a mode that would use the in-tree
# built Clang.
#
# 'nohost' is supposed to produce an LLVM Bitcode library,
# and it has to be done with a C/C++ compiler producing LLVM Bitcode
# compatible with the LLVM toolchain version distributed with the Flang
# compiler.
# In general, the in-tree built Clang should be used for 'nohost' build.
# Note that 'nohost' build does not produce the host version of Flang
# runtime library, so there will be two separate distributable objects.
# 'nohost' build is a TODO.
if (NOT FLANG_EXPERIMENTAL_OMP_OFFLOAD_BUILD STREQUAL "host_device")
message(FATAL_ERROR "Unsupported OpenMP offload build of Flang runtime")
endif()
if (BUILD_SHARED_LIBS)
message(FATAL_ERROR
"BUILD_SHARED_LIBS is not supported for OpenMP offload build of Fortran runtime"
)
endif()
if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" AND
"${CMAKE_C_COMPILER_ID}" MATCHES "Clang")
set(all_amdgpu_architectures
"gfx700;gfx701;gfx801;gfx803;gfx900;gfx902;gfx906"
"gfx908;gfx90a;gfx90c;gfx942;gfx950;gfx1010;gfx1030"
"gfx1031;gfx1032;gfx1033;gfx1034;gfx1035;gfx1036"
"gfx1100;gfx1101;gfx1102;gfx1103;gfx1150;gfx1151"
"gfx1152;gfx1153;gfx1200;gfx1201"
)
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}"
)
# TODO: support auto detection on the build system.
if (FLANG_OMP_DEVICE_ARCHITECTURES STREQUAL "all")
set(FLANG_OMP_DEVICE_ARCHITECTURES ${all_gpu_architectures})
endif()
list(REMOVE_DUPLICATES FLANG_OMP_DEVICE_ARCHITECTURES)
string(REPLACE ";" "," compile_for_architectures
"${FLANG_OMP_DEVICE_ARCHITECTURES}"
)
set(OMP_COMPILE_OPTIONS
-fopenmp
-fvisibility=hidden
-fopenmp-cuda-mode
--offload-arch=${compile_for_architectures}
# Force LTO for the device part.
-foffload-lto
)
set_source_files_properties(${files} PROPERTIES COMPILE_OPTIONS
"${OMP_COMPILE_OPTIONS}"
)
# Enable "declare target" in the source code.
set_source_files_properties(${files}
PROPERTIES COMPILE_DEFINITIONS OMP_OFFLOAD_BUILD
)
else()
message(FATAL_ERROR
"Flang runtime build is not supported for these compilers:\n"
"CMAKE_CXX_COMPILER_ID: ${CMAKE_CXX_COMPILER_ID}\n"
"CMAKE_C_COMPILER_ID: ${CMAKE_C_COMPILER_ID}")
endif()
endif()
endmacro()

3
flang/examples/CMakeLists.txt
View File

@ -1,6 +1,3 @@
if (FLANG_INCLUDE_RUNTIME)
add_subdirectory(ExternalHelloWorld)
endif ()
add_subdirectory(PrintFlangFunctionNames) add_subdirectory(PrintFlangFunctionNames)
add_subdirectory(FlangOmpReport) add_subdirectory(FlangOmpReport)
add_subdirectory(FeatureList) add_subdirectory(FeatureList)

9
flang/examples/ExternalHelloWorld/CMakeLists.txt
View File

@ -1,9 +0,0 @@
# This test is not run by default as it requires input.
add_llvm_example(external-hello-world
${FLANG_RT_SOURCE_DIR}/examples/ExternalHelloWorld/external-hello.cpp
)
target_link_libraries(external-hello-world
PRIVATE
flang_rt.runtime
)

385
flang/runtime/CMakeLists.txt
View File

@ -1,385 +0,0 @@
#===-- runtime/CMakeLists.txt ----------------------------------------------===#
#
# 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
#
#===------------------------------------------------------------------------===#
if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
cmake_minimum_required(VERSION 3.20.0)
project(FlangRuntime C CXX)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
set(CMAKE_CXX_EXTENSIONS OFF)
set(FLANG_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/..")
set(FLANG_RT_SOURCE_DIR "${FLANG_SOURCE_DIR}/../flang-rt")
set(LLVM_COMMON_CMAKE_UTILS "${FLANG_SOURCE_DIR}/../cmake")
set(LLVM_CMAKE_UTILS "${FLANG_SOURCE_DIR}/../llvm/cmake")
set(CLANG_CMAKE_UTILS "${FLANG_SOURCE_DIR}/../clang/cmake")
# Add path for custom modules
list(INSERT CMAKE_MODULE_PATH 0
"${FLANG_SOURCE_DIR}/cmake"
"${FLANG_SOURCE_DIR}/cmake/modules"
"${LLVM_COMMON_CMAKE_UTILS}"
"${LLVM_COMMON_CMAKE_UTILS}/Modules"
"${LLVM_CMAKE_UTILS}"
"${LLVM_CMAKE_UTILS}/modules"
"${CLANG_CMAKE_UTILS}/modules"
)
include(AddClang)
include(AddLLVM)
include(AddFlang)
include(HandleLLVMOptions)
include(TestBigEndian)
test_big_endian(IS_BIGENDIAN)
if (IS_BIGENDIAN)
add_compile_definitions(FLANG_BIG_ENDIAN=1)
else ()
add_compile_definitions(FLANG_LITTLE_ENDIAN=1)
endif ()
include_directories(BEFORE
${FLANG_SOURCE_DIR}/include)
# The out of tree builds of the compiler and the Fortran runtime
# must use the same setting of FLANG_RUNTIME_F128_MATH_LIB
# to be composable. Failure to synchronize this setting may result
# in linking errors or fatal failures in F128 runtime functions.
set(FLANG_RUNTIME_F128_MATH_LIB "" CACHE STRING
"Specifies the target library used for implementing IEEE-754 128-bit float \
math in F18 runtime, e.g. it might be libquadmath for targets where \
REAL(16) is mapped to __float128, or libm for targets where REAL(16) \
is mapped to long double, etc."
)
option(FLANG_CUF_RUNTIME
"Compile CUDA Fortran runtime sources" OFF)
if (FLANG_CUF_RUNTIME)
find_package(CUDAToolkit REQUIRED)
endif()
endif()
# Runtime files are in Flang-RT's source dir.
function (runtime_source_files outvar)
cmake_parse_arguments(ARG "" "SUBDIR" "" ${ARGN})
set(new_sources "")
foreach (source IN LISTS "${outvar}")
set(new_source "${FLANG_RT_SOURCE_DIR}/lib")
cmake_path(APPEND new_source "${ARG_SUBDIR}")
cmake_path(APPEND new_source "${source}")
list(APPEND new_sources "${new_source}")
endforeach ()
set("${outvar}" ${new_sources} PARENT_SCOPE)
endfunction ()
# Runtime includes are in Flang-RT's source dir.
include_directories(BEFORE "${FLANG_RT_SOURCE_DIR}/include")
set(linked_libraries "")
# function checks
find_package(Backtrace)
set(HAVE_BACKTRACE ${Backtrace_FOUND})
set(BACKTRACE_HEADER ${Backtrace_HEADER})
if(HAVE_BACKTRACE)
list(APPEND linked_libraries ${Backtrace_LIBRARY})
endif()
include(CheckCXXSymbolExists)
include(CheckCXXSourceCompiles)
check_cxx_symbol_exists(strerror_r string.h HAVE_STRERROR_R)
# Can't use symbol exists here as the function is overloaded in C++
check_cxx_source_compiles(
"#include <string.h>
int main() {
char buf[4096];
return strerror_s(buf, 4096, 0);
}
"
HAVE_DECL_STRERROR_S)
# Check if 128-bit float computations can be done via long double.
check_cxx_source_compiles(
"#include <cfloat>
#if LDBL_MANT_DIG != 113
#error LDBL_MANT_DIG != 113
#endif
int main() { return 0; }
"
HAVE_LDBL_MANT_DIG_113)
check_cxx_compiler_flag(-fno-lto FLANG_RUNTIME_HAS_FNO_LTO_FLAG)
if (FLANG_RUNTIME_HAS_FNO_LTO_FLAG)
set(NO_LTO_FLAGS "-fno-lto")
else()
set(NO_LTO_FLAGS "")
endif()
# based on AddLLVM.cmake
if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
set(NO_RTTI_FLAGS "-fno-exceptions -fno-rtti")
elseif (MSVC)
set(NO_RTTI_FLAGS "/EHs-c- /GR-")
elseif (CMAKE_CXX_COMPILER_ID MATCHES "XL")
set(NO_RTTI_FLAGS "-qnoeh -qnortti")
endif ()
# When compiling LLVM_ENABLE_RUNTIMES=flang-rt, the build system looks for the
# full path of quadmath.h. In this non-runtimes build, preserve the old behavior
# of just including <quadmath.h>.
set(FLANG_RT_INCLUDE_QUADMATH_H "<quadmath.h>")
configure_file("${FLANG_RT_SOURCE_DIR}/cmake/quadmath_wrapper.h.in" "quadmath_wrapper.h")
configure_file("${FLANG_RT_SOURCE_DIR}/cmake/config.h.cmake.in" config.h)
# include_directories is used here instead of target_include_directories
# because add_flang_library creates multiple objects (STATIC/SHARED, OBJECT)
# with different names
include_directories(AFTER ${CMAKE_CURRENT_BINARY_DIR})
append(${NO_LTO_FLAGS} CMAKE_C_FLAGS)
append(${NO_LTO_FLAGS} CMAKE_CXX_FLAGS)
append(${NO_RTTI_FLAGS} CMAKE_CXX_FLAGS)
# Disable libstdc++/libc++ assertions, even in an LLVM_ENABLE_ASSERTIONS build,
# to avoid an unwanted dependency on libstdc++/libc++.so.
add_definitions(-U_GLIBCXX_ASSERTIONS)
add_definitions(-U_LIBCPP_ENABLE_ASSERTIONS)
add_subdirectory(Float128Math)
set(sources
${FLANG_SOURCE_DIR}/lib/Decimal/binary-to-decimal.cpp
${FLANG_SOURCE_DIR}/lib/Decimal/decimal-to-binary.cpp
ISO_Fortran_binding.cpp
allocator-registry.cpp
allocatable.cpp
array-constructor.cpp
assign.cpp
buffer.cpp
character.cpp
command.cpp
complex-powi.cpp
complex-reduction.c
connection.cpp
copy.cpp
derived-api.cpp
derived.cpp
descriptor-io.cpp
descriptor.cpp
dot-product.cpp
edit-input.cpp
edit-output.cpp
environment.cpp
exceptions.cpp
execute.cpp
extensions.cpp
external-unit.cpp
extrema.cpp
file.cpp
findloc.cpp
format.cpp
inquiry.cpp
internal-unit.cpp
io-api.cpp
io-api-minimal.cpp
io-error.cpp
io-stmt.cpp
iostat.cpp
main.cpp
matmul-transpose.cpp
matmul.cpp
memory.cpp
misc-intrinsic.cpp
namelist.cpp
non-tbp-dio.cpp
numeric.cpp
pointer.cpp
product.cpp
pseudo-unit.cpp
ragged.cpp
random.cpp
reduce.cpp
reduction.cpp
stat.cpp
stop.cpp
sum.cpp
support.cpp
temporary-stack.cpp
terminator.cpp
time-intrinsic.cpp
tools.cpp
transformational.cpp
type-code.cpp
type-info.cpp
unit-map.cpp
unit.cpp
utf.cpp
${FORTRAN_MODULE_OBJECTS}
)
include(AddFlangOffloadRuntime)
# List of files that are buildable for all devices.
set(supported_files
${FLANG_SOURCE_DIR}/lib/Decimal/binary-to-decimal.cpp
${FLANG_SOURCE_DIR}/lib/Decimal/decimal-to-binary.cpp
ISO_Fortran_binding.cpp
allocatable.cpp
allocator-registry.cpp
array-constructor.cpp
assign.cpp
buffer.cpp
character.cpp
connection.cpp
copy.cpp
derived-api.cpp
derived.cpp
descriptor.cpp
descriptor-io.cpp
dot-product.cpp
edit-input.cpp
edit-output.cpp
environment.cpp
extrema.cpp
external-unit.cpp
file.cpp
findloc.cpp
format.cpp
inquiry.cpp
internal-unit.cpp
io-api.cpp
io-api-minimal.cpp
io-error.cpp
io-stmt.cpp
iostat.cpp
matmul-transpose.cpp
matmul.cpp
memory.cpp
misc-intrinsic.cpp
namelist.cpp
non-tbp-dio.cpp
numeric.cpp
pointer.cpp
product.cpp
pseudo-unit.cpp
ragged.cpp
stat.cpp
sum.cpp
support.cpp
terminator.cpp
tools.cpp
transformational.cpp
type-code.cpp
type-info.cpp
unit.cpp
utf.cpp
)
runtime_source_files(supported_files SUBDIR "runtime")
enable_cuda_compilation(flang_rt "${supported_files}")
enable_omp_offload_compilation("${supported_files}")
if (NOT TARGET flang_rt.quadmath)
# If flang_rt.quadmath is not defined, then we are not building
# standalone flang_rt.quadmath library. Instead, include
# the relevant sources into flang_rt.runtime itself.
# The information is provided via FortranFloat128MathILib
# interface library.
get_target_property(f128_sources
FortranFloat128MathILib INTERFACE_SOURCES
)
if (f128_sources)
# The interface may define special macros for Float128Math files,
# so we need to propagate them.
get_target_property(f128_defs
FortranFloat128MathILib INTERFACE_COMPILE_DEFINITIONS
)
set_property(SOURCE ${f128_sources}
APPEND PROPERTY COMPILE_DEFINITIONS
${f128_defs}
)
get_target_property(f128_include_dirs
FortranFloat128MathILib INTERFACE_INCLUDE_DIRECTORIES
)
set_property(SOURCE ${f128_sources}
APPEND PROPERTY INCLUDE_DIRECTORIES
${f128_include_dirs}
)
list(APPEND sources ${f128_sources})
endif()
endif()
runtime_source_files(sources SUBDIR "runtime")
if (NOT DEFINED MSVC)
add_flang_library(flang_rt.runtime
${sources}
LINK_LIBS
${linked_libraries}
INSTALL_WITH_TOOLCHAIN
)
else()
add_flang_library(flang_rt.runtime
${sources}
LINK_LIBS
${linked_libraries}
)
set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded)
add_flang_library(flang_rt.runtime.static ${sources}
INSTALL_WITH_TOOLCHAIN)
set_target_properties(flang_rt.runtime.static PROPERTIES FOLDER "Flang/Runtime Libraries")
set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreadedDLL)
add_flang_library(flang_rt.runtime.dynamic ${sources}
INSTALL_WITH_TOOLCHAIN)
set_target_properties(flang_rt.runtime.dynamic PROPERTIES FOLDER "Flang/Runtime Libraries")
set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreadedDebug)
add_flang_library(flang_rt.runtime.static_dbg ${sources}
INSTALL_WITH_TOOLCHAIN)
set_target_properties(flang_rt.runtime.static_dbg PROPERTIES FOLDER "Flang/Runtime Libraries")
set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreadedDebugDLL)
add_flang_library(flang_rt.runtime.dynamic_dbg ${sources}
INSTALL_WITH_TOOLCHAIN)
set_target_properties(flang_rt.runtime.dynamic_dbg PROPERTIES FOLDER "Flang/Runtime Libraries")
add_dependencies(flang_rt.runtime
flang_rt.runtime.static
flang_rt.runtime.dynamic
flang_rt.runtime.static_dbg
flang_rt.runtime.dynamic_dbg)
endif()
set_target_properties(flang_rt.runtime PROPERTIES FOLDER "Flang/Runtime Libraries")
# If flang_rt is part of a Flang build (and not a separate build) then
# add dependency to make sure that Fortran runtime library is being built after
# we have the Flang compiler available. This also includes the MODULE files
# that compile when the 'flang' target is built.
#
# TODO: This is a workaround and should be updated when runtime build procedure
# is changed to a regular runtime build. See discussion in PR #95388.
if (TARGET flang AND TARGET module_files)
add_dependencies(flang_rt.runtime flang module_files)
endif()
if (FLANG_CUF_RUNTIME)
add_subdirectory(CUDA)
endif()
# Compatibility targets.
add_custom_target(flang-rt)
add_dependencies(flang-rt flang_rt.runtime)
if (TARGET flang_rt.quadmath)
add_dependencies(flang-rt flang_rt.quadmath)
endif ()
if (TARGET flang_rt.cuda_${CUDAToolkit_VERSION_MAJOR})
add_dependencies(flang-rt flang_rt.cuda_${CUDAToolkit_VERSION_MAJOR})
endif ()
add_custom_target(FortranRuntime)
add_dependencies(FortranRuntime flang_rt.runtime)

43
flang/runtime/CUDA/CMakeLists.txt
View File

@ -1,43 +0,0 @@
#===-- runtime/CUDA/CMakeLists.txt -----------------------------------------===#
#
# 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_directories(${CUDAToolkit_INCLUDE_DIRS})
# libflang_rt.cuda 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.
set(CUFRT_LIBNAME flang_rt.cuda_${CUDAToolkit_VERSION_MAJOR})
set(sources
allocator.cpp
allocatable.cpp
descriptor.cpp
init.cpp
kernel.cpp
memmove-function.cpp
memory.cpp
pointer.cpp
registration.cpp
)
runtime_source_files(sources SUBDIR "cuda")
add_flang_library(${CUFRT_LIBNAME}
${sources}
)
if (BUILD_SHARED_LIBS)
set(CUDA_RT_TARGET CUDA::cudart)
else()
set(CUDA_RT_TARGET CUDA::cudart_static)
endif()
target_link_libraries(${CUFRT_LIBNAME}
PRIVATE
flang_rt.runtime
${CUDA_RT_TARGET}
)

134
flang/runtime/Float128Math/CMakeLists.txt
View File

@ -1,134 +0,0 @@
#===-- runtime/Float128Math/CMakeLists.txt ---------------------------------===#
#
# 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
#
#===------------------------------------------------------------------------===#
# FortranFloat128 implements IEEE-754 128-bit float math functions.
# It is a thin wapper and it currently relies on third-party
# libraries available for the target.
# It is distributed as a static library only.
# Fortran programs/libraries that end up linking any of the provided
# will have a dependency on the third-party library that is being
# used for building this flang_rt.quadmath library.
include(CheckLibraryExists)
set(sources
acos.cpp
acosh.cpp
asin.cpp
asinh.cpp
atan.cpp
atan2.cpp
atanh.cpp
ceil.cpp
complex-math.c
cos.cpp
cosh.cpp
erf.cpp
erfc.cpp
exp.cpp
exponent.cpp
floor.cpp
fma.cpp
fraction.cpp
hypot.cpp
j0.cpp
j1.cpp
jn.cpp
lgamma.cpp
llround.cpp
log.cpp
log10.cpp
lround.cpp
mod-real.cpp
modulo-real.cpp
nearest.cpp
nearbyint.cpp
norm2.cpp
pow.cpp
random.cpp
remainder.cpp
round.cpp
rrspacing.cpp
scale.cpp
set-exponent.cpp
sin.cpp
sinh.cpp
spacing.cpp
sqrt.cpp
tan.cpp
tanh.cpp
tgamma.cpp
trunc.cpp
y0.cpp
y1.cpp
yn.cpp
)
runtime_source_files(sources SUBDIR "quadmath")
include_directories(AFTER "${CMAKE_CURRENT_SOURCE_DIR}/..")
add_library(FortranFloat128MathILib INTERFACE)
target_include_directories(FortranFloat128MathILib INTERFACE
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
)
if (FLANG_RUNTIME_F128_MATH_LIB)
if (${FLANG_RUNTIME_F128_MATH_LIB} STREQUAL "libquadmath")
check_include_file(quadmath.h FOUND_QUADMATH_HEADER)
if(FOUND_QUADMATH_HEADER)
add_compile_definitions(HAS_QUADMATHLIB)
else()
message(FATAL_ERROR
"FLANG_RUNTIME_F128_MATH_LIB setting requires quadmath.h "
"to be available: ${FLANG_RUNTIME_F128_MATH_LIB}"
)
endif()
else()
message(FATAL_ERROR
"Unsupported third-party library for Fortran F128 math runtime: "
"${FLANG_RUNTIME_F128_MATH_LIB}"
)
endif()
add_flang_library(flang_rt.quadmath STATIC INSTALL_WITH_TOOLCHAIN
${sources})
if (DEFINED MSVC)
set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded)
add_flang_library(flang_rt.quadmath.static STATIC INSTALL_WITH_TOOLCHAIN
${sources}
)
set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreadedDebug)
add_flang_library(flang_rt.quadmath.static_dbg STATIC INSTALL_WITH_TOOLCHAIN
${sources}
)
add_dependencies(flang_rt.quadmath flang_rt.quadmath.static
flang_rt.quadmath.static_dbg
)
endif()
elseif (HAVE_LDBL_MANT_DIG_113)
# We can use 'long double' versions from libc.
check_library_exists(m sinl "" FOUND_LIBM)
if (FOUND_LIBM)
target_compile_definitions(FortranFloat128MathILib INTERFACE
HAS_LIBM
)
target_sources(FortranFloat128MathILib INTERFACE ${sources})
else()
message(FATAL_ERROR "flang_rt.quadmath cannot build without libm")
endif()
else()
# We can use '__float128' version from libc, if it has them.
check_library_exists(m sinf128 "" FOUND_LIBMF128)
if (FOUND_LIBMF128)
target_compile_definitions(FortranFloat128MathILib INTERFACE
HAS_LIBMF128
)
# Enable this, when math-entries.h and complex-math.h is ready.
# target_sources(FortranFloat128MathILib INTERFACE ${sources})
endif()
endif()

10
flang/test/CMakeLists.txt
View File

@ -78,10 +78,6 @@ if (NOT FLANG_STANDALONE_BUILD)
) )
endif () endif ()
if (FLANG_INCLUDE_RUNTIME)
list(APPEND FLANG_TEST_DEPENDS flang_rt.runtime)
endif ()
if (LLVM_BUILD_EXAMPLES AND LLVM_ENABLE_PLUGINS AND NOT WIN32 AND NOT FLANG_STANDALONE_BUILD) if (LLVM_BUILD_EXAMPLES AND LLVM_ENABLE_PLUGINS AND NOT WIN32 AND NOT FLANG_STANDALONE_BUILD)
list(APPEND FLANG_TEST_DEPENDS Bye) list(APPEND FLANG_TEST_DEPENDS Bye)
endif() endif()
@ -132,9 +128,3 @@ if (DEFINED FLANG_TEST_TARGET_TRIPLE)
"to use FLANG_TEST_TARGET_TRIPLE.") "to use FLANG_TEST_TARGET_TRIPLE.")
endif() endif()
endif() endif()
# Compatibility targets.
if (FLANG_INCLUDE_RUNTIME)
add_custom_target(check-flang-rt)
add_dependencies(check-flang-rt check-flang)
endif ()

3
flang/test/lit.cfg.py
View File

@ -163,9 +163,6 @@ else:
ToolSubst("%not_todo_abort_cmd", command=FindTool("not"), unresolved="fatal") ToolSubst("%not_todo_abort_cmd", command=FindTool("not"), unresolved="fatal")
) )
if config.flang_include_runtime:
config.available_features.add("flang-rt")
# Add all the tools and their substitutions (if applicable). Use the search paths provided for # Add all the tools and their substitutions (if applicable). Use the search paths provided for
# finding the tools. # finding the tools.
if config.flang_standalone_build: if config.flang_standalone_build:

1
flang/test/lit.site.cfg.py.in
View File

@ -30,7 +30,6 @@ else:
config.openmp_module_dir = None config.openmp_module_dir = None
config.flang_runtime_f128_math_lib = "@FLANG_RUNTIME_F128_MATH_LIB@" config.flang_runtime_f128_math_lib = "@FLANG_RUNTIME_F128_MATH_LIB@"
config.have_ldbl_mant_dig_113 = "@HAVE_LDBL_MANT_DIG_113@" config.have_ldbl_mant_dig_113 = "@HAVE_LDBL_MANT_DIG_113@"
config.flang_include_runtime = lit.util.pythonize_bool("@FLANG_INCLUDE_RUNTIME@")
import lit.llvm import lit.llvm
lit.llvm.initialize(lit_config, config) lit.llvm.initialize(lit_config, config)

17
flang/tools/f18/CMakeLists.txt
View File

@ -4,16 +4,9 @@ set(LLVM_LINK_COMPONENTS
Support Support
) )
# Define the list of Fortran module files that need to be compiled
# to produce an object file for inclusion into the flang_rt.runtime
# library.
set(MODULES_WITH_IMPLEMENTATION
"iso_fortran_env_impl"
)
# Define the list of Fortran module files for which it is # Define the list of Fortran module files for which it is
# sufficient to generate the module file via -fsyntax-only. # sufficient to generate the module file via -fsyntax-only.
set(MODULES_WITHOUT_IMPLEMENTATION set(MODULES
"__fortran_builtins" "__fortran_builtins"
"__fortran_ieee_exceptions" "__fortran_ieee_exceptions"
"__fortran_type_info" "__fortran_type_info"
@ -28,10 +21,9 @@ set(MODULES_WITHOUT_IMPLEMENTATION
"ieee_features" "ieee_features"
"iso_c_binding" "iso_c_binding"
"iso_fortran_env" "iso_fortran_env"
"iso_fortran_env_impl"
) )
set(MODULES ${MODULES_WITH_IMPLEMENTATION} ${MODULES_WITHOUT_IMPLEMENTATION})
# Check if 128-bit float computations can be done via long double. # Check if 128-bit float computations can be done via long double.
check_cxx_source_compiles( check_cxx_source_compiles(
"#include <cfloat> "#include <cfloat>
@ -109,11 +101,6 @@ if (NOT CMAKE_CROSSCOMPILING)
set(compile_with "-fsyntax-only") set(compile_with "-fsyntax-only")
set(object_output "") set(object_output "")
set(include_in_link FALSE) set(include_in_link FALSE)
if(${filename} IN_LIST MODULES_WITH_IMPLEMENTATION AND FLANG_INCLUDE_RUNTIME)
set(object_output "${CMAKE_CURRENT_BINARY_DIR}/${filename}${CMAKE_CXX_OUTPUT_EXTENSION}")
set(compile_with -c -o ${object_output})
set(include_in_link TRUE)
endif()
set(base ${FLANG_INTRINSIC_MODULES_DIR}/${filename}) set(base ${FLANG_INTRINSIC_MODULES_DIR}/${filename})
# TODO: We may need to flag this with conditional, in case Flang is built w/o OpenMP support # TODO: We may need to flag this with conditional, in case Flang is built w/o OpenMP support

43
flang/unittests/CMakeLists.txt
View File

@ -1,5 +1,3 @@
include(AddFlangOffloadRuntime)
if (FLANG_EXPERIMENTAL_CUDA_RUNTIME) if (FLANG_EXPERIMENTAL_CUDA_RUNTIME)
# If Fortran runtime is built as CUDA library, the linking # If Fortran runtime is built as CUDA library, the linking
# of targets that link flang_rt.runtime must be done # of targets that link flang_rt.runtime must be done
@ -12,38 +10,8 @@ endif()
add_custom_target(FlangUnitTests) add_custom_target(FlangUnitTests)
set_target_properties(FlangUnitTests PROPERTIES FOLDER "Flang/Tests") set_target_properties(FlangUnitTests PROPERTIES FOLDER "Flang/Tests")
include_directories("${FLANG_RT_SOURCE_DIR}/include")
function(add_flang_unittest_offload_properties target)
# Do not apply runtime properties if not even compiling the runtime.
if (NOT FLANG_INCLUDE_RUNTIME)
return ()
endif ()
# Set CUDA_RESOLVE_DEVICE_SYMBOLS.
if (FLANG_EXPERIMENTAL_CUDA_RUNTIME)
set_target_properties(${target}
PROPERTIES CUDA_RESOLVE_DEVICE_SYMBOLS ON
)
endif()
# Enable OpenMP offload during linking. We may need to replace
# LINK_OPTIONS with COMPILE_OPTIONS when there are OpenMP offload
# unittests.
#
# FIXME: replace 'native' in --offload-arch option with the list
# of targets that Fortran Runtime was built for.
# Common code must be moved from flang/runtime/CMakeLists.txt.
if (NOT FLANG_EXPERIMENTAL_OMP_OFFLOAD_BUILD STREQUAL "off")
set_target_properties(${target}
PROPERTIES LINK_OPTIONS
"-fopenmp;--offload-arch=native"
)
endif()
endfunction()
function(add_flang_unittest test_dirname) function(add_flang_unittest test_dirname)
add_unittest(FlangUnitTests ${test_dirname} ${ARGN}) add_unittest(FlangUnitTests ${test_dirname} ${ARGN})
add_flang_unittest_offload_properties(${test_dirname})
endfunction() endfunction()
if (CXX_SUPPORTS_SUGGEST_OVERRIDE_FLAG) if (CXX_SUPPORTS_SUGGEST_OVERRIDE_FLAG)
@ -63,11 +31,7 @@ function(add_flang_nongtest_unittest test_name)
set(suffix .test) set(suffix .test)
endif() endif()
# Sources for runtime tests are in Flang-RT. set(test_filepath "${test_name}.cpp")
set(test_filepath "${FLANG_RT_SOURCE_DIR}/unittests/Evaluate/${test_name}.cpp")
if (NOT EXISTS "${test_filepath}")
set(test_filepath "${test_name}.cpp")
endif ()
add_executable(${test_name}${suffix} "${test_filepath}") add_executable(${test_name}${suffix} "${test_filepath}")
set_target_properties(${test_name}${suffix} PROPERTIES FOLDER "Flang/Tests/Unit") set_target_properties(${test_name}${suffix} PROPERTIES FOLDER "Flang/Tests/Unit")
@ -82,15 +46,10 @@ function(add_flang_nongtest_unittest test_name)
if(NOT ARG_SLOW_TEST) if(NOT ARG_SLOW_TEST)
add_dependencies(FlangUnitTests ${test_name}${suffix}) add_dependencies(FlangUnitTests ${test_name}${suffix})
endif() endif()
add_flang_unittest_offload_properties(${test_name}${suffix})
endfunction() endfunction()
add_subdirectory(Optimizer) add_subdirectory(Optimizer)
add_subdirectory(Common) add_subdirectory(Common)
add_subdirectory(Decimal) add_subdirectory(Decimal)
add_subdirectory(Evaluate) add_subdirectory(Evaluate)
if (FLANG_INCLUDE_RUNTIME)
add_subdirectory(Runtime)
endif ()
add_subdirectory(Frontend) add_subdirectory(Frontend)

16
flang/unittests/Evaluate/CMakeLists.txt
View File

@ -55,22 +55,6 @@ add_flang_nongtest_unittest(real
) )
llvm_update_compile_flags(real.test) llvm_update_compile_flags(real.test)
if (FLANG_INCLUDE_RUNTIME)
add_flang_nongtest_unittest(reshape
NonGTestTesting
FortranSemantics
FortranEvaluate
flang_rt.runtime
)
add_flang_nongtest_unittest(ISO-Fortran-binding
NonGTestTesting
FortranEvaluate
FortranSemantics
flang_rt.runtime
)
endif ()
add_flang_nongtest_unittest(folding add_flang_nongtest_unittest(folding
FortranSupport FortranSupport
NonGTestTesting NonGTestTesting

41
flang/unittests/Runtime/CMakeLists.txt
View File

@ -1,41 +0,0 @@
add_flang_unittest(FlangRuntimeTests
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/AccessTest.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/Allocatable.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/ArrayConstructor.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/BufferTest.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/CharacterTest.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/CommandTest.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/Complex.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/CrashHandlerFixture.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/Derived.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/ExternalIOTest.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/Format.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/Inquiry.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/ListInputTest.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/LogicalFormatTest.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/Matmul.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/MatmulTranspose.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/MiscIntrinsic.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/Namelist.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/Numeric.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/NumericalFormatTest.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/Pointer.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/Ragged.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/Random.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/Reduction.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/RuntimeCrashTest.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/Stop.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/Support.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/Time.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/TemporaryStack.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/Transformational.cpp
)
target_link_libraries(FlangRuntimeTests
PRIVATE
flang_rt.runtime
)
target_compile_definitions(FlangRuntimeTests PRIVATE NOT_EXE="$<TARGET_FILE:not>")
add_subdirectory(CUDA)

24
flang/unittests/Runtime/CUDA/CMakeLists.txt
View File

@ -1,24 +0,0 @@
if (FLANG_CUF_RUNTIME)
add_flang_unittest(FlangCufRuntimeTests
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/CUDA/Allocatable.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/CUDA/AllocatorCUF.cpp
${FLANG_RT_SOURCE_DIR}/unittests/Runtime/CUDA/Memory.cpp
)
if (BUILD_SHARED_LIBS)
set(CUDA_RT_TARGET CUDA::cudart)
else()
set(CUDA_RT_TARGET CUDA::cudart_static)
endif()
target_link_libraries(FlangCufRuntimeTests
PRIVATE
${CUDA_RT_TARGET}
flang_rt.cuda_${CUDAToolkit_VERSION_MAJOR}
flang_rt.runtime
)
target_include_directories(FlangCufRuntimeTests PRIVATE ${CUDAToolkit_INCLUDE_DIRS})
endif()

6
llvm/CMakeLists.txt
View File

@ -148,6 +148,12 @@ if ("flang" IN_LIST LLVM_ENABLE_PROJECTS)
message(STATUS "Enabling clang as a dependency to flang") message(STATUS "Enabling clang as a dependency to flang")
list(APPEND LLVM_ENABLE_PROJECTS "clang") list(APPEND LLVM_ENABLE_PROJECTS "clang")
endif() endif()
option(FLANG_ENABLE_FLANG_RT "Implicitly add LLVM_ENABLE_RUNTIMES=flang-rt when compiling Flang" ON)
if (FLANG_ENABLE_FLANG_RT AND NOT "flang-rt" IN_LIST LLVM_ENABLE_RUNTIMES)
message(STATUS "Enabling Flang-RT as a dependency of Flang")
list(APPEND LLVM_ENABLE_RUNTIMES "flang-rt")
endif ()
endif() endif()
if ("libc" IN_LIST LLVM_ENABLE_PROJECTS) if ("libc" IN_LIST LLVM_ENABLE_PROJECTS)