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. 4 function(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) 21 endfunction() 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. 26 function(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) 44 endfunction() 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. 48 function(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}.") 89 endfunction() 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. 93 function(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) 111 endfunction() 112 113 # Read and process the exclude file into a list of symbols 114 function(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() 120 endfunction() 121 122 # this function takes an OS, architecture and minimum version and provides a 123 # list of builtin functions to exclude 124 function(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) 163 endfunction() 164 165 # adds a single builtin library for a single OS & ARCH 166 macro(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}>) 194 endmacro() 195 196 function(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() 218 endfunction() 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. 223 function(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) 247 endfunction() 248 249 function(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}) 271 endfunction() 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. 275 macro(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() 356 endmacro() 357 358 macro(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() 453 endmacro() 454
