flang/CMakeLists.txt

   1 cmake_minimum_required(VERSION 3.20.0)
   2 set(LLVM_SUBPROJECT_TITLE "Flang")
   3
   4 if(NOT DEFINED LLVM_COMMON_CMAKE_UTILS)
   5   set(LLVM_COMMON_CMAKE_UTILS ${CMAKE_CURRENT_SOURCE_DIR}/../cmake)
   6 endif()
   7 include(${LLVM_COMMON_CMAKE_UTILS}/Modules/CMakePolicy.cmake
   8   NO_POLICY_SCOPE)
   9
  10 set(CMAKE_BUILD_WITH_INSTALL_NAME_DIR ON)
  11
  12 # Flang requires C++17.
  13 set(CMAKE_CXX_STANDARD 17)
  14 set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
  15 set(CMAKE_CXX_EXTENSIONS OFF)
  16
  17 if (LLVM_ENABLE_EH)
  18   # To match with the flang guidelines we currently disable
  19   # building with exception support in core LLVM.
  20   message(FATAL_ERROR "Flang does not currently support building with \
  21           LLVM exceptions enabled.  Please disable LLVM_ENABLE_EH when building \
  22           flang.")
  23 endif()
  24
  25 set(FLANG_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
  26
  27 if (CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR AND NOT MSVC_IDE)
  28   message(FATAL_ERROR "In-source builds are not allowed. \
  29           Please create a directory and run cmake from there,\
  30           passing the path to this source directory as the last argument.\
  31           This process created the file `CMakeCache.txt' and the directory\
  32           `CMakeFiles'. Please delete them.")
  33 endif()
  34
  35 option(FLANG_ENABLE_WERROR "Fail and stop building flang if a warning is triggered." OFF)
  36
  37 # The out of tree builds of the compiler and the Fortran runtime
  38 # must use the same setting of FLANG_RUNTIME_F128_MATH_LIB
  39 # to be composable. Failure to synchronize this setting may result
  40 # in linking errors or fatal failures in F128 runtime functions.
  41 set(FLANG_RUNTIME_F128_MATH_LIB "" CACHE STRING
  42   "Specifies the target library used for implementing IEEE-754 128-bit float \
  43   math in F18 runtime, e.g. it might be libquadmath for targets where \
  44   REAL(16) is mapped to __float128, or libm for targets where REAL(16) \
  45   is mapped to long double, etc."
  46   )
  47
  48 # Check for a standalone build and configure as appropriate from
  49 # there.
  50 if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
  51   message("Building Flang as a standalone project.")
  52   project(Flang)
  53   set(FLANG_STANDALONE_BUILD ON)
  54 else()
  55   set(FLANG_STANDALONE_BUILD OFF)
  56 endif()
  57
  58 # Must go below project(..)
  59 include(GNUInstallDirs)
  60
  61 # MSVC + clang-cl build requires clang_rt.builtin.${target} library
  62 if (MSVC AND CMAKE_CXX_COMPILER_ID MATCHES Clang)
  63   include(HandleCompilerRT)
  64   find_compiler_rt_library(builtins CLANG_RT_BUILTINS_LIBRARY)
  65   get_filename_component(LIBDIR "${CLANG_RT_BUILTINS_LIBRARY}" DIRECTORY)
  66   if (IS_DIRECTORY "${LIBDIR}")
  67     link_libraries(${CLANG_RT_BUILTINS_LIBRARY})
  68   endif()
  69
  70   if (MSVC_VERSION EQUAL 1942)
  71     message(FATAL_ERROR "Flang cannot be built with clang and the MSVC 17.12 "
  72             "toolchain version. Please upgrade to 17.13 or later, or switch "
  73             "to the 17.10 LTSC release. "
  74             "See https://github.com/microsoft/STL/issues/4959 for more details.")
  75   endif()
  76 endif()
  77
  78 if(CMAKE_SIZEOF_VOID_P EQUAL 4)
  79   message(FATAL_ERROR "flang isn't supported on 32 bit CPUs")
  80 endif()
  81
  82 if (FLANG_STANDALONE_BUILD)
  83   set(FLANG_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
  84   set(CMAKE_INCLUDE_CURRENT_DIR ON)
  85   if (NOT MSVC_IDE)
  86     set(LLVM_ENABLE_ASSERTIONS ${ENABLE_ASSERTIONS}
  87       CACHE BOOL "Enable assertions")
  88     # Assertions follow llvm's configuration.
  89     mark_as_advanced(LLVM_ENABLE_ASSERTIONS)
  90   endif()
  91
  92   # If the user specifies a relative path to LLVM_DIR, the calls to include
  93   # LLVM modules fail. Append the absolute path to LLVM_DIR instead.
  94   if (LLVM_DIR)
  95     get_filename_component(LLVM_DIR_ABSOLUTE ${LLVM_DIR}
  96       REALPATH BASE_DIR ${CMAKE_CURRENT_BINARY_DIR})
  97     list(APPEND CMAKE_MODULE_PATH ${LLVM_DIR_ABSOLUTE})
  98   endif()
  99   # We need a pre-built/installed version of LLVM.
 100   find_package(LLVM REQUIRED HINTS "${LLVM_DIR_ABSOLUTE}")
 101   if (NOT LLVM_DIR_ABSOLUTE)
 102     # If the user did not specify a LLVM_DIR (and therefore LLVM_DIR_ABSOLUTE
 103     # was not set), append the discovered path to CMAKE_MODULE_PATH.
 104     list(APPEND CMAKE_MODULE_PATH ${LLVM_DIR})
 105   endif()
 106
 107   # Users might specify a path to CLANG_DIR that's:
 108   #   * a full path, or
 109   #   * a path relative to the path of this script.
 110   # Append the absolute path to CLANG_DIR so that find_package works in both
 111   # cases.
 112   if (CLANG_DIR)
 113     get_filename_component(
 114       CLANG_DIR_ABSOLUTE
 115       ${CLANG_DIR}
 116       REALPATH
 117       BASE_DIR ${CMAKE_CURRENT_BINARY_DIR})
 118     list(APPEND CMAKE_MODULE_PATH ${CLANG_DIR_ABSOLUTE})
 119
 120     # TODO: Remove when libclangDriver is lifted out of Clang
 121     find_package(Clang REQUIRED PATHS "${CLANG_DIR_ABSOLUTE}" NO_DEFAULT_PATH)
 122   else()
 123     find_package(Clang REQUIRED)
 124     list(APPEND CMAKE_MODULE_PATH ${Clang_DIR})
 125   endif()
 126
 127   # If LLVM links to zlib we need the imported targets so we can too.
 128   if(LLVM_ENABLE_ZLIB)
 129     find_package(ZLIB REQUIRED)
 130   endif()
 131   option(LLVM_ENABLE_PEDANTIC "Compile with pedantic enabled." ON)
 132   if(CMAKE_COMPILER_IS_GNUCXX)
 133     set(USE_NO_MAYBE_UNINITIALIZED 1)
 134   endif()
 135
 136   include(AddLLVM)
 137   include(HandleLLVMOptions)
 138   include(VersionFromVCS)
 139   include(GetErrcMessages)
 140
 141   include(AddClang)
 142
 143   include(TableGen)
 144   # If the user specifies a relative path to MLIR_DIR, the calls to include
 145   # MLIR modules fail. Append the absolute path to MLIR_DIR instead.
 146   if (MLIR_DIR)
 147     get_filename_component(MLIR_DIR_ABSOLUTE ${MLIR_DIR}
 148       REALPATH BASE_DIR ${CMAKE_CURRENT_BINARY_DIR})
 149     list(APPEND CMAKE_MODULE_PATH ${MLIR_DIR_ABSOLUTE})
 150   endif()
 151   find_package(MLIR REQUIRED CONFIG HINTS ${MLIR_DIR_ABSOLUTE})
 152   if (NOT MLIR_DIR_ABSOLUTE)
 153     list(APPEND CMAKE_MODULE_PATH ${MLIR_DIR})
 154   endif()
 155   # Use SYSTEM for the same reasons as for LLVM includes
 156   include_directories(SYSTEM ${MLIR_INCLUDE_DIRS})
 157   include(AddMLIR)
 158   find_program(MLIR_TABLEGEN_EXE "mlir-tblgen" ${LLVM_TOOLS_BINARY_DIR}
 159     NO_DEFAULT_PATH)
 160
 161   option(LLVM_INSTALL_TOOLCHAIN_ONLY
 162     "Only include toolchain files in the 'install' target." OFF)
 163   option(LLVM_FORCE_USE_OLD_TOOLCHAIN
 164     "Set to ON to force using an old, unsupported host toolchain." OFF)
 165
 166
 167   # Add LLVM include files as if they were SYSTEM because there are complex unused
 168   # parameter issues that may or may not appear depending on the environments and
 169   # compilers (ifdefs are involved). This allows warnings from LLVM headers to be
 170   # ignored while keeping -Wunused-parameter a fatal error inside f18 code base.
 171   # This may have to be fine-tuned if flang headers are consider part of this
 172   # LLVM_INCLUDE_DIRS when merging in the monorepo (Warning from flang headers
 173   # should not be suppressed).
 174   include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
 175   add_definitions(${LLVM_DEFINITIONS})
 176
 177   # LLVM's cmake configuration files currently sneak in a c++11 flag.
 178   # We look for it here and remove it from Flang's compile flags to
 179   # avoid some mixed compilation flangs (e.g. -std=c++11 ... -std=c++17).
 180   if (DEFINED LLVM_CXX_STD)
 181     message("LLVM configuration set a C++ standard: ${LLVM_CXX_STD}")
 182     if (NOT LLVM_CXX_STD EQUAL "c++17")
 183       message("Flang: Overriding LLVM's 'cxx_std' setting...")
 184       message("    removing '-std=${LLVM_CXX_STD}'")
 185       message("    CMAKE_CXX_FLAGS='${CMAKE_CXX_FLAGS}'")
 186       string(REPLACE " -std=${LLVM_CXX_STD}" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 187       message("    [NEW] CMAKE_CXX_FLAGS='${CMAKE_CXX_FLAGS}'")
 188     endif()
 189   endif()
 190
 191   link_directories("${LLVM_LIBRARY_DIR}")
 192
 193   set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 194   set(CMAKE_LIBRARY_OUTPUT_DIRECTORY
 195     ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX})
 196   set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY
 197     ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX})
 198
 199   set(LLVM_EXTERNAL_LIT "${LLVM_TOOLS_BINARY_DIR}/llvm-lit" CACHE STRING "Command used to spawn lit")
 200
 201   option(FLANG_INCLUDE_TESTS
 202          "Generate build targets for the Flang unit tests."
 203          ON)
 204
 205   get_errc_messages(LLVM_LIT_ERRC_MESSAGES)
 206
 207 #Handle unittests when out-of-tree
 208   set(FLANG_GTEST_AVAIL 0)
 209   if (FLANG_INCLUDE_TESTS)
 210     set(UNITTEST_DIR ${LLVM_THIRD_PARTY_DIR}/unittest)
 211     if(EXISTS ${UNITTEST_DIR}/googletest/include/gtest/gtest.h)
 212       if (NOT TARGET llvm_gtest)
 213         add_subdirectory(${UNITTEST_DIR} third-party/unittest)
 214       endif()
 215       set(FLANG_GTEST_AVAIL 1)
 216     else()
 217       message(WARNING
 218       "Unit-tests will be skipped as LLVM install does not include google-test related headers and libraries.")
 219       set(FLANG_GTEST_AVAIL 0)
 220     endif()
 221   endif()
 222   if (FLANG_GTEST_AVAIL)
 223     add_custom_target(check-all DEPENDS check-flang FlangUnitTests)
 224   else()
 225     add_custom_target(check-all DEPENDS check-flang )
 226   endif()
 227   if (LLVM_BUILD_DOCS)
 228     add_custom_target(doxygen ALL)
 229   endif()
 230
 231 else()
 232   option(FLANG_INCLUDE_TESTS
 233          "Generate build targets for the Flang unit tests."
 234          ${LLVM_INCLUDE_TESTS})
 235   set(FLANG_GTEST_AVAIL 1)
 236
 237   if(FLANG_STANDALONE_BUILD)
 238     set(FLANG_BINARY_DIR ${CMAKE_BINARY_DIR}/tools/flang)
 239   else()
 240     set(FLANG_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 241   endif()
 242
 243   set(MLIR_MAIN_SRC_DIR ${LLVM_MAIN_SRC_DIR}/../mlir ) # --src-root
 244   set(MLIR_INCLUDE_DIR ${MLIR_MAIN_SRC_DIR}/include ) # --includedir
 245   set(MLIR_TABLEGEN_OUTPUT_DIR ${CMAKE_BINARY_DIR}/tools/mlir/include)
 246   include_directories(SYSTEM ${MLIR_INCLUDE_DIR})
 247   include_directories(SYSTEM ${MLIR_TABLEGEN_OUTPUT_DIR})
 248 endif()
 249
 250 set(FLANG_TOOLS_INSTALL_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH
 251     "Path for binary subdirectory (defaults to '${CMAKE_INSTALL_BINDIR}')")
 252 mark_as_advanced(FLANG_TOOLS_INSTALL_DIR)
 253
 254 set(FLANG_INTRINSIC_MODULES_DIR ${CMAKE_BINARY_DIR}/include/flang)
 255 set(FLANG_INCLUDE_DIR ${FLANG_BINARY_DIR}/include)
 256
 257 # TODO: Remove when libclangDriver is lifted out of Clang
 258 if(FLANG_STANDALONE_BUILD)
 259   set(CLANG_INCLUDE_DIR ${CLANG_INCLUDE_DIRS} )
 260   # No need to specify TableGen output dir as that's embedded in CLANG_DIR
 261 else()
 262   set(CLANG_INCLUDE_DIR ${LLVM_MAIN_SRC_DIR}/../clang/include )
 263   # Specify TableGen output dir for things like DiagnosticCommonKinds.inc,
 264   # DiagnosticDriverKinds.inc (required for reporting diagnostics)
 265   set(CLANG_TABLEGEN_OUTPUT_DIR ${CMAKE_BINARY_DIR}/tools/clang/include)
 266   include_directories(SYSTEM ${CLANG_TABLEGEN_OUTPUT_DIR})
 267 endif()
 268 include_directories(SYSTEM ${CLANG_INCLUDE_DIR})
 269
 270 # tco tool and FIR lib output directories
 271 if(FLANG_STANDALONE_BUILD)
 272   set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/bin)
 273   set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/lib)
 274 endif()
 275 # Always build tco tool
 276 set(LLVM_BUILD_TOOLS ON)
 277
 278 include_directories(BEFORE
 279   ${FLANG_BINARY_DIR}/include
 280   ${FLANG_SOURCE_DIR}/include)
 281
 282 # Add Flang-centric modules to cmake path.
 283 list(INSERT CMAKE_MODULE_PATH 0
 284   "${FLANG_SOURCE_DIR}/cmake/modules"
 285   "${LLVM_COMMON_CMAKE_UTILS}/Modules"
 286   )
 287 include(AddFlang)
 288
 289 if (NOT DEFAULT_SYSROOT)
 290   set(DEFAULT_SYSROOT "" CACHE PATH
 291     "The <path> to use for the system root for all compiler invocations (--sysroot=<path>).")
 292 endif()
 293
 294 if (NOT ENABLE_LINKER_BUILD_ID)
 295   set(ENABLE_LINKER_BUILD_ID OFF CACHE BOOL "pass --build-id to ld")
 296 endif()
 297
 298 set(FLANG_DEFAULT_LINKER "" CACHE STRING
 299   "Default linker to use (linker name or absolute path, empty for platform default)")
 300
 301 set(FLANG_DEFAULT_RTLIB "" CACHE STRING
 302    "Default Fortran runtime library to use (\"libFortranRuntime\"), leave empty for platform default.")
 303
 304 if (NOT(FLANG_DEFAULT_RTLIB STREQUAL ""))
 305   message(WARNING "Resetting Flang's default runtime library to use platform default.")
 306   set(FLANG_DEFAULT_RTLIB "" CACHE STRING
 307       "Default runtime library to use (empty for platform default)" FORCE)
 308 endif()
 309
 310
 311
 312 set(PACKAGE_VERSION "${LLVM_PACKAGE_VERSION}")
 313 if (NOT PACKAGE_VERSION)
 314   set(PACKAGE_VERSION ${LLVM_VERSION_MAJOR})
 315 endif()
 316
 317
 318 if (NOT DEFINED FLANG_VERSION_MAJOR)
 319   set(FLANG_VERSION_MAJOR ${LLVM_VERSION_MAJOR})
 320 endif()
 321
 322 if (NOT DEFINED FLANG_VERSION_MINOR)
 323   set(FLANG_VERSION_MINOR ${LLVM_VERSION_MINOR})
 324 endif()
 325
 326 if (NOT DEFINED FLANG_VERSION_PATCHLEVEL)
 327   set(FLANG_VERSION_PATCHLEVEL ${LLVM_VERSION_PATCH})
 328 endif()
 329
 330 # Unlike PACKAGE_VERSION, FLANG_VERSION does not include LLVM_VERSION_SUFFIX.
 331 set(FLANG_VERSION "${FLANG_VERSION_MAJOR}.${FLANG_VERSION_MINOR}.${FLANG_VERSION_PATCHLEVEL}")
 332 message(STATUS "Flang version: ${FLANG_VERSION}")
 333 # Flang executable version information
 334 set(FLANG_EXECUTABLE_VERSION
 335     "${FLANG_VERSION_MAJOR}" CACHE STRING
 336     "Major version number to appended to the flang executable name.")
 337 set(LIBFLANG_LIBRARY_VERSION
 338     "${FLANG_VERSION_MAJOR}" CACHE STRING
 339     "Major version number to appended to the libflang library.")
 340
 341 mark_as_advanced(FLANG_EXECUTABLE_VERSION LIBFLANG_LIBRARY_VERSION)
 342
 343 set(FLANG_VENDOR ${PACKAGE_VENDOR} CACHE STRING
 344   "Vendor-specific Flang version information.")
 345 set(FLANG_VENDOR_UTI "org.llvm.flang" CACHE STRING
 346   "Vendor-specific uti.")
 347
 348 if (FLANG_VENDOR)
 349   add_definitions(-DFLANG_VENDOR="${FLANG_VENDOR} ")
 350 endif()
 351
 352 set(FLANG_REPOSITORY_STRING "" CACHE STRING
 353   "Vendor-specific text for showing the repository the source is taken from.")
 354 if (FLANG_REPOSITORY_STRING)
 355   add_definitions(-DFLANG_REPOSITORY_STRING="${FLANG_REPOSITORY_STRING}")
 356 endif()
 357
 358 if (FLANG_RUNTIME_F128_MATH_LIB)
 359   add_compile_definitions(
 360     FLANG_RUNTIME_F128_MATH_LIB="${FLANG_RUNTIME_F128_MATH_LIB}"
 361     )
 362 endif()
 363
 364 include(TestBigEndian)
 365 test_big_endian(IS_BIGENDIAN)
 366 if (IS_BIGENDIAN)
 367   add_compile_definitions(FLANG_BIG_ENDIAN=1)
 368 else ()
 369   add_compile_definitions(FLANG_LITTLE_ENDIAN=1)
 370 endif ()
 371
 372 # Configure Flang's Version.inc file.
 373 configure_file(
 374   ${CMAKE_CURRENT_SOURCE_DIR}/include/flang/Version.inc.in
 375   ${CMAKE_CURRENT_BINARY_DIR}/include/flang/Version.inc)
 376 # Configure Flang's version info header file.
 377 configure_file(
 378   ${FLANG_SOURCE_DIR}/include/flang/Config/config.h.cmake
 379   ${FLANG_BINARY_DIR}/include/flang/Config/config.h)
 380
 381 if (FLANG_ENABLE_WERROR)
 382   # The following is taken from llvm/cmake/modules/HandleLLVMOptions.cmake
 383   # Keep this up-to-date with that file
 384   if( MSVC )
 385     append("/WX" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
 386   endif()
 387   if ( LLVM_COMPILER_IS_GCC_COMPATIBLE )
 388     append("-Werror" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
 389     append("-Wno-error" CMAKE_REQUIRED_FLAGS)
 390   endif( LLVM_COMPILER_IS_GCC_COMPATIBLE )
 391 endif()
 392
 393 # Builtin check_cxx_compiler_flag doesn't seem to work correctly
 394 macro(check_compiler_flag flag resultVar)
 395   unset(${resultVar} CACHE)
 396   check_cxx_compiler_flag("${flag}" ${resultVar})
 397 endmacro()
 398
 399 check_compiler_flag("-Werror -Wno-deprecated-copy" CXX_SUPPORTS_NO_DEPRECATED_COPY_FLAG)
 400 if (CXX_SUPPORTS_NO_DEPRECATED_COPY_FLAG)
 401   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-copy")
 402 endif()
 403 check_compiler_flag("-Wstring-conversion" CXX_SUPPORTS_NO_STRING_CONVERSION_FLAG)
 404 if (CXX_SUPPORTS_NO_STRING_CONVERSION_FLAG)
 405   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-string-conversion")
 406 endif()
 407 check_compiler_flag("-Wno-ctad-maybe-unsupported" CXX_SUPPORTS_NO_CTAD_MAYBE_UNSUPPORTED_FLAG)
 408 if (CXX_SUPPORTS_NO_CTAD_MAYBE_UNSUPPORTED_FLAG)
 409   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-ctad-maybe-unsupported")
 410 endif()
 411
 412 # Add appropriate flags for GCC
 413 if (LLVM_COMPILER_IS_GCC_COMPATIBLE)
 414
 415   if (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
 416     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing -fno-semantic-interposition")
 417   else()
 418     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-command-line-argument -Wstring-conversion \
 419           -Wcovered-switch-default")
 420   endif()  # Clang.
 421
 422   check_cxx_compiler_flag("-Werror -Wnested-anon-types" CXX_SUPPORTS_NO_NESTED_ANON_TYPES_FLAG)
 423   if (CXX_SUPPORTS_NO_NESTED_ANON_TYPES_FLAG)
 424     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-nested-anon-types")
 425   endif()
 426
 427   # Add to build type flags.
 428   set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUGF18")
 429   set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -DCHECK=\"(void)\"")
 430
 431   # Building shared libraries is bad for performance with GCC by default
 432   # due to the need to preserve the right to override external entry points
 433   if (BUILD_SHARED_LIBS AND NOT (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
 434    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-semantic-interposition")
 435   endif()
 436
 437 endif()
 438
 439 # Clang on Darwin enables non-POSIX extensions by default, which allows the
 440 # macro HUGE to leak out of <math.h> even when it is never directly included,
 441 # conflicting with Flang's HUGE symbols.
 442 # Set _POSIX_C_SOURCE to avoid including these extensions.
 443 if (APPLE)
 444   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_POSIX_C_SOURCE=200809")
 445 endif()
 446
 447 list(REMOVE_DUPLICATES CMAKE_CXX_FLAGS)
 448
 449 # Determine HOST_LINK_VERSION on Darwin.
 450 set(HOST_LINK_VERSION)
 451 if (APPLE)
 452   set(LD_V_OUTPUT)
 453   execute_process(
 454     COMMAND sh -c "${CMAKE_LINKER} -v 2>&1 | head -1"
 455     RESULT_VARIABLE HAD_ERROR
 456     OUTPUT_VARIABLE LD_V_OUTPUT)
 457   if (NOT HAD_ERROR)
 458     if ("${LD_V_OUTPUT}" MATCHES ".*ld64-([0-9.]+).*")
 459       string(REGEX REPLACE ".*ld64-([0-9.]+).*" "\\1" HOST_LINK_VERSION ${LD_V_OUTPUT})
 460     elseif ("${LD_V_OUTPUT}" MATCHES "[^0-9]*([0-9.]+).*")
 461       string(REGEX REPLACE "[^0-9]*([0-9.]+).*" "\\1" HOST_LINK_VERSION ${LD_V_OUTPUT})
 462     endif()
 463   else()
 464     message(FATAL_ERROR "${CMAKE_LINKER} failed with status ${HAD_ERROR}")
 465   endif()
 466 endif()
 467
 468 include(AddFlang)
 469
 470 if (FLANG_INCLUDE_TESTS)
 471   add_compile_definitions(FLANG_INCLUDE_TESTS=1)
 472 endif()
 473
 474 option(FLANG_CUF_RUNTIME
 475   "Compile CUDA Fortran runtime sources" OFF)
 476 if (FLANG_CUF_RUNTIME)
 477   find_package(CUDAToolkit REQUIRED)
 478 endif()
 479
 480 add_subdirectory(include)
 481 add_subdirectory(lib)
 482 add_subdirectory(cmake/modules)
 483
 484 option(FLANG_BUILD_TOOLS
 485   "Build the Flang tools. If OFF, just generate build targets." ON)
 486 if (FLANG_BUILD_TOOLS)
 487   add_subdirectory(tools)
 488 endif()
 489
 490 add_subdirectory(runtime)
 491
 492 if (LLVM_INCLUDE_EXAMPLES)
 493   add_subdirectory(examples)
 494 endif()
 495
 496 if (FLANG_INCLUDE_TESTS)
 497   add_subdirectory(test)
 498   if (FLANG_GTEST_AVAIL)
 499     add_subdirectory(unittests)
 500   endif ()
 501 endif()
 502
 503 option(FLANG_INCLUDE_DOCS "Generate build targets for the Flang docs."
 504        ${LLVM_INCLUDE_DOCS})
 505 if (FLANG_INCLUDE_DOCS)
 506   add_subdirectory(docs)
 507 endif()
 508
 509 # Custom target to install Flang libraries.
 510 add_custom_target(flang-libraries)
 511 set_target_properties(flang-libraries PROPERTIES FOLDER "Flang/Meta")
 512
 513 if (NOT LLVM_ENABLE_IDE)
 514   add_llvm_install_targets(install-flang-libraries
 515    DEPENDS flang-libraries
 516    COMPONENT flang-libraries)
 517 endif()
 518
 519 get_property(FLANG_LIBS GLOBAL PROPERTY FLANG_LIBS)
 520 if (FLANG_LIBS)
 521   list(REMOVE_DUPLICATES FLANG_LIBS)
 522   foreach(lib ${FLANG_LIBS})
 523     add_dependencies(flang-libraries ${lib})
 524     if (NOT LLVM_ENABLE_IDE)
 525       add_dependencies(install-flang-libraries install-${lib})
 526     endif()
 527   endforeach()
 528 endif()
 529
 530 if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
 531   add_llvm_install_targets(install-flang-headers
 532     COMPONENT flang-headers)
 533
 534   install(DIRECTORY include/flang
 535     DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
 536     COMPONENT flang-headers
 537     FILES_MATCHING
 538     PATTERN "*.def"
 539     PATTERN "*.h"
 540     PATTERN "*.inc"
 541     PATTERN "*.td"
 542     PATTERN "config.h" EXCLUDE
 543     PATTERN ".git"     EXCLUDE
 544     PATTERN "CMakeFiles" EXCLUDE)
 545
 546   install(DIRECTORY ${FLANG_INCLUDE_DIR}/flang
 547     DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
 548     COMPONENT flang-headers
 549     FILES_MATCHING
 550     PATTERN "*.inc"
 551     )
 552 endif()
 553
 554 # Put ISO_Fortran_binding.h into the include files of the build area now
 555 # so that we can run tests before installing
 556 include(GetClangResourceDir)
 557 get_clang_resource_dir(HEADER_BINARY_DIR PREFIX ${LLVM_LIBRARY_OUTPUT_INTDIR}/.. SUBDIR include)
 558 configure_file(
 559   ${FLANG_SOURCE_DIR}/include/flang/ISO_Fortran_binding.h
 560   ${HEADER_BINARY_DIR}/ISO_Fortran_binding.h)
 561
 562 # And also install it into the install area
 563 get_clang_resource_dir(HEADER_INSTALL_DIR SUBDIR include)
 564 install(
 565   FILES include/flang/ISO_Fortran_binding.h
 566   DESTINATION ${HEADER_INSTALL_DIR} )
 567