Backport from flang_runtime_shared

Author: Meinersbur

flang-rt/CMakeLists.txt

@@ -88,7 +88,6 @@ 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
@@ -97,31 +96,28 @@ if (LLVM_TREE_AVAILABLE)
   # 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_DIR PREFIX "${LLVM_LIBRARY_OUTPUT_INTDIR}/..")
-  get_clang_resource_dir(FLANG_RT_INSTALL_PATH)
-
-  extend_path(FLANG_RT_BUILD_TOOLCHAIN_LIB_DIR "${FLANG_RT_OUTPUT_DIR}" "${toolchain_lib_subdir}")
+  get_clang_resource_dir(FLANG_RT_OUTPUT_RESOURCE_DIR PREFIX "${LLVM_LIBRARY_OUTPUT_INTDIR}/..")
+  get_clang_resource_dir(FLANG_RT_INSTALL_RESOURCE_PATH)
 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_DIR "${CMAKE_CURRENT_BINARY_DIR}")
-  set(FLANG_RT_INSTALL_PATH "${CMAKE_INSTALL_LIBDIR}/clang/${LLVM_VERSION_MAJOR}")
-
-  extend_path(FLANG_RT_BUILD_TOOLCHAIN_LIB_DIR "${FLANG_RT_OUTPUT_DIR}" "${CMAKE_INSTALL_LIBDIR}")
+  # between bootstrap and standalone runtimes builds.
+  set(FLANG_RT_OUTPUT_RESOURCE_DIR "${CMAKE_CURRENT_BINARY_DIR}")
+  set(FLANG_RT_INSTALL_RESOURCE_PATH "${CMAKE_INSTALL_LIBDIR}/clang/${LLVM_VERSION_MAJOR}")
 endif ()
+cmake_path(NORMAL_PATH FLANG_RT_OUTPUT_RESOURCE_DIR)
+cmake_path(NORMAL_PATH FLANG_RT_INSTALL_RESOURCE_PATH)
 
-# Apply the arch-specific library dir with the resource dir.
-extend_path(FLANG_RT_INSTALL_TOOLCHAIN_LIB_DIR "${FLANG_RT_INSTALL_PATH}" "${toolchain_lib_subdir}")
-
-cmake_path(NORMAL_PATH FLANG_RT_OUTPUT_DIR)
-cmake_path(NORMAL_PATH FLANG_RT_INSTALL_PATH)
-cmake_path(NORMAL_PATH FLANG_RT_BUILD_TOOLCHAIN_LIB_DIR)
-cmake_path(NORMAL_PATH FLANG_RT_INSTALL_TOOLCHAIN_LIB_DIR)
+# Determine subdirectories for build output and install destinations.
+get_toolchain_library_subdir(toolchain_lib_subdir)
+extend_path(FLANG_RT_OUTPUT_RESOURCE_LIB_DIR "${FLANG_RT_OUTPUT_RESOURCE_DIR}" "${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_LIB_DIR)
+cmake_path(NORMAL_PATH FLANG_RT_INSTALL_RESOURCE_LIB_PATH)
 
 
 #################

flang-rt/cmake/modules/AddFlangRT.cmake

@@ -44,9 +44,6 @@ function (add_flangrt_library name)
       ")
   endif ()
 
-  # 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)
-
   # Forward libtype to add_library
   set(extra_args "")
   if (ARG_SHARED)
@@ -62,6 +59,9 @@ function (add_flangrt_library name)
     list(APPEND extra_args EXCLUDE_FROM_ALL)
   endif ()
 
+  # 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)
+
   add_library(${name} ${extra_args} ${ARG_ADDITIONAL_HEADERS} ${ARG_UNPARSED_ARGUMENTS})
 
   if (ARG_INSTALL_WITH_TOOLCHAIN)
@@ -103,7 +103,7 @@ function (add_flangrt_library name)
       )
   endif ()
 
-  # Flang-rt's public headers
+  # Flang-RT's public headers
   target_include_directories(${name} PRIVATE "${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")
@@ -121,12 +121,24 @@ function (add_flangrt_library name)
   endif ()
 
   # Flang/Clang (including clang-cl) -compiled programs targeting the MSVC ABI
