Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / compiler-rt / 799172d60d32feb1acba1a6867f3a9c39a999e5c / . / cmake / Modules / CompilerRTDarwinUtils.cmake
blob: 511361b49a7a903131da6c75f9e3b4bacb9560fd [file] [log] [blame]
Pirama Arumuga Nainar799172d2016-03-03 15:50:30 -0800[diff] [blame^]1# On OS X SDKs can be installed anywhere on the base system and xcode-select can
2# set the default Xcode to use. This function finds the SDKs that are present in
3# the current Xcode.
4function(find_darwin_sdk_dir var sdk_name)
5 # Let's first try the internal SDK, otherwise use the public SDK.
6 execute_process(
7 COMMAND xcodebuild -version -sdk ${sdk_name}.internal Path
8 OUTPUT_VARIABLE var_internal
9 OUTPUT_STRIP_TRAILING_WHITESPACE
10 ERROR_FILE /dev/null
11 )
12 if("" STREQUAL "${var_internal}")
13 execute_process(
14 COMMAND xcodebuild -version -sdk ${sdk_name} Path
15 OUTPUT_VARIABLE var_internal
16 OUTPUT_STRIP_TRAILING_WHITESPACE
17 ERROR_FILE /dev/null
18 )
19 endif()
20 set(${var} ${var_internal} PARENT_SCOPE)
21endfunction()
22
23# There isn't a clear mapping of what architectures are supported with a given
24# target platform, but ld's version output does list the architectures it can
25# link for.
26function(darwin_get_toolchain_supported_archs output_var)
27 execute_process(
28 COMMAND ld -v
29 ERROR_VARIABLE LINKER_VERSION)
30
31 string(REGEX MATCH "configured to support archs: ([^\n]+)"
32 ARCHES_MATCHED "${LINKER_VERSION}")
33 if(ARCHES_MATCHED)
34 set(ARCHES "${CMAKE_MATCH_1}")
35 message(STATUS "Got ld supported ARCHES: ${ARCHES}")
36 string(REPLACE " " ";" ARCHES ${ARCHES})
37 else()
38 # If auto-detecting fails, fall back to a default set
39 message(WARNING "Detecting supported architectures from 'ld -v' failed. Returning default set.")
40 set(ARCHES "i386;x86_64;armv7;armv7s;arm64")
41 endif()
42
43 set(${output_var} ${ARCHES} PARENT_SCOPE)
44endfunction()
45
46# This function takes an OS and a list of architectures and identifies the
47# subset of the architectures list that the installed toolchain can target.
48function(darwin_test_archs os valid_archs)
49 if(${valid_archs})
50 message(STATUS "Using cached valid architectures for ${os}.")
51 return()
52 endif()
53
54 set(archs ${ARGN})
55 message(STATUS "Finding valid architectures for ${os}...")
56 set(SIMPLE_CPP ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/src.cpp)
57 file(WRITE ${SIMPLE_CPP} "#include <iostream>\nint main() { std::cout << std::endl; return 0; }\n")
58
59 set(os_linker_flags)
60 foreach(flag ${DARWIN_${os}_LINKFLAGS})
61 set(os_linker_flags "${os_linker_flags} ${flag}")
62 endforeach()
63
64 # The simple program will build for x86_64h on the simulator because it is
65 # compatible with x86_64 libraries (mostly), but since x86_64h isn't actually
66 # a valid or useful architecture for the iOS simulator we should drop it.
67 if(${os} STREQUAL "iossim")
68 list(REMOVE_ITEM archs "x86_64h")
69 endif()
70
71 set(working_archs)
72 foreach(arch ${archs})
73
74 set(arch_linker_flags "-arch ${arch} ${os_linker_flags}")
75 try_compile(CAN_TARGET_${os}_${arch} ${CMAKE_BINARY_DIR} ${SIMPLE_CPP}
76 COMPILE_DEFINITIONS "-v -arch ${arch}" ${DARWIN_${os}_CFLAGS}
77 CMAKE_FLAGS "-DCMAKE_EXE_LINKER_FLAGS=${arch_linker_flags}"
78 OUTPUT_VARIABLE TEST_OUTPUT)
79 if(${CAN_TARGET_${os}_${arch}})
80 list(APPEND working_archs ${arch})
81 else()
82 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
83 "Testing compiler for supporting ${os}-${arch}:\n"
84 "${TEST_OUTPUT}\n")
85 endif()
86 endforeach()
87 set(${valid_archs} ${working_archs}
88 CACHE STRING "List of valid architectures for platform ${os}.")
89endfunction()
90
91# This function checks the host cpusubtype to see if it is post-haswell. Haswell
92# and later machines can run x86_64h binaries. Haswell is cpusubtype 8.
93function(darwin_filter_host_archs input output)
94 list_union(tmp_var DARWIN_osx_ARCHS ${input})
95 execute_process(
96 COMMAND sysctl hw.cpusubtype
97 OUTPUT_VARIABLE SUBTYPE)
98
99 string(REGEX MATCH "hw.cpusubtype: ([0-9]*)"
100 SUBTYPE_MATCHED "${SUBTYPE}")
101 set(HASWELL_SUPPORTED Off)
102 if(SUBTYPE_MATCHED)
103 if(${CMAKE_MATCH_1} GREATER 7)
104 set(HASWELL_SUPPORTED On)
105 endif()
106 endif()
107 if(NOT HASWELL_SUPPORTED)
108 list(REMOVE_ITEM tmp_var x86_64h)
109 endif()
110 set(${output} ${tmp_var} PARENT_SCOPE)
111endfunction()
112
113# Read and process the exclude file into a list of symbols
114function(darwin_read_list_from_file output_var file)
115 if(EXISTS ${file})
116 file(READ ${file} EXCLUDES)
117 string(REPLACE "\n" ";" EXCLUDES ${EXCLUDES})
118 set(${output_var} ${EXCLUDES} PARENT_SCOPE)
119 endif()
120endfunction()
121
122# this function takes an OS, architecture and minimum version and provides a
123# list of builtin functions to exclude
124function(darwin_find_excluded_builtins_list output_var)
125 cmake_parse_arguments(LIB
126 ""
127 "OS;ARCH;MIN_VERSION"
128 ""
129 ${ARGN})
130
131 if(NOT LIB_OS OR NOT LIB_ARCH)
132 message(FATAL_ERROR "Must specify OS and ARCH to darwin_find_excluded_builtins_list!")
133 endif()
134
135 darwin_read_list_from_file(${LIB_OS}_BUILTINS
136 ${DARWIN_EXCLUDE_DIR}/${LIB_OS}.txt)
137 darwin_read_list_from_file(${LIB_OS}_${LIB_ARCH}_BASE_BUILTINS
138 ${DARWIN_EXCLUDE_DIR}/${LIB_OS}-${LIB_ARCH}.txt)
139
140 if(LIB_MIN_VERSION)
141 file(GLOB builtin_lists ${DARWIN_EXCLUDE_DIR}/${LIB_OS}*-${LIB_ARCH}.txt)
142 foreach(builtin_list ${builtin_lists})
143 string(REGEX MATCH "${LIB_OS}([0-9\\.]*)-${LIB_ARCH}.txt" VERSION_MATCHED "${builtin_list}")
144 if (VERSION_MATCHED AND NOT CMAKE_MATCH_1 VERSION_LESS LIB_MIN_VERSION)
145 if(NOT smallest_version)
146 set(smallest_version ${CMAKE_MATCH_1})
147 elseif(CMAKE_MATCH_1 VERSION_LESS smallest_version)
148 set(smallest_version ${CMAKE_MATCH_1})
149 endif()
150 endif()
151 endforeach()
152
153 if(smallest_version)
154 darwin_read_list_from_file(${LIB_ARCH}_${LIB_OS}_BUILTINS
155 ${DARWIN_EXCLUDE_DIR}/${LIB_OS}${smallest_version}-${LIB_ARCH}.txt)
156 endif()
157 endif()
158
159 set(${output_var}
160 ${${LIB_ARCH}_${LIB_OS}_BUILTINS}
161 ${${LIB_OS}_${LIB_ARCH}_BASE_BUILTINS}
162 ${${LIB_OS}_BUILTINS} PARENT_SCOPE)
163endfunction()
164
165# adds a single builtin library for a single OS & ARCH
166macro(darwin_add_builtin_library name suffix)
167 cmake_parse_arguments(LIB
168 ""
169 "PARENT_TARGET;OS;ARCH"
170 "SOURCES;CFLAGS;DEFS"
171 ${ARGN})
172 set(libname "${name}.${suffix}_${LIB_ARCH}_${LIB_OS}")
173 add_library(${libname} STATIC ${LIB_SOURCES})
174 if(DARWIN_${LIB_OS}_SYSROOT)
175 set(sysroot_flag -isysroot ${DARWIN_${LIB_OS}_SYSROOT})
176 endif()
177 set_target_compile_flags(${libname}
178 ${sysroot_flag}
179 ${DARWIN_${LIB_OS}_BUILTIN_MIN_VER_FLAG}
180 ${LIB_CFLAGS})
181 set_property(TARGET ${libname} APPEND PROPERTY
182 COMPILE_DEFINITIONS ${LIB_DEFS})
183 set_target_properties(${libname} PROPERTIES
184 OUTPUT_NAME ${libname}${COMPILER_RT_OS_SUFFIX})
185 set_target_properties(${libname} PROPERTIES
186 OSX_ARCHITECTURES ${LIB_ARCH})
187
188 if(LIB_PARENT_TARGET)
189 add_dependencies(${LIB_PARENT_TARGET} ${libname})
190 endif()
191
192 list(APPEND ${LIB_OS}_${suffix}_libs ${libname})
193 list(APPEND ${LIB_OS}_${suffix}_lipo_flags -arch ${arch} $<TARGET_FILE:${libname}>)
194endmacro()
195
196function(darwin_lipo_libs name)
197 cmake_parse_arguments(LIB
198 ""
199 "PARENT_TARGET;OUTPUT_DIR;INSTALL_DIR"
200 "LIPO_FLAGS;DEPENDS"
201 ${ARGN})
202 if(LIB_DEPENDS AND LIB_LIPO_FLAGS)
203 add_custom_command(OUTPUT ${LIB_OUTPUT_DIR}/lib${name}.a
204 COMMAND ${CMAKE_COMMAND} -E make_directory ${LIB_OUTPUT_DIR}
205 COMMAND lipo -output
206 ${LIB_OUTPUT_DIR}/lib${name}.a
207 -create ${LIB_LIPO_FLAGS}
208 DEPENDS ${LIB_DEPENDS}
209 )
210 add_custom_target(${name}
211 DEPENDS ${LIB_OUTPUT_DIR}/lib${name}.a)
212 add_dependencies(${LIB_PARENT_TARGET} ${name})
213 install(FILES ${LIB_OUTPUT_DIR}/lib${name}.a
214 DESTINATION ${LIB_INSTALL_DIR})
215 else()
216 message(WARNING "Not generating lipo target for ${name} because no input libraries exist.")
217 endif()
218endfunction()
219
220# Filter out generic versions of routines that are re-implemented in
221# architecture specific manner. This prevents multiple definitions of the
222# same symbols, making the symbol selection non-deterministic.
223function(darwin_filter_builtin_sources output_var exclude_or_include excluded_list)
224 if(exclude_or_include STREQUAL "EXCLUDE")
225 set(filter_action GREATER)
226 set(filter_value -1)
227 elseif(exclude_or_include STREQUAL "INCLUDE")
228 set(filter_action LESS)
229 set(filter_value 0)
230 else()
231 message(FATAL_ERROR "darwin_filter_builtin_sources called without EXCLUDE|INCLUDE")
232 endif()
233
234 set(intermediate ${ARGN})
235 foreach (_file ${intermediate})
236 get_filename_component(_name_we ${_file} NAME_WE)
237 list(FIND ${excluded_list} ${_name_we} _found)
238 if(_found ${filter_action} ${filter_value})
239 list(REMOVE_ITEM intermediate ${_file})
240 elseif(${_file} MATCHES ".*/.*\\.S" OR ${_file} MATCHES ".*/.*\\.c")
241 get_filename_component(_name ${_file} NAME)
242 string(REPLACE ".S" ".c" _cname "${_name}")
243 list(REMOVE_ITEM intermediate ${_cname})
244 endif ()
245 endforeach ()
246 set(${output_var} ${intermediate} PARENT_SCOPE)
247endfunction()
248
249function(darwin_add_eprintf_library)
250 cmake_parse_arguments(LIB
251 ""
252 ""
253 "CFLAGS"
254 ${ARGN})
255
256 add_library(clang_rt.eprintf STATIC eprintf.c)
257 set_target_compile_flags(clang_rt.eprintf
258 -isysroot ${DARWIN_osx_SYSROOT}
259 ${DARWIN_osx_BUILTIN_MIN_VER_FLAG}
260 -arch i386
261 ${LIB_CFLAGS})
262 set_target_properties(clang_rt.eprintf PROPERTIES
263 OUTPUT_NAME clang_rt.eprintf${COMPILER_RT_OS_SUFFIX})
264 set_target_properties(clang_rt.eprintf PROPERTIES
265 OSX_ARCHITECTURES i386)
266 add_dependencies(builtins clang_rt.eprintf)
267 set_target_properties(clang_rt.eprintf PROPERTIES
268 ARCHIVE_OUTPUT_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR})
269 install(TARGETS clang_rt.eprintf
270 ARCHIVE DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR})
271endfunction()
272
273# Generates builtin libraries for all operating systems specified in ARGN. Each
274# OS library is constructed by lipo-ing together single-architecture libraries.
275macro(darwin_add_builtin_libraries)
276 set(DARWIN_EXCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Darwin-excludes)
277
278 set(CFLAGS "-fPIC -O3 -fvisibility=hidden -DVISIBILITY_HIDDEN -Wall -fomit-frame-pointer")
279 set(CMAKE_C_FLAGS "")
280 set(CMAKE_CXX_FLAGS "")
281 set(CMAKE_ASM_FLAGS "")
282
283 set(PROFILE_SOURCES ../profile/InstrProfiling
284 ../profile/InstrProfilingBuffer
285 ../profile/InstrProfilingPlatformDarwin)
286 foreach (os ${ARGN})
287 list_union(DARWIN_BUILTIN_ARCHS DARWIN_${os}_ARCHS BUILTIN_SUPPORTED_ARCH)
288 foreach (arch ${DARWIN_BUILTIN_ARCHS})
289 darwin_find_excluded_builtins_list(${arch}_${os}_EXCLUDED_BUILTINS
290 OS ${os}
291 ARCH ${arch}
292 MIN_VERSION ${DARWIN_${os}_BUILTIN_MIN_VER})
293
294 darwin_filter_builtin_sources(filtered_sources
295 EXCLUDE ${arch}_${os}_EXCLUDED_BUILTINS
296 ${${arch}_SOURCES})
297
298 darwin_add_builtin_library(clang_rt builtins
299 OS ${os}
300 ARCH ${arch}
301 SOURCES ${filtered_sources}
302 CFLAGS ${CFLAGS} -arch ${arch}
303 PARENT_TARGET builtins)
304 endforeach()
305
306 # Don't build cc_kext libraries for simulator platforms
307 if(NOT DARWIN_${os}_SKIP_CC_KEXT)
308 foreach (arch ${DARWIN_BUILTIN_ARCHS})
309 # By not specifying MIN_VERSION this only reads the OS and OS-arch lists.
310 # We don't want to filter out the builtins that are present in libSystem
311 # because kexts can't link libSystem.
312 darwin_find_excluded_builtins_list(${arch}_${os}_EXCLUDED_BUILTINS
313 OS ${os}
314 ARCH ${arch})
315
316 darwin_filter_builtin_sources(filtered_sources
317 EXCLUDE ${arch}_${os}_EXCLUDED_BUILTINS
318 ${${arch}_SOURCES})
319
320 # In addition to the builtins cc_kext includes some profile sources
321 darwin_add_builtin_library(clang_rt cc_kext
322 OS ${os}
323 ARCH ${arch}
324 SOURCES ${filtered_sources} ${PROFILE_SOURCES}
325 CFLAGS ${CFLAGS} -arch ${arch} -mkernel
326 DEFS KERNEL_USE
327 PARENT_TARGET builtins)
328 endforeach()
329 set(archive_name clang_rt.cc_kext_${os})
330 if(${os} STREQUAL "osx")
331 set(archive_name clang_rt.cc_kext)
332 endif()
333 darwin_lipo_libs(${archive_name}
334 PARENT_TARGET builtins
335 LIPO_FLAGS ${${os}_cc_kext_lipo_flags}
336 DEPENDS ${${os}_cc_kext_libs}
337 OUTPUT_DIR ${COMPILER_RT_LIBRARY_OUTPUT_DIR}
338 INSTALL_DIR ${COMPILER_RT_LIBRARY_INSTALL_DIR})
339 endif()
340 endforeach()
341
342 darwin_add_eprintf_library(CFLAGS ${CFLAGS})
343
344 # We put the x86 sim slices into the archives for their base OS
345 foreach (os ${ARGN})
346 if(NOT ${os} MATCHES ".*sim$")
347 darwin_lipo_libs(clang_rt.${os}
348 PARENT_TARGET builtins
349 LIPO_FLAGS ${${os}_builtins_lipo_flags} ${${os}sim_builtins_lipo_flags}
350 DEPENDS ${${os}_builtins_libs} ${${os}sim_builtins_libs}
351 OUTPUT_DIR ${COMPILER_RT_LIBRARY_OUTPUT_DIR}
352 INSTALL_DIR ${COMPILER_RT_LIBRARY_INSTALL_DIR})
353 endif()
354 endforeach()
355 darwin_add_embedded_builtin_libraries()
356endmacro()
357
358macro(darwin_add_embedded_builtin_libraries)
359 # this is a hacky opt-out. If you can't target both intel and arm
360 # architectures we bail here.
361 set(DARWIN_SOFT_FLOAT_ARCHS armv6m armv7m armv7em armv7)
362 set(DARWIN_HARD_FLOAT_ARCHS armv7em armv7)
363 if(COMPILER_RT_SUPPORTED_ARCH MATCHES ".*armv.*")
364 list(FIND COMPILER_RT_SUPPORTED_ARCH i386 i386_idx)
365 if(i386_idx GREATER -1)
366 list(APPEND DARWIN_HARD_FLOAT_ARCHS i386)
367 endif()
368
369 list(FIND COMPILER_RT_SUPPORTED_ARCH x86_64 x86_64_idx)
370 if(x86_64_idx GREATER -1)
371 list(APPEND DARWIN_HARD_FLOAT_ARCHS x86_64)
372 endif()
373
374 set(MACHO_SYM_DIR ${CMAKE_CURRENT_SOURCE_DIR}/macho_embedded)
375
376 set(CFLAGS "-Oz -Wall -fomit-frame-pointer -ffreestanding")
377 set(CMAKE_C_FLAGS "")
378 set(CMAKE_CXX_FLAGS "")
379 set(CMAKE_ASM_FLAGS "")
380
381 set(SOFT_FLOAT_FLAG -mfloat-abi=soft)
382 set(HARD_FLOAT_FLAG -mfloat-abi=hard)
383
384 set(ENABLE_PIC Off)
385 set(PIC_FLAG -fPIC)
386 set(STATIC_FLAG -static)
387
388 set(DARWIN_macho_embedded_ARCHS armv6m armv7m armv7em armv7 i386 x86_64)
389
390 set(DARWIN_macho_embedded_LIBRARY_OUTPUT_DIR
391 ${COMPILER_RT_OUTPUT_DIR}/lib/macho_embedded)
392 set(DARWIN_macho_embedded_LIBRARY_INSTALL_DIR
393 ${COMPILER_RT_INSTALL_PATH}/lib/macho_embedded)
394
395 set(CFLAGS_armv7 "-target thumbv7-apple-darwin-eabi")
396 set(CFLAGS_i386 "-march=pentium")
397
398 darwin_read_list_from_file(common_FUNCTIONS ${MACHO_SYM_DIR}/common.txt)
399 darwin_read_list_from_file(thumb2_FUNCTIONS ${MACHO_SYM_DIR}/thumb2.txt)
400 darwin_read_list_from_file(thumb2_64_FUNCTIONS ${MACHO_SYM_DIR}/thumb2-64.txt)
401 darwin_read_list_from_file(arm_FUNCTIONS ${MACHO_SYM_DIR}/arm.txt)
402 darwin_read_list_from_file(i386_FUNCTIONS ${MACHO_SYM_DIR}/i386.txt)
403
404
405 set(armv6m_FUNCTIONS ${common_FUNCTIONS} ${arm_FUNCTIONS})
406 set(armv7m_FUNCTIONS ${common_FUNCTIONS} ${arm_FUNCTIONS} ${thumb2_FUNCTIONS})
407 set(armv7em_FUNCTIONS ${common_FUNCTIONS} ${arm_FUNCTIONS} ${thumb2_FUNCTIONS})
408 set(armv7_FUNCTIONS ${common_FUNCTIONS} ${arm_FUNCTIONS} ${thumb2_FUNCTIONS} ${thumb2_64_FUNCTIONS})
409 set(i386_FUNCTIONS ${common_FUNCTIONS} ${i386_FUNCTIONS})
410 set(x86_64_FUNCTIONS ${common_FUNCTIONS})
411
412 foreach(arch ${DARWIN_macho_embedded_ARCHS})
413 darwin_filter_builtin_sources(${arch}_filtered_sources
414 INCLUDE ${arch}_FUNCTIONS
415 ${${arch}_SOURCES})
416 if(NOT ${arch}_filtered_sources)
417 message("${arch}_SOURCES: ${${arch}_SOURCES}")
418 message("${arch}_FUNCTIONS: ${${arch}_FUNCTIONS}")
419 message(FATAL_ERROR "Empty filtered sources!")
420 endif()
421 endforeach()
422
423 foreach(float_type SOFT HARD)
424 foreach(type PIC STATIC)
425 string(TOLOWER "${float_type}_${type}" lib_suffix)
426 foreach(arch ${DARWIN_${float_type}_FLOAT_ARCHS})
427 set(DARWIN_macho_embedded_SYSROOT ${DARWIN_osx_SYSROOT})
428 set(float_flag)
429 if(${arch} MATCHES "^arm")
430 # x86 targets are hard float by default, but the complain about the
431 # float ABI flag, so don't pass it unless we're targeting arm.
432 set(float_flag ${${float_type}_FLOAT_FLAG})
433 endif()
434 darwin_add_builtin_library(clang_rt ${lib_suffix}
435 OS macho_embedded
436 ARCH ${arch}
437 SOURCES ${${arch}_filtered_sources}
438 CFLAGS ${CFLAGS} -arch ${arch} ${${type}_FLAG} ${float_flag} ${CFLAGS_${arch}}
439 PARENT_TARGET builtins)
440 endforeach()
441 foreach(lib ${macho_embedded_${lib_suffix}_libs})
442 set_target_properties(${lib} PROPERTIES LINKER_LANGUAGE C)
443 endforeach()
444 darwin_lipo_libs(clang_rt.${lib_suffix}
445 PARENT_TARGET builtins
446 LIPO_FLAGS ${macho_embedded_${lib_suffix}_lipo_flags}
447 DEPENDS ${macho_embedded_${lib_suffix}_libs}
448 OUTPUT_DIR ${DARWIN_macho_embedded_LIBRARY_OUTPUT_DIR}
449 INSTALL_DIR ${DARWIN_macho_embedded_LIBRARY_INSTALL_DIR})
450 endforeach()
451 endforeach()
452 endif()
453endmacro()