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