CMakeLists.txt

   1 # CMake build for CompilerRT.
   2 #
   3 # This build assumes that CompilerRT is checked out into the
   4 # 'projects/compiler-rt' inside of an LLVM tree, it is not a stand-alone build
   5 # system.
   6 #
   7 # An important constraint of the build is that it only produces libraries
   8 # based on the ability of the host toolchain to target various platforms.
   9
  10 include(LLVMParseArguments)
  11
  12 # The CompilerRT build system requires CMake version 2.8.8 or higher in order
  13 # to use its support for building convenience "libraries" as a collection of
  14 # .o files. This is particularly useful in producing larger, more complex
  15 # runtime libraries.
  16 cmake_minimum_required(VERSION 2.8.8)
  17
  18 # Compute the Clang version from the LLVM version.
  19 # FIXME: We should be able to reuse CLANG_VERSION variable calculated
  20 #        in Clang cmake files, instead of copying the rules here.
  21 string(REGEX MATCH "[0-9]+\\.[0-9]+(\\.[0-9]+)?" CLANG_VERSION
  22        ${PACKAGE_VERSION})
  23 # Setup the paths where compiler-rt runtimes and headers should be stored.
  24 set(LIBCLANG_INSTALL_PATH lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION})
  25 string(TOLOWER ${CMAKE_SYSTEM_NAME} LIBCLANG_OS_DIR)
  26 set(CLANG_RESOURCE_DIR ${LLVM_BINARY_DIR}/lib/clang/${CLANG_VERSION})
  27 set(COMPILER_RT_LIBRARY_OUTPUT_DIR ${CLANG_RESOURCE_DIR}/lib/${LIBCLANG_OS_DIR})
  28 set(COMPILER_RT_LIBRARY_INSTALL_DIR
  29   ${LIBCLANG_INSTALL_PATH}/lib/${LIBCLANG_OS_DIR})
  30
  31 # Add path for custom modules
  32 set(CMAKE_MODULE_PATH
  33   ${CMAKE_MODULE_PATH}
  34   "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules"
  35   )
  36 include(AddCompilerRT)
  37
  38 set(COMPILER_RT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
  39 set(COMPILER_RT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
  40 # Setup custom SDK sysroots.
  41 set(COMPILER_RT_DARWIN_SDK_SYSROOT ${COMPILER_RT_SOURCE_DIR}/SDKs/darwin)
  42 set(COMPILER_RT_LINUX_SDK_SYSROOT ${COMPILER_RT_SOURCE_DIR}/SDKs/linux)
  43
  44 # Detect whether the current target platform is 32-bit or 64-bit, and setup
  45 # the correct commandline flags needed to attempt to target 32-bit and 64-bit.
  46 if(CMAKE_SIZEOF_VOID_P EQUAL 4 OR LLVM_BUILD_32_BITS)
  47   set(TARGET_64_BIT_CFLAGS "-m64")
  48   set(TARGET_32_BIT_CFLAGS "")
  49 else()
  50   if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
  51     message(FATAL_ERROR "Please use a sane architecture with 4 or 8 byte pointers.")
  52   endif()
  53   set(TARGET_64_BIT_CFLAGS "")
  54   set(TARGET_32_BIT_CFLAGS "-m32")
  55 endif()
  56
  57 # List of architectures we can target.
  58 set(COMPILER_RT_SUPPORTED_ARCH)
  59
  60 function(get_target_flags_for_arch arch out_var)
  61   list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX)
  62   if(ARCH_INDEX EQUAL -1)
  63     message(FATAL_ERROR "Unsupported architecture: ${arch}")
  64   else()
  65     set(${out_var} ${TARGET_${arch}_CFLAGS} PARENT_SCOPE)
  66   endif()
  67 endfunction()
  68
  69 # Try to compile a very simple source file to ensure we can target the given
  70 # platform. We use the results of these tests to build only the various target
  71 # runtime libraries supported by our current compilers cross-compiling
  72 # abilities.
  73 set(SIMPLE_SOURCE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/simple.c)
  74 file(WRITE ${SIMPLE_SOURCE} "#include <stdlib.h>\nint main() {}")
  75
  76 # test_target_arch(<arch> <target flags...>)
  77 # Sets the target flags for a given architecture and determines if this
  78 # architecture is supported by trying to build a simple file.
  79 macro(test_target_arch arch)
  80   set(TARGET_${arch}_CFLAGS ${ARGN})
  81   try_compile(CAN_TARGET_${arch} ${CMAKE_BINARY_DIR} ${SIMPLE_SOURCE}
  82               COMPILE_DEFINITIONS "${TARGET_${arch}_CFLAGS}"
  83               CMAKE_FLAGS "-DCMAKE_EXE_LINKER_FLAGS:STRING=${TARGET_${arch}_CFLAGS}")
  84   if(${CAN_TARGET_${arch}})
  85     list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
  86   endif()
  87 endmacro()
  88
  89 if("${LLVM_NATIVE_ARCH}" STREQUAL "X86")
  90   test_target_arch(x86_64 ${TARGET_64_BIT_CFLAGS})
  91   test_target_arch(i386 ${TARGET_32_BIT_CFLAGS})
  92 elseif("${LLVM_NATIVE_ARCH}" STREQUAL "PowerPC")
  93   # Explicitly set -m flag on powerpc, because on ppc64 defaults for gcc and
  94   # clang are different.
  95   test_target_arch(powerpc64 "-m64")
  96   test_target_arch(powerpc "-m32")
  97 endif()
  98
  99 # We only support running instrumented tests when we're not cross compiling
 100 # and target a unix-like system. On Android we define the rules for building
 101 # unit tests, but don't execute them.
 102 if("${CMAKE_HOST_SYSTEM}" STREQUAL "${CMAKE_SYSTEM}" AND UNIX AND NOT ANDROID)
 103   option(COMPILER_RT_CAN_EXECUTE_TESTS "Can we execute instrumented tests" ON)
 104 else()
 105   option(COMPILER_RT_CAN_EXECUTE_TESTS "Can we execute instrumented tests" OFF)
 106 endif()
 107
 108 # Check if compiler-rt is built with libc++.
 109 find_flag_in_string("${CMAKE_CXX_FLAGS}" "-stdlib=libc++"
 110                     COMPILER_RT_USES_LIBCXX)
 111
 112 function(filter_available_targets out_var)
 113   set(archs)
 114   foreach(arch ${ARGN})
 115     list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX)
 116     if(NOT (ARCH_INDEX EQUAL -1) AND CAN_TARGET_${arch})
 117       list(APPEND archs ${arch})
 118     endif()
 119   endforeach()
 120   set(${out_var} ${archs} PARENT_SCOPE)
 121 endfunction()
 122
 123 # Provide some common commmandline flags for Sanitizer runtimes.
 124 set(SANITIZER_COMMON_CFLAGS
 125   -fPIC
 126   -fno-builtin
 127   -fno-exceptions
 128   -fomit-frame-pointer
 129   -funwind-tables
 130   -fno-stack-protector
 131   -Wno-gnu  # Variadic macros with 0 arguments for ...
 132   -O3
 133   )
 134 if(NOT WIN32)
 135   list(APPEND SANITIZER_COMMON_CFLAGS -fvisibility=hidden)
 136 endif()
 137 # Build sanitizer runtimes with debug info.
 138 check_cxx_compiler_flag(-gline-tables-only SUPPORTS_GLINE_TABLES_ONLY_FLAG)
 139 if(SUPPORTS_GLINE_TABLES_ONLY_FLAG)
 140   list(APPEND SANITIZER_COMMON_CFLAGS -gline-tables-only)
 141 else()
 142   list(APPEND SANITIZER_COMMON_CFLAGS -g)
 143 endif()
 144 # Warnings suppressions.
 145 check_cxx_compiler_flag(-Wno-variadic-macros SUPPORTS_NO_VARIADIC_MACROS_FLAG)
 146 if(SUPPORTS_NO_VARIADIC_MACROS_FLAG)
 147   list(APPEND SANITIZER_COMMON_CFLAGS -Wno-variadic-macros)
 148 endif()
 149 check_cxx_compiler_flag(-Wno-c99-extensions SUPPORTS_NO_C99_EXTENSIONS_FLAG)
 150 if(SUPPORTS_NO_C99_EXTENSIONS_FLAG)
 151   list(APPEND SANITIZER_COMMON_CFLAGS -Wno-c99-extensions)
 152 endif()
 153 # Sanitizer may not have libstdc++, so we can have problems with virtual
 154 # destructors.
 155 check_cxx_compiler_flag(-Wno-non-virtual-dtor SUPPORTS_NO_NON_VIRTUAL_DTOR_FLAG)
 156 if (SUPPORTS_NO_NON_VIRTUAL_DTOR_FLAG)
 157   list(APPEND SANITIZER_COMMON_CFLAGS -Wno-non-virtual-dtor)
 158 endif()
 159
 160 # Setup min Mac OS X version.
 161 if(APPLE)
 162   if(COMPILER_RT_USES_LIBCXX)
 163     set(SANITIZER_MIN_OSX_VERSION 10.7)
 164   else()
 165     set(SANITIZER_MIN_OSX_VERSION 10.5)
 166   endif()
 167   list(APPEND SANITIZER_COMMON_CFLAGS
 168     -mmacosx-version-min=${SANITIZER_MIN_OSX_VERSION})
 169 endif()
 170
 171 # Architectures supported by Sanitizer runtimes. Specific sanitizers may
 172 # support only subset of these (e.g. TSan works on x86_64 only).
 173 filter_available_targets(SANITIZER_COMMON_SUPPORTED_ARCH
 174   x86_64 i386 powerpc64)
 175
 176 # Add the public header's directory to the includes for all of compiler-rt.
 177 include_directories(include)
 178 add_subdirectory(include)
 179
 180 set(SANITIZER_COMMON_LIT_TEST_DEPS
 181   clang clang-headers FileCheck count not llvm-nm llvm-symbolizer
 182   compiler-rt-headers)
 183
 184 add_subdirectory(lib)
 185
 186 if(LLVM_INCLUDE_TESTS)
 187   # Currently the tests have not been ported to CMake, so disable this
 188   # directory.
 189   #
 190   #add_subdirectory(test)
 191 endif()