1include(ExternalProject) 2include(CompilerRTUtils) 3include(HandleCompilerRT) 4 5function(set_target_output_directories target output_dir) 6 # For RUNTIME_OUTPUT_DIRECTORY variable, Multi-configuration generators 7 # append a per-configuration subdirectory to the specified directory. 8 # To avoid the appended folder, the configuration specific variable must be 9 # set 'RUNTIME_OUTPUT_DIRECTORY_${CONF}': 10 # RUNTIME_OUTPUT_DIRECTORY_DEBUG, RUNTIME_OUTPUT_DIRECTORY_RELEASE, ... 11 if(CMAKE_CONFIGURATION_TYPES) 12 foreach(build_mode ${CMAKE_CONFIGURATION_TYPES}) 13 string(TOUPPER "${build_mode}" CONFIG_SUFFIX) 14 set_target_properties("${target}" PROPERTIES 15 "ARCHIVE_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${output_dir} 16 "LIBRARY_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${output_dir} 17 "RUNTIME_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${output_dir}) 18 endforeach() 19 else() 20 set_target_properties("${target}" PROPERTIES 21 ARCHIVE_OUTPUT_DIRECTORY ${output_dir} 22 LIBRARY_OUTPUT_DIRECTORY ${output_dir} 23 RUNTIME_OUTPUT_DIRECTORY ${output_dir}) 24 endif() 25endfunction() 26 27# Tries to add an "object library" target for a given list of OSs and/or 28# architectures with name "<name>.<arch>" for non-Darwin platforms if 29# architecture can be targeted, and "<name>.<os>" for Darwin platforms. 30# add_compiler_rt_object_libraries(<name> 31# OS <os names> 32# ARCHS <architectures> 33# SOURCES <source files> 34# CFLAGS <compile flags> 35# DEFS <compile definitions> 36# DEPS <dependencies> 37# ADDITIONAL_HEADERS <header files>) 38function(add_compiler_rt_object_libraries name) 39 cmake_parse_arguments(LIB "" "" "OS;ARCHS;SOURCES;CFLAGS;DEFS;DEPS;ADDITIONAL_HEADERS" 40 ${ARGN}) 41 set(libnames) 42 if(APPLE) 43 foreach(os ${LIB_OS}) 44 set(libname "${name}.${os}") 45 set(libnames ${libnames} ${libname}) 46 set(extra_cflags_${libname} ${DARWIN_${os}_CFLAGS}) 47 list_intersect(LIB_ARCHS_${libname} DARWIN_${os}_ARCHS LIB_ARCHS) 48 endforeach() 49 else() 50 foreach(arch ${LIB_ARCHS}) 51 set(libname "${name}.${arch}") 52 set(libnames ${libnames} ${libname}) 53 set(extra_cflags_${libname} ${TARGET_${arch}_CFLAGS}) 54 if(NOT CAN_TARGET_${arch}) 55 message(FATAL_ERROR "Architecture ${arch} can't be targeted") 56 return() 57 endif() 58 endforeach() 59 endif() 60 61 # Add headers to LIB_SOURCES for IDEs 62 compiler_rt_process_sources(LIB_SOURCES 63 ${LIB_SOURCES} 64 ADDITIONAL_HEADERS 65 ${LIB_ADDITIONAL_HEADERS} 66 ) 67 68 foreach(libname ${libnames}) 69 add_library(${libname} OBJECT ${LIB_SOURCES}) 70 if(LIB_DEPS) 71 add_dependencies(${libname} ${LIB_DEPS}) 72 endif() 73 74 # Strip out -msse3 if this isn't macOS. 75 set(target_flags ${LIB_CFLAGS}) 76 if(APPLE AND NOT "${libname}" MATCHES ".*\.osx.*") 77 list(REMOVE_ITEM target_flags "-msse3") 78 endif() 79 80 set_target_compile_flags(${libname} 81 ${extra_cflags_${libname}} ${target_flags}) 82 set_property(TARGET ${libname} APPEND PROPERTY 83 COMPILE_DEFINITIONS ${LIB_DEFS}) 84 set_target_properties(${libname} PROPERTIES FOLDER "Compiler-RT Libraries") 85 if(APPLE) 86 set_target_properties(${libname} PROPERTIES 87 OSX_ARCHITECTURES "${LIB_ARCHS_${libname}}") 88 endif() 89 endforeach() 90endfunction() 91 92# Takes a list of object library targets, and a suffix and appends the proper 93# TARGET_OBJECTS string to the output variable. 94# format_object_libs(<output> <suffix> ...) 95macro(format_object_libs output suffix) 96 foreach(lib ${ARGN}) 97 list(APPEND ${output} $<TARGET_OBJECTS:${lib}.${suffix}>) 98 endforeach() 99endmacro() 100 101function(add_compiler_rt_component name) 102 add_custom_target(${name}) 103 set_target_properties(${name} PROPERTIES FOLDER "Compiler-RT Misc") 104 if(COMMAND runtime_register_component) 105 runtime_register_component(${name}) 106 endif() 107 add_dependencies(compiler-rt ${name}) 108endfunction() 109 110function(add_asm_sources output) 111 set(${output} ${ARGN} PARENT_SCOPE) 112 # Xcode will try to compile asm files as C ('clang -x c'), and that will fail. 113 if (${CMAKE_GENERATOR} STREQUAL "Xcode") 114 enable_language(ASM) 115 else() 116 # Pass ASM file directly to the C++ compiler. 117 set_source_files_properties(${ARGN} PROPERTIES LANGUAGE C) 118 endif() 119endfunction() 120 121macro(set_output_name output name arch) 122 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR) 123 set(${output} ${name}) 124 else() 125 if(ANDROID AND ${arch} STREQUAL "i386") 126 set(${output} "${name}-i686${COMPILER_RT_OS_SUFFIX}") 127 else() 128 set(${output} "${name}-${arch}${COMPILER_RT_OS_SUFFIX}") 129 endif() 130 endif() 131endmacro() 132 133# Adds static or shared runtime for a list of architectures and operating 134# systems and puts it in the proper directory in the build and install trees. 135# add_compiler_rt_runtime(<name> 136# {OBJECT|STATIC|SHARED} 137# ARCHS <architectures> 138# OS <os list> 139# SOURCES <source files> 140# CFLAGS <compile flags> 141# LINK_FLAGS <linker flags> 142# DEFS <compile definitions> 143# LINK_LIBS <linked libraries> (only for shared library) 144# OBJECT_LIBS <object libraries to use as sources> 145# PARENT_TARGET <convenience parent target> 146# ADDITIONAL_HEADERS <header files>) 147function(add_compiler_rt_runtime name type) 148 if(NOT type MATCHES "^(OBJECT|STATIC|SHARED)$") 149 message(FATAL_ERROR "type argument must be OBJECT, STATIC or SHARED") 150 return() 151 endif() 152 cmake_parse_arguments(LIB 153 "" 154 "PARENT_TARGET" 155 "OS;ARCHS;SOURCES;CFLAGS;LINK_FLAGS;DEFS;LINK_LIBS;OBJECT_LIBS;ADDITIONAL_HEADERS" 156 ${ARGN}) 157 set(libnames) 158 # Until we support this some other way, build compiler-rt runtime without LTO 159 # to allow non-LTO projects to link with it. 160 if(COMPILER_RT_HAS_FNO_LTO_FLAG) 161 set(NO_LTO_FLAGS "-fno-lto") 162 else() 163 set(NO_LTO_FLAGS "") 164 endif() 165 166 # By default do not instrument or use profdata for compiler-rt. 167 set(NO_PGO_FLAGS "") 168 if(NOT COMPILER_RT_ENABLE_PGO) 169 if(LLVM_PROFDATA_FILE AND COMPILER_RT_HAS_FNO_PROFILE_INSTR_USE_FLAG) 170 list(APPEND NO_PGO_FLAGS "-fno-profile-instr-use") 171 endif() 172 if(LLVM_BUILD_INSTRUMENTED MATCHES IR AND COMPILER_RT_HAS_FNO_PROFILE_GENERATE_FLAG) 173 list(APPEND NO_PGO_FLAGS "-fno-profile-generate") 174 elseif(LLVM_BUILD_INSTRUMENTED AND COMPILER_RT_HAS_FNO_PROFILE_INSTR_GENERATE_FLAG) 175 list(APPEND NO_PGO_FLAGS "-fno-profile-instr-generate") 176 endif() 177 endif() 178 179 list(LENGTH LIB_SOURCES LIB_SOURCES_LENGTH) 180 if (${LIB_SOURCES_LENGTH} GREATER 0) 181 # Add headers to LIB_SOURCES for IDEs. It doesn't make sense to 182 # do this for a runtime library that only consists of OBJECT 183 # libraries, so only add the headers when source files are present. 184 compiler_rt_process_sources(LIB_SOURCES 185 ${LIB_SOURCES} 186 ADDITIONAL_HEADERS 187 ${LIB_ADDITIONAL_HEADERS} 188 ) 189 endif() 190 191 if(APPLE) 192 foreach(os ${LIB_OS}) 193 # Strip out -msse3 if this isn't macOS. 194 list(LENGTH LIB_CFLAGS HAS_EXTRA_CFLAGS) 195 if(HAS_EXTRA_CFLAGS AND NOT "${os}" MATCHES "^(osx)$") 196 list(REMOVE_ITEM LIB_CFLAGS "-msse3") 197 endif() 198 if(type STREQUAL "STATIC") 199 set(libname "${name}_${os}") 200 else() 201 set(libname "${name}_${os}_dynamic") 202 set(extra_link_flags_${libname} ${DARWIN_${os}_LINK_FLAGS} ${LIB_LINK_FLAGS}) 203 endif() 204 list_intersect(LIB_ARCHS_${libname} DARWIN_${os}_ARCHS LIB_ARCHS) 205 if(LIB_ARCHS_${libname}) 206 list(APPEND libnames ${libname}) 207 set(extra_cflags_${libname} ${DARWIN_${os}_CFLAGS} ${NO_LTO_FLAGS} ${NO_PGO_FLAGS} ${LIB_CFLAGS}) 208 set(output_name_${libname} ${libname}${COMPILER_RT_OS_SUFFIX}) 209 set(sources_${libname} ${LIB_SOURCES}) 210 format_object_libs(sources_${libname} ${os} ${LIB_OBJECT_LIBS}) 211 get_compiler_rt_output_dir(${COMPILER_RT_DEFAULT_TARGET_ARCH} output_dir_${libname}) 212 get_compiler_rt_install_dir(${COMPILER_RT_DEFAULT_TARGET_ARCH} install_dir_${libname}) 213 endif() 214 endforeach() 215 else() 216 foreach(arch ${LIB_ARCHS}) 217 if(NOT CAN_TARGET_${arch}) 218 message(FATAL_ERROR "Architecture ${arch} can't be targeted") 219 return() 220 endif() 221 if(type STREQUAL "OBJECT") 222 set(libname "${name}-${arch}") 223 set_output_name(output_name_${libname} ${name}${COMPILER_RT_OS_SUFFIX} ${arch}) 224 elseif(type STREQUAL "STATIC") 225 set(libname "${name}-${arch}") 226 set_output_name(output_name_${libname} ${name} ${arch}) 227 else() 228 set(libname "${name}-dynamic-${arch}") 229 set(extra_cflags_${libname} ${TARGET_${arch}_CFLAGS} ${LIB_CFLAGS}) 230 set(extra_link_flags_${libname} ${TARGET_${arch}_LINK_FLAGS} ${LIB_LINK_FLAGS}) 231 if(WIN32) 232 set_output_name(output_name_${libname} ${name}_dynamic ${arch}) 233 else() 234 set_output_name(output_name_${libname} ${name} ${arch}) 235 endif() 236 endif() 237 if(COMPILER_RT_USE_BUILTINS_LIBRARY AND NOT type STREQUAL "OBJECT" AND 238 NOT name STREQUAL "clang_rt.builtins") 239 get_compiler_rt_target(${arch} target) 240 find_compiler_rt_library(builtins ${target} builtins_${libname}) 241 if(builtins_${libname} STREQUAL "NOTFOUND") 242 message(FATAL_ERROR "Cannot find builtins library for the target architecture") 243 endif() 244 endif() 245 set(sources_${libname} ${LIB_SOURCES}) 246 format_object_libs(sources_${libname} ${arch} ${LIB_OBJECT_LIBS}) 247 set(libnames ${libnames} ${libname}) 248 set(extra_cflags_${libname} ${TARGET_${arch}_CFLAGS} ${NO_LTO_FLAGS} ${NO_PGO_FLAGS} ${LIB_CFLAGS}) 249 get_compiler_rt_output_dir(${arch} output_dir_${libname}) 250 get_compiler_rt_install_dir(${arch} install_dir_${libname}) 251 endforeach() 252 endif() 253 254 if(NOT libnames) 255 return() 256 endif() 257 258 if(LIB_PARENT_TARGET) 259 # If the parent targets aren't created we should create them 260 if(NOT TARGET ${LIB_PARENT_TARGET}) 261 add_custom_target(${LIB_PARENT_TARGET}) 262 set_target_properties(${LIB_PARENT_TARGET} PROPERTIES 263 FOLDER "Compiler-RT Misc") 264 endif() 265 endif() 266 267 foreach(libname ${libnames}) 268 # If you are using a multi-configuration generator we don't generate 269 # per-library install rules, so we fall back to the parent target COMPONENT 270 if(CMAKE_CONFIGURATION_TYPES AND LIB_PARENT_TARGET) 271 set(COMPONENT_OPTION COMPONENT ${LIB_PARENT_TARGET}) 272 else() 273 set(COMPONENT_OPTION COMPONENT ${libname}) 274 endif() 275 276 if(type STREQUAL "OBJECT") 277 if(CMAKE_C_COMPILER_ID MATCHES Clang AND CMAKE_C_COMPILER_TARGET) 278 list(APPEND extra_cflags_${libname} "--target=${CMAKE_C_COMPILER_TARGET}") 279 endif() 280 if(CMAKE_SYSROOT) 281 list(APPEND extra_cflags_${libname} "--sysroot=${CMAKE_SYSROOT}") 282 endif() 283 string(REPLACE ";" " " extra_cflags_${libname} "${extra_cflags_${libname}}") 284 string(REGEX MATCHALL "<[A-Za-z0-9_]*>" substitutions 285 ${CMAKE_C_COMPILE_OBJECT}) 286 set(compile_command_${libname} "${CMAKE_C_COMPILE_OBJECT}") 287 288 set(output_file_${libname} ${output_name_${libname}}${CMAKE_C_OUTPUT_EXTENSION}) 289 foreach(substitution ${substitutions}) 290 if(substitution STREQUAL "<CMAKE_C_COMPILER>") 291 string(REPLACE "<CMAKE_C_COMPILER>" "${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}" 292 compile_command_${libname} ${compile_command_${libname}}) 293 elseif(substitution STREQUAL "<OBJECT>") 294 string(REPLACE "<OBJECT>" "${output_dir_${libname}}/${output_file_${libname}}" 295 compile_command_${libname} ${compile_command_${libname}}) 296 elseif(substitution STREQUAL "<SOURCE>") 297 string(REPLACE "<SOURCE>" "${sources_${libname}}" 298 compile_command_${libname} ${compile_command_${libname}}) 299 elseif(substitution STREQUAL "<FLAGS>") 300 string(REPLACE "<FLAGS>" "${CMAKE_C_FLAGS} ${extra_cflags_${libname}}" 301 compile_command_${libname} ${compile_command_${libname}}) 302 else() 303 string(REPLACE "${substitution}" "" compile_command_${libname} 304 ${compile_command_${libname}}) 305 endif() 306 endforeach() 307 separate_arguments(compile_command_${libname}) 308 add_custom_command( 309 OUTPUT ${output_dir_${libname}}/${output_file_${libname}} 310 COMMAND ${compile_command_${libname}} 311 DEPENDS ${sources_${libname}} 312 COMMENT "Building C object ${output_file_${libname}}") 313 add_custom_target(${libname} DEPENDS ${output_dir_${libname}}/${output_file_${libname}}) 314 install(FILES ${output_dir_${libname}}/${output_file_${libname}} 315 DESTINATION ${install_dir_${libname}} 316 ${COMPONENT_OPTION}) 317 else() 318 add_library(${libname} ${type} ${sources_${libname}}) 319 set_target_compile_flags(${libname} ${extra_cflags_${libname}}) 320 set_target_link_flags(${libname} ${extra_link_flags_${libname}}) 321 set_property(TARGET ${libname} APPEND PROPERTY 322 COMPILE_DEFINITIONS ${LIB_DEFS}) 323 set_target_output_directories(${libname} ${output_dir_${libname}}) 324 install(TARGETS ${libname} 325 ARCHIVE DESTINATION ${install_dir_${libname}} 326 ${COMPONENT_OPTION} 327 LIBRARY DESTINATION ${install_dir_${libname}} 328 ${COMPONENT_OPTION} 329 RUNTIME DESTINATION ${install_dir_${libname}} 330 ${COMPONENT_OPTION}) 331 endif() 332 set_target_properties(${libname} PROPERTIES 333 OUTPUT_NAME ${output_name_${libname}}) 334 set_target_properties(${libname} PROPERTIES FOLDER "Compiler-RT Runtime") 335 if(LIB_LINK_LIBS) 336 target_link_libraries(${libname} PRIVATE ${LIB_LINK_LIBS}) 337 endif() 338 if(builtins_${libname}) 339 target_link_libraries(${libname} PRIVATE ${builtins_${libname}}) 340 endif() 341 if(${type} STREQUAL "SHARED") 342 if(COMMAND llvm_setup_rpath) 343 llvm_setup_rpath(${libname}) 344 endif() 345 if(WIN32 AND NOT CYGWIN AND NOT MINGW) 346 set_target_properties(${libname} PROPERTIES IMPORT_PREFIX "") 347 set_target_properties(${libname} PROPERTIES IMPORT_SUFFIX ".lib") 348 endif() 349 if(APPLE) 350 # Ad-hoc sign the dylibs 351 add_custom_command(TARGET ${libname} 352 POST_BUILD 353 COMMAND codesign --sign - $<TARGET_FILE:${libname}> 354 WORKING_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR} 355 ) 356 endif() 357 endif() 358 359 set(parent_target_arg) 360 if(LIB_PARENT_TARGET) 361 set(parent_target_arg PARENT_TARGET ${LIB_PARENT_TARGET}) 362 endif() 363 add_compiler_rt_install_targets(${libname} ${parent_target_arg}) 364 365 if(APPLE) 366 set_target_properties(${libname} PROPERTIES 367 OSX_ARCHITECTURES "${LIB_ARCHS_${libname}}") 368 endif() 369 370 if(type STREQUAL "SHARED") 371 rt_externalize_debuginfo(${libname}) 372 endif() 373 endforeach() 374 if(LIB_PARENT_TARGET) 375 add_dependencies(${LIB_PARENT_TARGET} ${libnames}) 376 endif() 377endfunction() 378 379# when cross compiling, COMPILER_RT_TEST_COMPILER_CFLAGS help 380# in compilation and linking of unittests. 381string(REPLACE " " ";" COMPILER_RT_UNITTEST_CFLAGS "${COMPILER_RT_TEST_COMPILER_CFLAGS}") 382set(COMPILER_RT_UNITTEST_LINK_FLAGS ${COMPILER_RT_UNITTEST_CFLAGS}) 383 384# Unittests support. 385set(COMPILER_RT_GTEST_PATH ${LLVM_MAIN_SRC_DIR}/utils/unittest/googletest) 386set(COMPILER_RT_GTEST_SOURCE ${COMPILER_RT_GTEST_PATH}/src/gtest-all.cc) 387set(COMPILER_RT_GTEST_CFLAGS 388 -DGTEST_NO_LLVM_SUPPORT=1 389 -DGTEST_HAS_RTTI=0 390 -I${COMPILER_RT_GTEST_PATH}/include 391 -I${COMPILER_RT_GTEST_PATH} 392) 393 394# Mocking support. 395set(COMPILER_RT_GMOCK_PATH ${LLVM_MAIN_SRC_DIR}/utils/unittest/googlemock) 396set(COMPILER_RT_GMOCK_SOURCE ${COMPILER_RT_GMOCK_PATH}/src/gmock-all.cc) 397set(COMPILER_RT_GMOCK_CFLAGS 398 -DGTEST_NO_LLVM_SUPPORT=1 399 -DGTEST_HAS_RTTI=0 400 -I${COMPILER_RT_GMOCK_PATH}/include 401 -I${COMPILER_RT_GMOCK_PATH} 402) 403 404append_list_if(COMPILER_RT_DEBUG -DSANITIZER_DEBUG=1 COMPILER_RT_UNITTEST_CFLAGS) 405append_list_if(COMPILER_RT_HAS_WCOVERED_SWITCH_DEFAULT_FLAG -Wno-covered-switch-default COMPILER_RT_UNITTEST_CFLAGS) 406append_list_if(COMPILER_RT_HAS_WSUGGEST_OVERRIDE_FLAG -Wno-suggest-override COMPILER_RT_UNITTEST_CFLAGS) 407 408if(MSVC) 409 # gtest use a lot of stuff marked as deprecated on Windows. 410 list(APPEND COMPILER_RT_GTEST_CFLAGS -Wno-deprecated-declarations) 411endif() 412 413# Compile and register compiler-rt tests. 414# generate_compiler_rt_tests(<output object files> <test_suite> <test_name> 415# <test architecture> 416# KIND <custom prefix> 417# SUBDIR <subdirectory for testing binary> 418# SOURCES <sources to compile> 419# RUNTIME <tests runtime to link in> 420# CFLAGS <compile-time flags> 421# COMPILE_DEPS <compile-time dependencies> 422# DEPS <dependencies> 423# LINK_FLAGS <flags to use during linking> 424# ) 425function(generate_compiler_rt_tests test_objects test_suite testname arch) 426 cmake_parse_arguments(TEST "" "KIND;RUNTIME;SUBDIR" 427 "SOURCES;COMPILE_DEPS;DEPS;CFLAGS;LINK_FLAGS" ${ARGN}) 428 429 foreach(source ${TEST_SOURCES}) 430 sanitizer_test_compile( 431 "${test_objects}" "${source}" "${arch}" 432 KIND ${TEST_KIND} 433 COMPILE_DEPS ${TEST_COMPILE_DEPS} 434 DEPS ${TEST_DEPS} 435 CFLAGS ${TEST_CFLAGS} 436 ) 437 endforeach() 438 439 set(TEST_DEPS ${${test_objects}}) 440 441 if(NOT "${TEST_RUNTIME}" STREQUAL "") 442 list(APPEND TEST_DEPS ${TEST_RUNTIME}) 443 list(APPEND "${test_objects}" $<TARGET_FILE:${TEST_RUNTIME}>) 444 endif() 445 446 add_compiler_rt_test(${test_suite} "${testname}" "${arch}" 447 SUBDIR ${TEST_SUBDIR} 448 OBJECTS ${${test_objects}} 449 DEPS ${TEST_DEPS} 450 LINK_FLAGS ${TEST_LINK_FLAGS} 451 ) 452 set("${test_objects}" "${${test_objects}}" PARENT_SCOPE) 453endfunction() 454 455# Link objects into a single executable with COMPILER_RT_TEST_COMPILER, 456# using specified link flags. Make executable a part of provided 457# test_suite. 458# add_compiler_rt_test(<test_suite> <test_name> <arch> 459# SUBDIR <subdirectory for binary> 460# OBJECTS <object files> 461# DEPS <deps (e.g. runtime libs)> 462# LINK_FLAGS <link flags>) 463function(add_compiler_rt_test test_suite test_name arch) 464 cmake_parse_arguments(TEST "" "SUBDIR" "OBJECTS;DEPS;LINK_FLAGS" "" ${ARGN}) 465 set(output_dir ${CMAKE_CURRENT_BINARY_DIR}) 466 if(TEST_SUBDIR) 467 set(output_dir "${output_dir}/${TEST_SUBDIR}") 468 endif() 469 set(output_dir "${output_dir}/${CMAKE_CFG_INTDIR}") 470 file(MAKE_DIRECTORY "${output_dir}") 471 set(output_bin "${output_dir}/${test_name}") 472 if(MSVC) 473 set(output_bin "${output_bin}.exe") 474 endif() 475 476 # Use host compiler in a standalone build, and just-built Clang otherwise. 477 if(NOT COMPILER_RT_STANDALONE_BUILD) 478 list(APPEND TEST_DEPS clang) 479 endif() 480 481 get_target_flags_for_arch(${arch} TARGET_LINK_FLAGS) 482 list(APPEND TEST_LINK_FLAGS ${TARGET_LINK_FLAGS}) 483 484 # If we're not on MSVC, include the linker flags from CMAKE but override them 485 # with the provided link flags. This ensures that flags which are required to 486 # link programs at all are included, but the changes needed for the test 487 # trump. With MSVC we can't do that because CMake is set up to run link.exe 488 # when linking, not the compiler. Here, we hack it to use the compiler 489 # because we want to use -fsanitize flags. 490 491 # Only add CMAKE_EXE_LINKER_FLAGS when in a standalone bulid. 492 # Or else CMAKE_EXE_LINKER_FLAGS contains flags for build compiler of Clang/llvm. 493 # This might not be the same as what the COMPILER_RT_TEST_COMPILER supports. 494 # eg: the build compiler use lld linker and we build clang with default ld linker 495 # then to be tested clang will complain about lld options like --color-diagnostics. 496 if(NOT MSVC AND COMPILER_RT_STANDALONE_BUILD) 497 set(TEST_LINK_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${TEST_LINK_FLAGS}") 498 separate_arguments(TEST_LINK_FLAGS) 499 endif() 500 if(NOT COMPILER_RT_STANDALONE_BUILD AND COMPILER_RT_HAS_LLD AND "lld" IN_LIST LLVM_ENABLE_PROJECTS) 501 # CMAKE_EXE_LINKER_FLAGS may contain -fuse=lld 502 # FIXME: -DLLVM_ENABLE_LLD=ON and -DLLVM_ENABLE_PROJECTS without lld case. 503 list(APPEND TEST_DEPS lld) 504 endif() 505 add_custom_command( 506 OUTPUT "${output_bin}" 507 COMMAND ${COMPILER_RT_TEST_COMPILER} ${TEST_OBJECTS} -o "${output_bin}" 508 ${TEST_LINK_FLAGS} 509 DEPENDS ${TEST_DEPS} 510 ) 511 add_custom_target(T${test_name} DEPENDS "${output_bin}") 512 set_target_properties(T${test_name} PROPERTIES FOLDER "Compiler-RT Tests") 513 514 # Make the test suite depend on the binary. 515 add_dependencies(${test_suite} T${test_name}) 516endfunction() 517 518macro(add_compiler_rt_resource_file target_name file_name component) 519 set(src_file "${CMAKE_CURRENT_SOURCE_DIR}/${file_name}") 520 set(dst_file "${COMPILER_RT_OUTPUT_DIR}/share/${file_name}") 521 add_custom_command(OUTPUT ${dst_file} 522 DEPENDS ${src_file} 523 COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src_file} ${dst_file} 524 COMMENT "Copying ${file_name}...") 525 add_custom_target(${target_name} DEPENDS ${dst_file}) 526 # Install in Clang resource directory. 527 install(FILES ${file_name} 528 DESTINATION ${COMPILER_RT_INSTALL_PATH}/share 529 COMPONENT ${component}) 530 add_dependencies(${component} ${target_name}) 531 532 set_target_properties(${target_name} PROPERTIES FOLDER "Compiler-RT Misc") 533endmacro() 534 535macro(add_compiler_rt_script name) 536 set(dst ${COMPILER_RT_EXEC_OUTPUT_DIR}/${name}) 537 set(src ${CMAKE_CURRENT_SOURCE_DIR}/${name}) 538 add_custom_command(OUTPUT ${dst} 539 DEPENDS ${src} 540 COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst} 541 COMMENT "Copying ${name}...") 542 add_custom_target(${name} DEPENDS ${dst}) 543 install(FILES ${dst} 544 PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE 545 DESTINATION ${COMPILER_RT_INSTALL_PATH}/bin) 546endmacro(add_compiler_rt_script src name) 547 548# Builds custom version of libc++ and installs it in <prefix>. 549# Can be used to build sanitized versions of libc++ for running unit tests. 550# add_custom_libcxx(<name> <prefix> 551# DEPS <list of build deps> 552# CFLAGS <list of compile flags> 553# USE_TOOLCHAIN) 554macro(add_custom_libcxx name prefix) 555 if(NOT COMPILER_RT_LIBCXX_PATH) 556 message(FATAL_ERROR "libcxx not found!") 557 endif() 558 if(NOT COMPILER_RT_LIBCXXABI_PATH) 559 message(FATAL_ERROR "libcxxabi not found!") 560 endif() 561 562 cmake_parse_arguments(LIBCXX "USE_TOOLCHAIN" "" "DEPS;CFLAGS;CMAKE_ARGS" ${ARGN}) 563 564 if(LIBCXX_USE_TOOLCHAIN) 565 set(compiler_args -DCMAKE_C_COMPILER=${COMPILER_RT_TEST_COMPILER} 566 -DCMAKE_CXX_COMPILER=${COMPILER_RT_TEST_CXX_COMPILER}) 567 if(NOT COMPILER_RT_STANDALONE_BUILD AND NOT RUNTIMES_BUILD) 568 set(toolchain_deps $<TARGET_FILE:clang>) 569 set(force_deps DEPENDS $<TARGET_FILE:clang>) 570 endif() 571 else() 572 set(compiler_args -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} 573 -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}) 574 endif() 575 576 set(STAMP_DIR ${prefix}-stamps/) 577 set(BINARY_DIR ${prefix}-bins/) 578 579 add_custom_target(${name}-clear 580 COMMAND ${CMAKE_COMMAND} -E remove_directory ${BINARY_DIR} 581 COMMAND ${CMAKE_COMMAND} -E remove_directory ${STAMP_DIR} 582 COMMENT "Clobbering ${name} build and stamp directories" 583 USES_TERMINAL 584 ) 585 set_target_properties(${name}-clear PROPERTIES FOLDER "Compiler-RT Misc") 586 587 add_custom_command( 588 OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${name}-clobber-stamp 589 DEPENDS ${LIBCXX_DEPS} ${toolchain_deps} 590 COMMAND ${CMAKE_COMMAND} -E touch ${BINARY_DIR}/CMakeCache.txt 591 COMMAND ${CMAKE_COMMAND} -E touch ${STAMP_DIR}/${name}-mkdir 592 COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/${name}-clobber-stamp 593 COMMENT "Clobbering bootstrap build and stamp directories" 594 ) 595 596 add_custom_target(${name}-clobber 597 DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${name}-clobber-stamp) 598 set_target_properties(${name}-clobber PROPERTIES FOLDER "Compiler-RT Misc") 599 600 set(PASSTHROUGH_VARIABLES 601 CMAKE_C_COMPILER_TARGET 602 CMAKE_CXX_COMPILER_TARGET 603 CMAKE_SHARED_LINKER_FLAGS 604 CMAKE_MODULE_LINKER_FLAGS 605 CMAKE_EXE_LINKER_FLAGS 606 CMAKE_INSTALL_PREFIX 607 CMAKE_MAKE_PROGRAM 608 CMAKE_LINKER 609 CMAKE_AR 610 CMAKE_RANLIB 611 CMAKE_NM 612 CMAKE_OBJCOPY 613 CMAKE_OBJDUMP 614 CMAKE_STRIP 615 CMAKE_SYSROOT 616 CMAKE_SYSTEM_NAME) 617 foreach(variable ${PASSTHROUGH_VARIABLES}) 618 get_property(is_value_set CACHE ${variable} PROPERTY VALUE SET) 619 if(${is_value_set}) 620 get_property(value CACHE ${variable} PROPERTY VALUE) 621 list(APPEND CMAKE_PASSTHROUGH_VARIABLES -D${variable}=${value}) 622 endif() 623 endforeach() 624 625 string(REPLACE ";" " " LIBCXX_C_FLAGS "${LIBCXX_CFLAGS}") 626 get_property(C_FLAGS CACHE CMAKE_C_FLAGS PROPERTY VALUE) 627 set(LIBCXX_C_FLAGS "${LIBCXX_C_FLAGS} ${C_FLAGS}") 628 629 string(REPLACE ";" " " LIBCXX_CXX_FLAGS "${LIBCXX_CFLAGS}") 630 get_property(CXX_FLAGS CACHE CMAKE_CXX_FLAGS PROPERTY VALUE) 631 set(LIBCXX_CXX_FLAGS "${LIBCXX_CXX_FLAGS} ${CXX_FLAGS}") 632 633 ExternalProject_Add(${name} 634 DEPENDS ${name}-clobber ${LIBCXX_DEPS} 635 PREFIX ${prefix} 636 SOURCE_DIR ${COMPILER_RT_SOURCE_DIR}/cmake/Modules/CustomLibcxx 637 STAMP_DIR ${STAMP_DIR} 638 BINARY_DIR ${BINARY_DIR} 639 CMAKE_ARGS ${CMAKE_PASSTHROUGH_VARIABLES} 640 ${compiler_args} 641 -DCMAKE_C_FLAGS=${LIBCXX_C_FLAGS} 642 -DCMAKE_CXX_FLAGS=${LIBCXX_CXX_FLAGS} 643 -DCMAKE_BUILD_TYPE=Release 644 -DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY 645 -DLLVM_PATH=${LLVM_MAIN_SRC_DIR} 646 -DLLVM_BINARY_DIR=${prefix} 647 -DLLVM_LIBRARY_OUTPUT_INTDIR=${prefix}/lib 648 -DCOMPILER_RT_LIBCXX_PATH=${COMPILER_RT_LIBCXX_PATH} 649 -DCOMPILER_RT_LIBCXXABI_PATH=${COMPILER_RT_LIBCXXABI_PATH} 650 ${LIBCXX_CMAKE_ARGS} 651 INSTALL_COMMAND "" 652 STEP_TARGETS configure build 653 BUILD_ALWAYS 1 654 USES_TERMINAL_CONFIGURE 1 655 USES_TERMINAL_BUILD 1 656 USES_TERMINAL_INSTALL 1 657 EXCLUDE_FROM_ALL TRUE 658 BUILD_BYPRODUCTS "${prefix}/lib/libc++.a" "${prefix}/lib/libc++abi.a" 659 ) 660 661 if (CMAKE_GENERATOR MATCHES "Make") 662 set(run_clean "$(MAKE)" "-C" "${BINARY_DIR}" "clean") 663 else() 664 set(run_clean ${CMAKE_COMMAND} --build ${BINARY_DIR} --target clean 665 --config "$<CONFIG>") 666 endif() 667 668 ExternalProject_Add_Step(${name} clean 669 COMMAND ${run_clean} 670 COMMENT "Cleaning ${name}..." 671 DEPENDEES configure 672 ${force_deps} 673 WORKING_DIRECTORY ${BINARY_DIR} 674 EXCLUDE_FROM_MAIN 1 675 USES_TERMINAL 1 676 ) 677 ExternalProject_Add_StepTargets(${name} clean) 678 679 if(LIBCXX_USE_TOOLCHAIN) 680 add_dependencies(${name}-clean ${name}-clobber) 681 set_target_properties(${name}-clean PROPERTIES 682 SOURCES ${CMAKE_CURRENT_BINARY_DIR}/${name}-clobber-stamp) 683 endif() 684endmacro() 685 686function(rt_externalize_debuginfo name) 687 if(NOT COMPILER_RT_EXTERNALIZE_DEBUGINFO) 688 return() 689 endif() 690 691 if(NOT COMPILER_RT_EXTERNALIZE_DEBUGINFO_SKIP_STRIP) 692 set(strip_command COMMAND xcrun strip -Sl $<TARGET_FILE:${name}>) 693 endif() 694 695 if(APPLE) 696 if(CMAKE_CXX_FLAGS MATCHES "-flto" 697 OR CMAKE_CXX_FLAGS_${uppercase_CMAKE_BUILD_TYPE} MATCHES "-flto") 698 699 set(lto_object ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${name}-lto.o) 700 set_property(TARGET ${name} APPEND_STRING PROPERTY 701 LINK_FLAGS " -Wl,-object_path_lto -Wl,${lto_object}") 702 endif() 703 add_custom_command(TARGET ${name} POST_BUILD 704 COMMAND xcrun dsymutil $<TARGET_FILE:${name}> 705 ${strip_command}) 706 else() 707 message(FATAL_ERROR "COMPILER_RT_EXTERNALIZE_DEBUGINFO isn't implemented for non-darwin platforms!") 708 endif() 709endfunction() 710 711 712# Configure lit configuration files, including compiler-rt specific variables. 713function(configure_compiler_rt_lit_site_cfg input output) 714 set_llvm_build_mode() 715 716 get_compiler_rt_output_dir(${COMPILER_RT_DEFAULT_TARGET_ARCH} output_dir) 717 718 string(REPLACE ${CMAKE_CFG_INTDIR} ${LLVM_BUILD_MODE} COMPILER_RT_RESOLVED_TEST_COMPILER ${COMPILER_RT_TEST_COMPILER}) 719 string(REPLACE ${CMAKE_CFG_INTDIR} ${LLVM_BUILD_MODE} COMPILER_RT_RESOLVED_LIBRARY_OUTPUT_DIR ${output_dir}) 720 721 configure_lit_site_cfg(${input} ${output}) 722endfunction() 723