-  # should only depend on msv(u)crt. LLVM still emits libgcc/compiler-rt
+  # 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") AND FLANG_RT_BUILTINS_LIBRARY)
-    target_compile_options(${name} PRIVATE "$<$<COMPILE_LANGUAGE:CXX,C>:-Xclang>$<$<COMPILE_LANGUAGE:Fortran>:-Xflang>" "--dependent-lib=${FLANG_RT_BUILTINS_LIBRARY}")
+  if (MSVC AND CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    if (FLANG_RT_BUILTINS_LIBRARY)
+      target_compile_options(${name} PRIVATE "$<$<COMPILE_LANGUAGE:CXX,C>:-Xclang>" "--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>" "--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 ${name}
+        may result in a linker error.")
+    endif ()
   endif ()
 
   # Non-GTest unittests depend on LLVMSupport
@@ -146,19 +158,15 @@ function (add_flangrt_library name)
   if (ARG_INSTALL_WITH_TOOLCHAIN)
     set_target_properties(${name}
       PROPERTIES
-        LIBRARY_OUTPUT_DIRECTORY "${FLANG_RT_BUILD_TOOLCHAIN_LIB_DIR}"
-        ARCHIVE_OUTPUT_DIRECTORY "${FLANG_RT_BUILD_TOOLCHAIN_LIB_DIR}"
-        RUNTIME_OUTPUT_DIRECTORY "${FLANG_RT_BUILD_TOOLCHAIN_LIB_DIR}"
+        ARCHIVE_OUTPUT_DIRECTORY "${FLANG_RT_OUTPUT_RESOURCE_LIB_DIR}"
       )
 
     install(TARGETS ${name}
-        LIBRARY DESTINATION "${FLANG_RT_INSTALL_TOOLCHAIN_LIB_DIR}"
-        ARCHIVE DESTINATION "${FLANG_RT_INSTALL_TOOLCHAIN_LIB_DIR}"
-        RUNTIME DESTINATION "${FLANG_RT_INSTALL_TOOLCHAIN_LIB_DIR}"
+        ARCHIVE DESTINATION "${FLANG_RT_INSTALL_RESOURCE_LIB_PATH}"
       )
   endif ()
 
-  # flang-rt should build all the flang-rt targets that are built in an
+  # 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 ${name})

flang-rt/lib/FortranFloat128Math/CMakeLists.txt

@@ -96,16 +96,16 @@ if (FLANG_RUNTIME_F128_MATH_LIB)
 
   if (WIN32)
     # Do not create a FortranFloat128Math library under Windows, the Flang
-    # driver never links it. Instead, add the sources to the flang_rt itself.
+    # driver never links it. Instead, add the sources to flang_rt itself.
     target_sources(FortranFloat128MathILib INTERFACE ${sources})
     target_compile_definitions(FortranFloat128MathILib INTERFACE HAS_QUADMATHLIB)
   else ()
     add_flangrt_library(FortranFloat128Math STATIC INSTALL_WITH_TOOLCHAIN
       ${sources})
-   endif ()
-   target_include_directories(FortranFloat128Math PRIVATE
-     "${FLANG_RT_SOURCE_DIR}/lib/flang_rt"
-     )
+    target_include_directories(FortranFloat128Math PRIVATE
+        "${FLANG_RT_SOURCE_DIR}/lib/flang_rt"
+      )
+  endif ()
 elseif (HAVE_LDBL_MANT_DIG_113)
   # We can use 'long double' versions from libc.
   check_library_exists(m sinl "" FOUND_LIBM)

flang-rt/lib/Testing/CMakeLists.txt

@@ -12,8 +12,9 @@ file(GLOB_RECURSE public_headers
 )
 
 add_flangrt_library(NonGTestTesting EXCLUDE_FROM_ALL LINK_TO_LLVM
-  ${FLANG_SOURCE_DIR}/lib/Testing/testing.cpp
-  ${FLANG_SOURCE_DIR}/lib/Testing/fp-testing.cpp
- ADDITIONAL_HEADERS
-   ${public_headers}
-)
+      ${FLANG_SOURCE_DIR}/lib/Testing/testing.cpp
+      ${FLANG_SOURCE_DIR}/lib/Testing/fp-testing.cpp
+
+    ADDITIONAL_HEADERS
+      ${public_headers}
+  )

flang-rt/test/Runtime/no-cpp-dep.c

@@ -6,7 +6,7 @@ a C compiler.
 UNSUPPORTED: system-windows
 
 RUN: %if system-aix %{ export OBJECT_MODE=64 %}
-RUN: %cc -std=c99 %s -I%include %libruntime -lm %deplibs \
+RUN: %cc -std=c99 %s -I%include -L"%libdir" -lflang_rt -lm %deplibs \
 RUN: %if system-aix %{-lpthread %}
 */
 

flang-rt/test/lit.cfg.py

@@ -80,24 +80,24 @@ def shjoin(args, sep=" "):
         extra_args=isysroot_flag,
         unresolved="fatal",
     ),
