cmake/base-config-ix.cmake

   1 # The CompilerRT build system requires CMake version 2.8.8 or higher in order
   2 # to use its support for building convenience "libraries" as a collection of
   3 # .o files. This is particularly useful in producing larger, more complex
   4 # runtime libraries.
   5
   6 include(CheckIncludeFile)
   7 include(CheckCXXSourceCompiles)
   8
   9 check_include_file(unwind.h HAVE_UNWIND_H)
  10
  11 # Used by sanitizer_common and tests.
  12 check_include_file(rpc/xdr.h HAVE_RPC_XDR_H)
  13 if (NOT HAVE_RPC_XDR_H)
  14   set(HAVE_RPC_XDR_H 0)
  15 endif()
  16
  17 # Top level target used to build all compiler-rt libraries.
  18 add_custom_target(compiler-rt ALL)
  19 add_custom_target(install-compiler-rt)
  20 add_custom_target(install-compiler-rt-stripped)
  21 set_property(
  22   TARGET
  23     compiler-rt
  24     install-compiler-rt
  25     install-compiler-rt-stripped
  26   PROPERTY
  27     FOLDER "Compiler-RT Misc"
  28 )
  29
  30 # Setting these variables from an LLVM build is sufficient that compiler-rt can
  31 # construct the output paths, so it can behave as if it were in-tree here.
  32 if (LLVM_LIBRARY_OUTPUT_INTDIR AND LLVM_RUNTIME_OUTPUT_INTDIR AND PACKAGE_VERSION)
  33   set(LLVM_TREE_AVAILABLE On)
  34 endif()
  35
  36 if (LLVM_TREE_AVAILABLE)
  37   # Compute the Clang version from the LLVM version.
  38   # FIXME: We should be able to reuse CLANG_VERSION variable calculated
  39   #        in Clang cmake files, instead of copying the rules here.
  40   string(REGEX MATCH "[0-9]+\\.[0-9]+(\\.[0-9]+)?" CLANG_VERSION
  41          ${PACKAGE_VERSION})
  42   # Setup the paths where compiler-rt runtimes and headers should be stored.
  43   set(COMPILER_RT_OUTPUT_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/clang/${CLANG_VERSION})
  44   set(COMPILER_RT_EXEC_OUTPUT_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR})
  45   set(COMPILER_RT_INSTALL_PATH lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION})
  46   option(COMPILER_RT_INCLUDE_TESTS "Generate and build compiler-rt unit tests."
  47          ${LLVM_INCLUDE_TESTS})
  48   option(COMPILER_RT_ENABLE_WERROR "Fail and stop if warning is triggered"
  49          ${LLVM_ENABLE_WERROR})
  50   # Use just-built Clang to compile/link tests on all platforms, except for
  51   # Windows where we need to use clang-cl instead.
  52   if(NOT MSVC)
  53     set(COMPILER_RT_TEST_COMPILER ${LLVM_RUNTIME_OUTPUT_INTDIR}/clang)
  54     set(COMPILER_RT_TEST_CXX_COMPILER ${LLVM_RUNTIME_OUTPUT_INTDIR}/clang++)
  55   else()
  56     set(COMPILER_RT_TEST_COMPILER ${LLVM_RUNTIME_OUTPUT_INTDIR}/clang.exe)
  57     set(COMPILER_RT_TEST_CXX_COMPILER ${LLVM_RUNTIME_OUTPUT_INTDIR}/clang++.exe)
  58   endif()
  59 else()
  60     # Take output dir and install path from the user.
  61   set(COMPILER_RT_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR} CACHE PATH
  62     "Path where built compiler-rt libraries should be stored.")
  63   set(COMPILER_RT_EXEC_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/bin CACHE PATH
  64     "Path where built compiler-rt executables should be stored.")
  65   set(COMPILER_RT_INSTALL_PATH ${CMAKE_INSTALL_PREFIX} CACHE PATH
  66     "Path where built compiler-rt libraries should be installed.")
  67   option(COMPILER_RT_INCLUDE_TESTS "Generate and build compiler-rt unit tests." OFF)
  68   option(COMPILER_RT_ENABLE_WERROR "Fail and stop if warning is triggered" OFF)
  69   # Use a host compiler to compile/link tests.
  70   set(COMPILER_RT_TEST_COMPILER ${CMAKE_C_COMPILER} CACHE PATH "Compiler to use for testing")
  71   set(COMPILER_RT_TEST_CXX_COMPILER ${CMAKE_CXX_COMPILER} CACHE PATH "C++ Compiler to use for testing")
  72 endif()
  73
  74 if("${COMPILER_RT_TEST_COMPILER}" MATCHES "clang[+]*$")
  75   set(COMPILER_RT_TEST_COMPILER_ID Clang)
  76 elseif("${COMPILER_RT_TEST_COMPILER}" MATCHES "clang.*.exe$")
  77   set(COMPILER_RT_TEST_COMPILER_ID Clang)
  78 else()
  79   set(COMPILER_RT_TEST_COMPILER_ID GNU)
  80 endif()
  81
  82 if(NOT DEFINED COMPILER_RT_OS_DIR)
  83   string(TOLOWER ${CMAKE_SYSTEM_NAME} COMPILER_RT_OS_DIR)
  84 endif()
  85 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)
  86   set(COMPILER_RT_LIBRARY_OUTPUT_DIR
  87     ${COMPILER_RT_OUTPUT_DIR})
  88   set(COMPILER_RT_LIBRARY_INSTALL_DIR
  89     ${COMPILER_RT_INSTALL_PATH})
  90 else(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR)
  91   set(COMPILER_RT_LIBRARY_OUTPUT_DIR
  92     ${COMPILER_RT_OUTPUT_DIR}/lib/${COMPILER_RT_OS_DIR})
  93   set(COMPILER_RT_LIBRARY_INSTALL_DIR
  94     ${COMPILER_RT_INSTALL_PATH}/lib/${COMPILER_RT_OS_DIR})
  95 endif()
  96
  97 if(APPLE)
  98   # On Darwin if /usr/include doesn't exist, the user probably has Xcode but not
  99   # the command line tools. If this is the case, we need to find the OS X
 100   # sysroot to pass to clang.
 101   if(NOT EXISTS /usr/include)
 102     execute_process(COMMAND xcodebuild -version -sdk macosx Path
 103        OUTPUT_VARIABLE OSX_SYSROOT
 104        ERROR_QUIET
 105        OUTPUT_STRIP_TRAILING_WHITESPACE)
 106     set(OSX_SYSROOT_FLAG "-isysroot${OSX_SYSROOT}")
 107   endif()
 108
 109   option(COMPILER_RT_ENABLE_IOS "Enable building for iOS" On)
 110   option(COMPILER_RT_ENABLE_WATCHOS "Enable building for watchOS - Experimental" Off)
 111   option(COMPILER_RT_ENABLE_TVOS "Enable building for tvOS - Experimental" Off)
 112
 113 else()
 114   option(COMPILER_RT_DEFAULT_TARGET_ONLY "Build builtins only for the default target" Off)
 115 endif()
 116
 117 if(WIN32 AND NOT MINGW AND NOT CYGWIN)
 118   set(CMAKE_SHARED_LIBRARY_PREFIX_C "")
 119   set(CMAKE_SHARED_LIBRARY_PREFIX_CXX "")
 120   set(CMAKE_STATIC_LIBRARY_PREFIX_C "")
 121   set(CMAKE_STATIC_LIBRARY_PREFIX_CXX "")
 122   set(CMAKE_STATIC_LIBRARY_SUFFIX_C ".lib")
 123   set(CMAKE_STATIC_LIBRARY_SUFFIX_CXX ".lib")
 124 endif()
 125
 126 macro(test_targets)
 127   # Find and run MSVC (not clang-cl) and get its version. This will tell clang-cl
 128   # what version of MSVC to pretend to be so that the STL works.
 129   set(MSVC_VERSION_FLAG "")
 130   if (MSVC)
 131     execute_process(COMMAND "$ENV{VSINSTALLDIR}/VC/bin/cl.exe"
 132       OUTPUT_QUIET
 133       ERROR_VARIABLE MSVC_COMPAT_VERSION
 134       )
 135     string(REGEX REPLACE "^.*Compiler Version ([0-9.]+) for .*$" "\\1"
 136       MSVC_COMPAT_VERSION "${MSVC_COMPAT_VERSION}")
 137     if (MSVC_COMPAT_VERSION MATCHES "^[0-9].+$")
 138       set(MSVC_VERSION_FLAG "-fms-compatibility-version=${MSVC_COMPAT_VERSION}")
 139       # Add this flag into the host build if this is clang-cl.
 140       if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
 141         append("${MSVC_VERSION_FLAG}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
 142       elseif (COMPILER_RT_TEST_COMPILER_ID MATCHES "Clang")
 143         # Add this flag to test compiles to suppress clang's auto-detection
 144         # logic.
 145         append("${MSVC_VERSION_FLAG}" COMPILER_RT_TEST_COMPILER_CFLAGS)
 146       endif()
 147     endif()
 148   endif()
 149
 150   # Generate the COMPILER_RT_SUPPORTED_ARCH list.
 151   if(ANDROID)
 152     # Examine compiler output to determine target architecture.
 153     detect_target_arch()
 154     set(COMPILER_RT_OS_SUFFIX "-android")
 155   elseif(NOT APPLE) # Supported archs for Apple platforms are generated later
 156     if(COMPILER_RT_DEFAULT_TARGET_ONLY)
 157       add_default_target_arch(${COMPILER_RT_DEFAULT_TARGET_ARCH})
 158     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "i[2-6]86|x86|amd64")
 159       if(NOT MSVC)
 160         if(CMAKE_SYSTEM_NAME MATCHES "OpenBSD")
 161           if (CMAKE_SIZEOF_VOID_P EQUAL 4)
 162             test_target_arch(i386 __i386__ "-m32")
 163           else()
 164             test_target_arch(x86_64 "" "-m64")
 165           endif()
 166         else()
 167           test_target_arch(x86_64 "" "-m64")
 168           test_target_arch(i386 __i386__ "-m32")
 169         endif()
 170       else()
 171         if (CMAKE_SIZEOF_VOID_P EQUAL 4)
 172           test_target_arch(i386 "" "")
 173         else()
 174           test_target_arch(x86_64 "" "")
 175         endif()
 176       endif()
 177     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "powerpc")
 178       # Strip out -nodefaultlibs when calling TEST_BIG_ENDIAN. Configuration
 179       # will fail with this option when building with a sanitizer.
 180       cmake_push_check_state()
 181       string(REPLACE "-nodefaultlibs" "" CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
 182       TEST_BIG_ENDIAN(HOST_IS_BIG_ENDIAN)
 183       cmake_pop_check_state()
 184
 185       if(HOST_IS_BIG_ENDIAN)
 186         test_target_arch(powerpc64 "" "-m64")
 187       else()
 188         test_target_arch(powerpc64le "" "-m64")
 189       endif()
 190     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "s390x")
 191       test_target_arch(s390x "" "")
 192     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "mipsel|mips64el")
 193       # Gcc doesn't accept -m32/-m64 so we do the next best thing and use
 194       # -mips32r2/-mips64r2. We don't use -mips1/-mips3 because we want to match
 195       # clang's default CPU's. In the 64-bit case, we must also specify the ABI
 196       # since the default ABI differs between gcc and clang.
 197       # FIXME: Ideally, we would build the N32 library too.
 198       test_target_arch(mipsel "" "-mips32r2" "-mabi=32")
 199       test_target_arch(mips64el "" "-mips64r2" "-mabi=64")
 200     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "mips")
 201       test_target_arch(mips "" "-mips32r2" "-mabi=32")
 202       test_target_arch(mips64 "" "-mips64r2" "-mabi=64")
 203     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "arm")
 204       if(WIN32)
 205         test_target_arch(arm "" "" "")
 206       else()
 207         test_target_arch(arm "" "-march=armv7-a" "-mfloat-abi=soft")
 208         test_target_arch(armhf "" "-march=armv7-a" "-mfloat-abi=hard")
 209         test_target_arch(armv6m "" "-march=armv6m" "-mfloat-abi=soft")
 210       endif()
 211     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "aarch32")
 212       test_target_arch(aarch32 "" "-march=armv8-a")
 213     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "aarch64")
 214       test_target_arch(aarch64 "" "-march=armv8-a")
 215     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "riscv32")
 216       test_target_arch(riscv32 "" "")
 217     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "riscv64")
 218       test_target_arch(riscv64 "" "")
 219     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "wasm32")
 220       test_target_arch(wasm32 "" "--target=wasm32-unknown-unknown")
 221     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "wasm64")
 222       test_target_arch(wasm64 "" "--target=wasm64-unknown-unknown")
 223     endif()
 224     set(COMPILER_RT_OS_SUFFIX "")
 225   endif()
 226 endmacro()