Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2024-11-25 06:40:18 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
8f540272e8
llvm-capstone/compiler-rt/CMakeLists.txt

242 lines
9.2 KiB
CMake
Raw Normal View History

Initial, very rough cut at a new CMake build system for compiler-rt. Some high-level notes: 1) An explicit goal is to support building compiler-rt as a subproject build, checked out into the projects/compiler-rt directory. There are many other possible ways of building the code here, but this is optimized for development on LLVM/Clang/compiler-rt, and incremental trial and testing of the toolchain. 2) The current support is targeted at Linux. I would love to see this generalized to other platforms, but for the sake of simplicity in testing, I'm focusing here first. Much of this patch was paired with Manuel, and I credit him with the majority of the work here. Some important caveats that I'll be working on in subsequent patches: 1) This uses the host compiler rather than using the just-built-clang. 2) Currently only x86 is supported. 3) Currently, none of the tests are built or run. 4) Uses CMake's builtin globbing which doesn't update correctly. 5) This is still turned off from LLVM's CMake build until these issues are addressed llvm-svn: 154060
2012-04-04 22:12:04 +00:00
# CMake build for CompilerRT.
#
# This build assumes that CompilerRT is checked out into the
# 'projects/compiler-rt' inside of an LLVM tree, it is not a stand-alone build
# system.
#
# An important constraint of the build is that it only produces libraries
# based on the ability of the host toolchain to target various platforms.
Another big step toward a viable CMake build system for CompilerRT, ASan, and friends. This explicitly switches the CompilerRT CMake build to require CMake version 2.8.8 or newer which provides first-class support for "object" libraries which consist of a pile of '.o' files -- exactly what is desired for composing runtime libraries. I've gone ahead and switched to using this. I've also added the interception library which I missed initially. And I've added proper dependencies between the various libraries. With this, I'm able to build archives for asan that appear to contain all of the necessary .o files. The final tweak here is to start setting up the compile flags and macro defines expected by ASan and its helper libraries. These may not be entirely correct currently, they're based loosely on my reading of the old Makefiles. However, they can be tweaked more easily now that they're wired up properly. llvm-svn: 159129
2012-06-25 08:40:10 +00:00
# The CompilerRT build system requires CMake version 2.8.8 or higher in order
# to use its support for building convenience "libraries" as a collection of
# .o files. This is particularly useful in producing larger, more complex
# runtime libraries.
Require CMake 2.8.12.1 or later on Windows That version knows to use the /FS flag, which is needed for building lib/interception with VS2013. llvm-svn: 201184
2014-02-11 21:46:19 +00:00
if (NOT MSVC)
cmake_minimum_required(VERSION 2.8.8)
else()
# Version 2.8.12.1 is required to build with Visual Studion 2013.
cmake_minimum_required(VERSION 2.8.12.1)
endif()
Add top-level CMake 'compiler-rt' target to build all compiler-rt libraries llvm-svn: 191747
2013-10-01 12:52:15 +00:00
# Top level target used to build all compiler-rt libraries.
add_custom_target(compiler-rt)
CMake: Add add_compiler_rt_static_runtime function and use it to build generic compiler-rt libraries llvm-svn: 172977
2013-01-20 13:58:10 +00:00
# Compute the Clang version from the LLVM version.
# FIXME: We should be able to reuse CLANG_VERSION variable calculated
# in Clang cmake files, instead of copying the rules here.
string(REGEX MATCH "[0-9]+\\.[0-9]+(\\.[0-9]+)?" CLANG_VERSION
${PACKAGE_VERSION})
# Setup the paths where compiler-rt runtimes and headers should be stored.
[CMake] Rename several variables llvm-svn: 201575
2014-02-18 14:28:53 +00:00
set(COMPILER_RT_INSTALL_PATH lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION})
string(TOLOWER ${CMAKE_SYSTEM_NAME} COMPILER_RT_OS_DIR)
set(COMPILER_RT_OUTPUT_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/clang/${CLANG_VERSION})
set(COMPILER_RT_LIBRARY_OUTPUT_DIR
${COMPILER_RT_OUTPUT_DIR}/lib/${COMPILER_RT_OS_DIR})
CMake: Add add_compiler_rt_static_runtime function and use it to build generic compiler-rt libraries llvm-svn: 172977
2013-01-20 13:58:10 +00:00
set(COMPILER_RT_LIBRARY_INSTALL_DIR
[CMake] Rename several variables llvm-svn: 201575
2014-02-18 14:28:53 +00:00
${COMPILER_RT_INSTALL_PATH}/lib/${COMPILER_RT_OS_DIR})
CMake: Add add_compiler_rt_static_runtime function and use it to build generic compiler-rt libraries llvm-svn: 172977
2013-01-20 13:58:10 +00:00
Significantly change the way we build ASan unittests in CMake build tree. Now just-built Clang is used to: 1) compile instrumented sources (as before); 2) compile non-instrumented sources; 3) compile our own instrumented version of googletest; 4) link it all together using -fsanitize=address flag (instead of trying to copy linker behavior in CMake build rules). This makes ASan unittests pretty much self-consistent and independent of other LLVM libraries. llvm-svn: 170541
2012-12-19 12:33:39 +00:00
# Add path for custom modules
set(CMAKE_MODULE_PATH
[CMake] Simplify code for detecting/setting compiler flags llvm-svn: 201543
2014-02-18 07:26:58 +00:00
"${CMAKE_CURRENT_SOURCE_DIR}/cmake"
Significantly change the way we build ASan unittests in CMake build tree. Now just-built Clang is used to: 1) compile instrumented sources (as before); 2) compile non-instrumented sources; 3) compile our own instrumented version of googletest; 4) link it all together using -fsanitize=address flag (instead of trying to copy linker behavior in CMake build rules). This makes ASan unittests pretty much self-consistent and independent of other LLVM libraries. llvm-svn: 170541
2012-12-19 12:33:39 +00:00
"${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules"
[CMake] Simplify code for detecting/setting compiler flags llvm-svn: 201543
2014-02-18 07:26:58 +00:00
${CMAKE_MODULE_PATH}
Significantly change the way we build ASan unittests in CMake build tree. Now just-built Clang is used to: 1) compile instrumented sources (as before); 2) compile non-instrumented sources; 3) compile our own instrumented version of googletest; 4) link it all together using -fsanitize=address flag (instead of trying to copy linker behavior in CMake build rules). This makes ASan unittests pretty much self-consistent and independent of other LLVM libraries. llvm-svn: 170541
2012-12-19 12:33:39 +00:00
)
[CMake] Simplify code for detecting/setting compiler flags llvm-svn: 201543
2014-02-18 07:26:58 +00:00
include(CompilerRTUtils)
Significantly change the way we build ASan unittests in CMake build tree. Now just-built Clang is used to: 1) compile instrumented sources (as before); 2) compile non-instrumented sources; 3) compile our own instrumented version of googletest; 4) link it all together using -fsanitize=address flag (instead of trying to copy linker behavior in CMake build rules). This makes ASan unittests pretty much self-consistent and independent of other LLVM libraries. llvm-svn: 170541
2012-12-19 12:33:39 +00:00
set(COMPILER_RT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
[ASan] lit tests: create common autogenerated config for running compiler-rt lit tests, and use it in ASan llvm-svn: 183400
2013-06-06 12:35:48 +00:00
set(COMPILER_RT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
Support CMake build of profile runtime library on Linux llvm-svn: 177382
2013-03-19 09:17:35 +00:00
# Setup custom SDK sysroots.
set(COMPILER_RT_DARWIN_SDK_SYSROOT ${COMPILER_RT_SOURCE_DIR}/SDKs/darwin)
set(COMPILER_RT_LINUX_SDK_SYSROOT ${COMPILER_RT_SOURCE_DIR}/SDKs/linux)
Significantly change the way we build ASan unittests in CMake build tree. Now just-built Clang is used to: 1) compile instrumented sources (as before); 2) compile non-instrumented sources; 3) compile our own instrumented version of googletest; 4) link it all together using -fsanitize=address flag (instead of trying to copy linker behavior in CMake build rules). This makes ASan unittests pretty much self-consistent and independent of other LLVM libraries. llvm-svn: 170541
2012-12-19 12:33:39 +00:00
Add a copy of missing <ucontext.h> for Android and enable ASan SEGV handler. This change adds a copy of <ucontext.h> for Android found in google-breakpad that is missing from the official NDK. ASan SEGV handler is still disabled by default and can be enabled with ASAN_OPTIONS=handle_segv. llvm-svn: 201084
2014-02-10 13:34:43 +00:00
set(COMPILER_RT_EXTRA_ANDROID_HEADERS ${COMPILER_RT_SOURCE_DIR}/third_party/android/include)
Initial, very rough cut at a new CMake build system for compiler-rt. Some high-level notes: 1) An explicit goal is to support building compiler-rt as a subproject build, checked out into the projects/compiler-rt directory. There are many other possible ways of building the code here, but this is optimized for development on LLVM/Clang/compiler-rt, and incremental trial and testing of the toolchain. 2) The current support is targeted at Linux. I would love to see this generalized to other platforms, but for the sake of simplicity in testing, I'm focusing here first. Much of this patch was paired with Manuel, and I credit him with the majority of the work here. Some important caveats that I'll be working on in subsequent patches: 1) This uses the host compiler rather than using the just-built-clang. 2) Currently only x86 is supported. 3) Currently, none of the tests are built or run. 4) Uses CMake's builtin globbing which doesn't update correctly. 5) This is still turned off from LLVM's CMake build until these issues are addressed llvm-svn: 154060
2012-04-04 22:12:04 +00:00
# Detect whether the current target platform is 32-bit or 64-bit, and setup
# the correct commandline flags needed to attempt to target 32-bit and 64-bit.
Always set -m32/-m64 flags for targeting i386/x86_64 respectively. Apparently, there are platforms where the clang defaults are different from gcc llvm-svn: 185287
2013-06-30 16:21:32 +00:00
if (NOT CMAKE_SIZEOF_VOID_P EQUAL 4 AND
NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
message(FATAL_ERROR "Please use architecture with 4 or 8 byte pointers.")
Initial, very rough cut at a new CMake build system for compiler-rt. Some high-level notes: 1) An explicit goal is to support building compiler-rt as a subproject build, checked out into the projects/compiler-rt directory. There are many other possible ways of building the code here, but this is optimized for development on LLVM/Clang/compiler-rt, and incremental trial and testing of the toolchain. 2) The current support is targeted at Linux. I would love to see this generalized to other platforms, but for the sake of simplicity in testing, I'm focusing here first. Much of this patch was paired with Manuel, and I credit him with the majority of the work here. Some important caveats that I'll be working on in subsequent patches: 1) This uses the host compiler rather than using the just-built-clang. 2) Currently only x86 is supported. 3) Currently, none of the tests are built or run. 4) Uses CMake's builtin globbing which doesn't update correctly. 5) This is still turned off from LLVM's CMake build until these issues are addressed llvm-svn: 154060
2012-04-04 22:12:04 +00:00
endif()
cmake: fix the compiler-rt build with MSVC This sets flags and excludes things that aren't working with MSVC yet, allowing us to build the ASan runtime as part of the cmake build. Differential Revision: http://llvm-reviews.chandlerc.com/D1525 llvm-svn: 189304
2013-08-27 01:24:01 +00:00
if (NOT MSVC)
set(TARGET_64_BIT_CFLAGS "-m64")
set(TARGET_32_BIT_CFLAGS "-m32")
else()
set(TARGET_64_BIT_CFLAGS "")
set(TARGET_32_BIT_CFLAGS "")
endif()
Initial, very rough cut at a new CMake build system for compiler-rt. Some high-level notes: 1) An explicit goal is to support building compiler-rt as a subproject build, checked out into the projects/compiler-rt directory. There are many other possible ways of building the code here, but this is optimized for development on LLVM/Clang/compiler-rt, and incremental trial and testing of the toolchain. 2) The current support is targeted at Linux. I would love to see this generalized to other platforms, but for the sake of simplicity in testing, I'm focusing here first. Much of this patch was paired with Manuel, and I credit him with the majority of the work here. Some important caveats that I'll be working on in subsequent patches: 1) This uses the host compiler rather than using the just-built-clang. 2) Currently only x86 is supported. 3) Currently, none of the tests are built or run. 4) Uses CMake's builtin globbing which doesn't update correctly. 5) This is still turned off from LLVM's CMake build until these issues are addressed llvm-svn: 154060
2012-04-04 22:12:04 +00:00
CMake: generalize checking for target availability and add initial support for PowerPC native arch. With this patch, building LLVM on PowerPC native arch produces a working ASan runtime. llvm-svn: 173044
2013-01-21 14:31:45 +00:00
# List of architectures we can target.
set(COMPILER_RT_SUPPORTED_ARCH)
CMake: start to generalize rules for non-x86 architectures llvm-svn: 172816
2013-01-18 13:10:42 +00:00
[ASan] Support building both 32- and 64-bit unit tests if we can target both architectures llvm-svn: 170549
2012-12-19 15:17:23 +00:00
function(get_target_flags_for_arch arch out_var)
CMake: start to generalize rules for non-x86 architectures llvm-svn: 172816
2013-01-18 13:10:42 +00:00
list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX)
if(ARCH_INDEX EQUAL -1)
[ASan] Support building both 32- and 64-bit unit tests if we can target both architectures llvm-svn: 170549
2012-12-19 15:17:23 +00:00
message(FATAL_ERROR "Unsupported architecture: ${arch}")
CMake: start to generalize rules for non-x86 architectures llvm-svn: 172816
2013-01-18 13:10:42 +00:00
else()
set(${out_var} ${TARGET_${arch}_CFLAGS} PARENT_SCOPE)
[ASan] Support building both 32- and 64-bit unit tests if we can target both architectures llvm-svn: 170549
2012-12-19 15:17:23 +00:00
endif()
endfunction()
Initial, very rough cut at a new CMake build system for compiler-rt. Some high-level notes: 1) An explicit goal is to support building compiler-rt as a subproject build, checked out into the projects/compiler-rt directory. There are many other possible ways of building the code here, but this is optimized for development on LLVM/Clang/compiler-rt, and incremental trial and testing of the toolchain. 2) The current support is targeted at Linux. I would love to see this generalized to other platforms, but for the sake of simplicity in testing, I'm focusing here first. Much of this patch was paired with Manuel, and I credit him with the majority of the work here. Some important caveats that I'll be working on in subsequent patches: 1) This uses the host compiler rather than using the just-built-clang. 2) Currently only x86 is supported. 3) Currently, none of the tests are built or run. 4) Uses CMake's builtin globbing which doesn't update correctly. 5) This is still turned off from LLVM's CMake build until these issues are addressed llvm-svn: 154060
2012-04-04 22:12:04 +00:00
# Try to compile a very simple source file to ensure we can target the given
# platform. We use the results of these tests to build only the various target
# runtime libraries supported by our current compilers cross-compiling
# abilities.
CMake: generalize checking for target availability and add initial support for PowerPC native arch. With this patch, building LLVM on PowerPC native arch produces a working ASan runtime. llvm-svn: 173044
2013-01-21 14:31:45 +00:00
set(SIMPLE_SOURCE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/simple.c)
file(WRITE ${SIMPLE_SOURCE} "#include <stdlib.h>\nint main() {}")
# test_target_arch(<arch> <target flags...>)
# Sets the target flags for a given architecture and determines if this
# architecture is supported by trying to build a simple file.
macro(test_target_arch arch)
set(TARGET_${arch}_CFLAGS ${ARGN})
try_compile(CAN_TARGET_${arch} ${CMAKE_BINARY_DIR} ${SIMPLE_SOURCE}
COMPILE_DEFINITIONS "${TARGET_${arch}_CFLAGS}"
CMAKE_FLAGS "-DCMAKE_EXE_LINKER_FLAGS:STRING=${TARGET_${arch}_CFLAGS}")
if(${CAN_TARGET_${arch}})
list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
endif()
endmacro()
[asan] Android test runner for ASan lit tests. This change replaces 32- and 64- bit config.in-s with a single config template that is used to generate both 32 and 64 bits configs as well as the new arm-android config. Arm-android config is special because it can run tests on a remote device over adb (android debug bridge). We replace %clang with a script that run the compiler, upload the result to the device, and replaces it with another script. The second script runs the binary on the device and delivers stdout/stderr/exitcode back. llvm-svn: 201394
2014-02-14 09:22:10 +00:00
if(ANDROID_COMMON_FLAGS)
test_target_arch(arm_android "${ANDROID_COMMON_FLAGS}")
else()
if("${LLVM_NATIVE_ARCH}" STREQUAL "X86")
if (NOT MSVC)
test_target_arch(x86_64 ${TARGET_64_BIT_CFLAGS})
endif()
test_target_arch(i386 ${TARGET_32_BIT_CFLAGS})
elseif("${LLVM_NATIVE_ARCH}" STREQUAL "PowerPC")
test_target_arch(powerpc64 ${TARGET_64_BIT_CFLAGS})
elseif("${LLVM_NATIVE_ARCH}" STREQUAL "ARM")
test_target_arch(arm "")
cmake: fix the compiler-rt build with MSVC This sets flags and excludes things that aren't working with MSVC yet, allowing us to build the ASan runtime as part of the cmake build. Differential Revision: http://llvm-reviews.chandlerc.com/D1525 llvm-svn: 189304
2013-08-27 01:24:01 +00:00
endif()
CMake: generalize checking for target availability and add initial support for PowerPC native arch. With this patch, building LLVM on PowerPC native arch produces a working ASan runtime. llvm-svn: 173044
2013-01-21 14:31:45 +00:00
endif()
Initial, very rough cut at a new CMake build system for compiler-rt. Some high-level notes: 1) An explicit goal is to support building compiler-rt as a subproject build, checked out into the projects/compiler-rt directory. There are many other possible ways of building the code here, but this is optimized for development on LLVM/Clang/compiler-rt, and incremental trial and testing of the toolchain. 2) The current support is targeted at Linux. I would love to see this generalized to other platforms, but for the sake of simplicity in testing, I'm focusing here first. Much of this patch was paired with Manuel, and I credit him with the majority of the work here. Some important caveats that I'll be working on in subsequent patches: 1) This uses the host compiler rather than using the just-built-clang. 2) Currently only x86 is supported. 3) Currently, none of the tests are built or run. 4) Uses CMake's builtin globbing which doesn't update correctly. 5) This is still turned off from LLVM's CMake build until these issues are addressed llvm-svn: 154060
2012-04-04 22:12:04 +00:00
Define COMPILER_RT_CAN_EXECUTE_TESTS variable on platforms where we can produce working binaries and use it in build rules for sanitizers tests llvm-svn: 171160
2012-12-27 13:19:23 +00:00
# We only support running instrumented tests when we're not cross compiling
[asan] Android test runner for ASan lit tests. This change replaces 32- and 64- bit config.in-s with a single config template that is used to generate both 32 and 64 bits configs as well as the new arm-android config. Arm-android config is special because it can run tests on a remote device over adb (android debug bridge). We replace %clang with a script that run the compiler, upload the result to the device, and replaces it with another script. The second script runs the binary on the device and delivers stdout/stderr/exitcode back. llvm-svn: 201394
2014-02-14 09:22:10 +00:00
# and target a unix-like system. We can run tests on Android even when we are
# cross-compiling.
if(("${CMAKE_HOST_SYSTEM}" STREQUAL "${CMAKE_SYSTEM}" AND UNIX) OR ANDROID)
Change the cmake variable COMPILER_RT_CAN_EXECUTE_TESTS to be an option so that it can overwritten. The reason why this simple change is needed is that I am trying to set up a quick cmake/ninja based buildbot and apple-clang does not support using the sanitizers currently. The default behavior follows exactly what was there before implying that no ones builds should be affected at all. llvm-svn: 178455
2013-04-01 04:13:03 +00:00
option(COMPILER_RT_CAN_EXECUTE_TESTS "Can we execute instrumented tests" ON)
Define COMPILER_RT_CAN_EXECUTE_TESTS variable on platforms where we can produce working binaries and use it in build rules for sanitizers tests llvm-svn: 171160
2012-12-27 13:19:23 +00:00
else()
Change the cmake variable COMPILER_RT_CAN_EXECUTE_TESTS to be an option so that it can overwritten. The reason why this simple change is needed is that I am trying to set up a quick cmake/ninja based buildbot and apple-clang does not support using the sanitizers currently. The default behavior follows exactly what was there before implying that no ones builds should be affected at all. llvm-svn: 178455
2013-04-01 04:13:03 +00:00
option(COMPILER_RT_CAN_EXECUTE_TESTS "Can we execute instrumented tests" OFF)
Define COMPILER_RT_CAN_EXECUTE_TESTS variable on platforms where we can produce working binaries and use it in build rules for sanitizers tests llvm-svn: 171160
2012-12-27 13:19:23 +00:00
endif()
Change the cmake variable COMPILER_RT_CAN_EXECUTE_TESTS to be an option so that it can overwritten. The reason why this simple change is needed is that I am trying to set up a quick cmake/ninja based buildbot and apple-clang does not support using the sanitizers currently. The default behavior follows exactly what was there before implying that no ones builds should be affected at all. llvm-svn: 178455
2013-04-01 04:13:03 +00:00
[CMake] set -mmacosx-version-min to 10.7 if compiler-rt is built with -stdlib=libc++ llvm-svn: 174699
2013-02-08 07:39:25 +00:00
# Check if compiler-rt is built with libc++.
find_flag_in_string("${CMAKE_CXX_FLAGS}" "-stdlib=libc++"
COMPILER_RT_USES_LIBCXX)
[ASan] CMake support for building ASan runtime as a universal binary on Mac llvm-svn: 161665
2012-08-10 14:45:52 +00:00
function(filter_available_targets out_var)
set(archs)
foreach(arch ${ARGN})
CMake: start to generalize rules for non-x86 architectures llvm-svn: 172816
2013-01-18 13:10:42 +00:00
list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX)
if(NOT (ARCH_INDEX EQUAL -1) AND CAN_TARGET_${arch})
[ASan] CMake support for building ASan runtime as a universal binary on Mac llvm-svn: 161665
2012-08-10 14:45:52 +00:00
list(APPEND archs ${arch})
endif()
endforeach()
set(${out_var} ${archs} PARENT_SCOPE)
endfunction()
Add a CMake option COMPILER_RT_DEBUG for building runtimes with full debug info. Differential Revision: http://llvm-reviews.chandlerc.com/D1984 llvm-svn: 193449
2013-10-25 23:03:34 +00:00
option(COMPILER_RT_DEBUG "Build runtimes with full debug info" OFF)
# COMPILER_RT_DEBUG_PYBOOL is used by lit.common.configured.in.
pythonize_bool(COMPILER_RT_DEBUG)
[CMake] Simplify code for detecting/setting compiler flags llvm-svn: 201543
2014-02-18 07:26:58 +00:00
#================================
# Setup Compiler Flags
#================================
include(config-ix)
# Provide some common commmandline flags for Sanitizer runtimes.
append_if(SANITIZER_COMMON_CFLAGS COMPILER_RT_HAS_FPIC_FLAG -fPIC)
append_if(SANITIZER_COMMON_CFLAGS COMPILER_RT_HAS_FNO_BUILTIN_FLAG -fno-builtin)
append_if(SANITIZER_COMMON_CFLAGS COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG -fno-exceptions)
append_if(SANITIZER_COMMON_CFLAGS COMPILER_RT_HAS_FOMIT_FRAME_POINTER_FLAG -fomit-frame-pointer)
append_if(SANITIZER_COMMON_CFLAGS COMPILER_RT_HAS_FUNWIND_TABLES_FLAG -funwind-tables)
append_if(SANITIZER_COMMON_CFLAGS COMPILER_RT_HAS_FNO_STACK_PROTECTOR_FLAG -fno-stack-protector)
append_if(SANITIZER_COMMON_CFLAGS COMPILER_RT_HAS_FVISIBILITY_HIDDEN_FLAG -fvisibility=hidden)
append_if(SANITIZER_COMMON_CFLAGS COMPILER_RT_HAS_FNO_FUNCTION_SECTIONS_FLAG -fno-function-sections)
append_if(SANITIZER_COMMON_CFLAGS COMPILER_RT_HAS_MT_FLAG /MT)
append_if(SANITIZER_COMMON_CFLAGS COMPILER_RT_HAS_Oy_FLAG /Oy-)
append_if(SANITIZER_COMMON_CFLAGS COMPILER_RT_HAS_GS_FLAG /GS-)
# Build with optimization, unless we're in debug mode.
if(NOT COMPILER_RT_DEBUG)
if(MSVC)
list(APPEND SANITIZER_COMMON_CFLAGS /O2)
cmake: fix the compiler-rt build with MSVC This sets flags and excludes things that aren't working with MSVC yet, allowing us to build the ASan runtime as part of the cmake build. Differential Revision: http://llvm-reviews.chandlerc.com/D1525 llvm-svn: 189304
2013-08-27 01:24:01 +00:00
else()
[CMake] Simplify code for detecting/setting compiler flags llvm-svn: 201543
2014-02-18 07:26:58 +00:00
list(APPEND SANITIZER_COMMON_CFLAGS -O3)
cmake: fix the compiler-rt build with MSVC This sets flags and excludes things that aren't working with MSVC yet, allowing us to build the ASan runtime as part of the cmake build. Differential Revision: http://llvm-reviews.chandlerc.com/D1525 llvm-svn: 189304
2013-08-27 01:24:01 +00:00
endif()
[Sanitizer] Build all sanitizer runtime libraries with debug info (with -gline-tables-only, if it's available) llvm-svn: 167584
2012-11-08 14:49:28 +00:00
endif()
[CMake] Simplify code for detecting/setting compiler flags llvm-svn: 201543
2014-02-18 07:26:58 +00:00
# Build sanitizer runtimes with debug info.
if(COMPILER_RT_HAS_GLINE_TABLES_ONLY_FLAG)
list(APPEND SANITIZER_COMMON_CFLAGS -gline-tables-only)
elseif(COMPILER_RT_HAS_G_FLAG)
list(APPEND SANITIZER_COMMON_CFLAGS -g)
elseif(COMPILER_RT_HAS_Zi_FLAG)
list(APPEND SANITIZER_COMMON_CFLAGS /Zi)
[Sanitizer] Compile sanitizer runtimes with -Wno-non-virtual-dtor. Virtual dtors may be a problem for us, as sanitizer runtime should not generally assume libstdc++ presence. llvm-svn: 177860
2013-03-25 10:31:49 +00:00
endif()
[CMake] Simplify code for detecting/setting compiler flags llvm-svn: 201543
2014-02-18 07:26:58 +00:00
# Turn off several warnings.
append_if(SANITIZER_COMMON_CFLAGS COMPILER_RT_HAS_WNO_GNU_FLAG -Wno-gnu)
append_if(SANITIZER_COMMON_CFLAGS COMPILER_RT_HAS_WNO_VARIADIC_MACROS_FLAG -Wno-variadic-macros)
append_if(SANITIZER_COMMON_CFLAGS COMPILER_RT_HAS_WNO_C99_EXTENSIONS_FLAG -Wno-c99-extensions)
append_if(SANITIZER_COMMON_CFLAGS COMPILER_RT_HAS_WNO_NON_VIRTUAL_DTOR_FLAG -Wno-non-virtual-dtor)
append_if(SANITIZER_COMMON_CFLAGS COMPILER_RT_HAS_WD4722_FLAG /wd4722)
[CMake] set -mmacosx-version-min to 10.7 if compiler-rt is built with -stdlib=libc++ llvm-svn: 174699
2013-02-08 07:39:25 +00:00
[ASan] hoist more compile flags to SANITIZER_COMMON_CFLAGS var and add the rest of flags/defs from old Makefile to CMake llvm-svn: 163204
2012-09-05 09:00:03 +00:00
if(APPLE)
[ASan] Add CMake configs for libclang_rt.asan_iossim_dynamic.dylib CMake changes to build the ASan runtime for the iOS simulator. This is a universal library targeting the same architectures as the OSX ASan runtime does, thus the iossim version can't live in the same universal libclang_rt.asan_osx_dynamic.dylib The difference between the OSX and iossim builds is in the -mios-simulator-version-min and -ios_simulator_version_min flags that tell Clang to compile and link iossim code. The iossim runtime can only be built on a machine with both Xcode and the iOS Simulator SDK installed. If xcodebuild -version -sdk iphonesimulator Path returns a nonempty path, it is used when compiling and linking the iossim runtime. llvm-svn: 194199
2013-11-07 10:08:19 +00:00
# Obtain the iOS Simulator SDK path from xcodebuild.
execute_process(
COMMAND xcodebuild -version -sdk iphonesimulator Path
OUTPUT_VARIABLE IOSSIM_SDK_DIR
OUTPUT_STRIP_TRAILING_WHITESPACE
)
[CMake] Don't build ASan for iossim if -mmacosx-version-min is specified llvm-svn: 201566
2014-02-18 12:01:24 +00:00
string(REGEX MATCH "-mmacosx-version-min="
MACOSX_VERSION_MIN_FLAG "${CMAKE_CXX_FLAGS}")
[ASan] Add CMake configs for libclang_rt.asan_iossim_dynamic.dylib CMake changes to build the ASan runtime for the iOS simulator. This is a universal library targeting the same architectures as the OSX ASan runtime does, thus the iossim version can't live in the same universal libclang_rt.asan_osx_dynamic.dylib The difference between the OSX and iossim builds is in the -mios-simulator-version-min and -ios_simulator_version_min flags that tell Clang to compile and link iossim code. The iossim runtime can only be built on a machine with both Xcode and the iOS Simulator SDK installed. If xcodebuild -version -sdk iphonesimulator Path returns a nonempty path, it is used when compiling and linking the iossim runtime. llvm-svn: 194199
2013-11-07 10:08:19 +00:00
set(SANITIZER_COMMON_SUPPORTED_DARWIN_OS osx)
[CMake] Don't build ASan for iossim if -mmacosx-version-min is specified llvm-svn: 201566
2014-02-18 12:01:24 +00:00
if (IOSSIM_SDK_DIR AND NOT MACOSX_VERSION_MIN_FLAG)
[ASan] Add CMake configs for libclang_rt.asan_iossim_dynamic.dylib CMake changes to build the ASan runtime for the iOS simulator. This is a universal library targeting the same architectures as the OSX ASan runtime does, thus the iossim version can't live in the same universal libclang_rt.asan_osx_dynamic.dylib The difference between the OSX and iossim builds is in the -mios-simulator-version-min and -ios_simulator_version_min flags that tell Clang to compile and link iossim code. The iossim runtime can only be built on a machine with both Xcode and the iOS Simulator SDK installed. If xcodebuild -version -sdk iphonesimulator Path returns a nonempty path, it is used when compiling and linking the iossim runtime. llvm-svn: 194199
2013-11-07 10:08:19 +00:00
list(APPEND SANITIZER_COMMON_SUPPORTED_DARWIN_OS iossim)
endif()
[CMake] set -mmacosx-version-min to 10.7 if compiler-rt is built with -stdlib=libc++ llvm-svn: 174699
2013-02-08 07:39:25 +00:00
if(COMPILER_RT_USES_LIBCXX)
set(SANITIZER_MIN_OSX_VERSION 10.7)
else()
[ASan] Bump min supported Mac OS X version to 10.6 llvm-svn: 186404
2013-07-16 11:54:40 +00:00
set(SANITIZER_MIN_OSX_VERSION 10.6)
[CMake] set -mmacosx-version-min to 10.7 if compiler-rt is built with -stdlib=libc++ llvm-svn: 174699
2013-02-08 07:39:25 +00:00
endif()
[ASan] Add CMake configs for libclang_rt.asan_iossim_dynamic.dylib CMake changes to build the ASan runtime for the iOS simulator. This is a universal library targeting the same architectures as the OSX ASan runtime does, thus the iossim version can't live in the same universal libclang_rt.asan_osx_dynamic.dylib The difference between the OSX and iossim builds is in the -mios-simulator-version-min and -ios_simulator_version_min flags that tell Clang to compile and link iossim code. The iossim runtime can only be built on a machine with both Xcode and the iOS Simulator SDK installed. If xcodebuild -version -sdk iphonesimulator Path returns a nonempty path, it is used when compiling and linking the iossim runtime. llvm-svn: 194199
2013-11-07 10:08:19 +00:00
set(DARWIN_osx_CFLAGS -mmacosx-version-min=${SANITIZER_MIN_OSX_VERSION})
set(DARWIN_iossim_CFLAGS
-mios-simulator-version-min=7.0 -isysroot ${IOSSIM_SDK_DIR})
set(DARWIN_osx_LINKFLAGS)
set(DARWIN_iossim_LINKFLAGS
-Wl,-ios_simulator_version_min,7.0.0
-mios-simulator-version-min=7.0
[ASan] Use -isysroot instead of -Wl,-syslibroot to link the ASan iossim runtime (-Wl,-syslibroot was accidentally overridden by -isysroot from Clang on OSX 10.9) -isysroot is a Clang/LLVM-GCC-specific option, but hosting libsanitizer for LLVM with GCC on Darwin shouldn't work anyway, because of the missing blocks support. llvm-svn: 195132
2013-11-19 14:58:42 +00:00
-isysroot ${IOSSIM_SDK_DIR})
[ASan] hoist more compile flags to SANITIZER_COMMON_CFLAGS var and add the rest of flags/defs from old Makefile to CMake llvm-svn: 163204
2012-09-05 09:00:03 +00:00
endif()
Some flag cleanup for the sanitizer runtimes. This hoists most of the CFLAGS into a common variable. It also adds detection for -Wno-c99-extensions and uses it to silence a pile of warnings. Finally, it switches to the proper flag -rdynamic. With this, the cmake build is warning free on my bootstrap Linux build. llvm-svn: 162809
2012-08-29 00:13:11 +00:00
CMake: Generalize build rules for different arches for sanitizer_common, asan, ubsan llvm-svn: 172829
2013-01-18 16:51:07 +00:00
# Architectures supported by Sanitizer runtimes. Specific sanitizers may
# support only subset of these (e.g. TSan works on x86_64 only).
filter_available_targets(SANITIZER_COMMON_SUPPORTED_ARCH
Enable compilation of RT on ARM Adding the ARM RT sources to the CMake files, and enabling some sanitizers to also build on ARM. This is far from supported or production quality, but enabling it to build will get us errors that we can actually fix. Having said that, the Compiler-RT and the Asan libraries are know to work on some variations of ARM. llvm-svn: 200546
2014-01-31 14:25:58 +00:00
x86_64 i386 powerpc64 arm)
Move ASan lit-tests under test/asan llvm-svn: 201413
2014-02-14 14:06:10 +00:00
filter_available_targets(ASAN_SUPPORTED_ARCH x86_64 i386 powerpc64)
Move DFSan test suite under test/ llvm-svn: 201403
2014-02-14 12:05:41 +00:00
filter_available_targets(DFSAN_SUPPORTED_ARCH x86_64)
Move LSan test suite under test/ llvm-svn: 201408
2014-02-14 12:26:05 +00:00
filter_available_targets(LSAN_SUPPORTED_ARCH x86_64)
Move MSan lit-tests under test/msan llvm-svn: 201412
2014-02-14 13:02:58 +00:00
filter_available_targets(MSAN_SUPPORTED_ARCH x86_64)
Move TSan lit-tests under test/tsan llvm-svn: 201414
2014-02-14 14:35:48 +00:00
filter_available_targets(TSAN_SUPPORTED_ARCH x86_64)
Move DFSan test suite under test/ llvm-svn: 201403
2014-02-14 12:05:41 +00:00
filter_available_targets(UBSAN_SUPPORTED_ARCH x86_64 i386)
CMake: Generalize build rules for different arches for sanitizer_common, asan, ubsan llvm-svn: 172829
2013-01-18 16:51:07 +00:00
Explicitly list all sanitizer headers in CMake build rules. Make sure sanitizer lit_tests depend on fresh headers. llvm-svn: 179293
2013-04-11 15:49:52 +00:00
add_subdirectory(include)
Move MSan lit-tests under test/msan llvm-svn: 201412
2014-02-14 13:02:58 +00:00
set(COMPILER_RT_LIBCXX_PATH ${LLVM_MAIN_SRC_DIR}/projects/libcxx)
if(EXISTS ${COMPILER_RT_LIBCXX_PATH}/)
set(COMPILER_RT_HAS_LIBCXX_SOURCES TRUE)
else()
set(COMPILER_RT_HAS_LIBCXX_SOURCES FALSE)
endif()
Initial, very rough cut at a new CMake build system for compiler-rt. Some high-level notes: 1) An explicit goal is to support building compiler-rt as a subproject build, checked out into the projects/compiler-rt directory. There are many other possible ways of building the code here, but this is optimized for development on LLVM/Clang/compiler-rt, and incremental trial and testing of the toolchain. 2) The current support is targeted at Linux. I would love to see this generalized to other platforms, but for the sake of simplicity in testing, I'm focusing here first. Much of this patch was paired with Manuel, and I credit him with the majority of the work here. Some important caveats that I'll be working on in subsequent patches: 1) This uses the host compiler rather than using the just-built-clang. 2) Currently only x86 is supported. 3) Currently, none of the tests are built or run. 4) Uses CMake's builtin globbing which doesn't update correctly. 5) This is still turned off from LLVM's CMake build until these issues are addressed llvm-svn: 154060
2012-04-04 22:12:04 +00:00
add_subdirectory(lib)
if(LLVM_INCLUDE_TESTS)
Move shared configs for lit test suites to test/ and unittests/ directories llvm-svn: 201399
2014-02-14 11:00:07 +00:00
add_subdirectory(unittests)
Initial, very rough cut at a new CMake build system for compiler-rt. Some high-level notes: 1) An explicit goal is to support building compiler-rt as a subproject build, checked out into the projects/compiler-rt directory. There are many other possible ways of building the code here, but this is optimized for development on LLVM/Clang/compiler-rt, and incremental trial and testing of the toolchain. 2) The current support is targeted at Linux. I would love to see this generalized to other platforms, but for the sake of simplicity in testing, I'm focusing here first. Much of this patch was paired with Manuel, and I credit him with the majority of the work here. Some important caveats that I'll be working on in subsequent patches: 1) This uses the host compiler rather than using the just-built-clang. 2) Currently only x86 is supported. 3) Currently, none of the tests are built or run. 4) Uses CMake's builtin globbing which doesn't update correctly. 5) This is still turned off from LLVM's CMake build until these issues are addressed llvm-svn: 154060
2012-04-04 22:12:04 +00:00
endif()
Move ASan lit-tests under test/asan llvm-svn: 201413
2014-02-14 14:06:10 +00:00
add_subdirectory(test)
Reference in New Issue Copy Permalink