-    ToolSubst("%cc", command=config.cc, extra_args=isysroot_flag, unresolved="fatal"),
+    ToolSubst("%cc",
+        command=config.cc,
+        extra_args=isysroot_flag,
+        unresolved="fatal"
+    ),
 ]
 llvm_config.add_tool_substitutions(tools)
 
 # Let tests find LLVM's standard tools (FileCheck, split-file, not, ...)
 llvm_config.with_environment("PATH", config.llvm_tools_dir, append_path=True)
 
-# Library path of libflang_rt.a
-config.substitutions.append(("%libdir", config.flang_rt_build_lib_dir))
+# Include path for C headers that define Flang's Fortran ABI.
+config.substitutions.append(("%include", os.path.join(config.flang_source_dir, "include")))
 
-# Define some variables to help us test that the flang runtime doesn't depend on
-# the C++ runtime libraries. For this we need a C compiler.
-libruntime = os.path.join(config.flang_rt_build_lib_dir, "libflang_rt.a")
-include = os.path.join(config.flang_source_dir, "include")
-config.substitutions.append(("%libruntime", libruntime))
-config.substitutions.append(("%include", include))
+# Library path of libflang_rt.a (for lib search path when using non-Flang driver for linking)
+config.substitutions.append(("%libdir", config.flang_rt_output_resource_lib_dir))
 
-# Additional library depedendencies the that flang driver does not add itself.
+# Additional library depedendencies the that Flang driver does not add itself.
 deplibs = []
 if config.flang_rt_experimental_offload_support == "CUDA":
     deplibs.append("-lcudart")

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_build_lib_dir = "@FLANG_RT_BUILD_TOOLCHAIN_LIB_DIR@"
+config.flang_rt_output_resource_lib_dir = "@FLANG_RT_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@"

flang-rt/unittests/CMakeLists.txt

@@ -10,7 +10,7 @@
 # output. Therefore it also needs to include files from LLVM. Unfortunately,
 # LLVM/GTest doesn't add the include search path itself. Limiting the scope
 # using target_include_directories does not work because with
-# LLVM_INSTALL_GTEST=ON, llvm_gtest is an IMPORT library.
+# LLVM_INSTALL_GTEST=ON, as llvm_gtest is an IMPORT library.
 include_directories("${LLVM_INCLUDE_DIR}" "${LLVM_MAIN_INCLUDE_DIR}")
 
 # Add GTest if not already present.
@@ -91,11 +91,13 @@ function(add_flangrt_nongtest_unittest test_name)
       set(suffix .test)
   endif()
 
-  add_executable(${test_name}${suffix} ${ARG_UNPARSED_ARGUMENTS})
+  add_executable(${test_name}${suffix} EXCLUDE_FROM_ALL ${ARG_UNPARSED_ARGUMENTS})
   set_target_properties(${test_name}${suffix} PROPERTIES FOLDER "Flang-RT/Tests/Unit")
 
-  target_include_directories(${test_name}${suffix} PRIVATE "${FLANG_RT_SOURCE_DIR}/include")
-  target_include_directories(${test_name}${suffix} PRIVATE "${FLANG_SOURCE_DIR}/include")
+  target_include_directories(${test_name}${suffix} PRIVATE
+      "${FLANG_RT_SOURCE_DIR}/include"
+      "${FLANG_SOURCE_DIR}/include"
+    )
   target_link_libraries(${test_name}${suffix} PRIVATE NonGTestTesting ${ARG_LINK_LIBS})
 
   if(NOT ARG_SLOW_TEST)