From 2f5e1990f005c62e7c515e831c493b469957dc97 Mon Sep 17 00:00:00 2001 From: TB Schardl Date: Tue, 19 Jan 2021 10:46:09 -0500 Subject: [PATCH] [cmake] Backport recent compiler-rt CMake changes to cleanup and fix cmake on MacOSX. --- CMakeLists.txt | 39 +++++--- cmake/Modules/AddCilktools.cmake | 18 ++-- cmake/Modules/CilktoolsDarwinUtils.cmake | 95 +++++++++++++++---- cmake/Modules/CilktoolsUtils.cmake | 60 ++++++------ cmake/Modules/SanitizerUtils.cmake | 114 ----------------------- cmake/base-config-ix.cmake | 5 +- cmake/config-ix.cmake | 45 +++++++-- 7 files changed, 190 insertions(+), 186 deletions(-) delete mode 100644 cmake/Modules/SanitizerUtils.cmake diff --git a/CMakeLists.txt b/CMakeLists.txt index cbaef4a..ffc0831 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -5,7 +5,6 @@ cmake_minimum_required(VERSION 3.4.3) if(POLICY CMP0068) cmake_policy(SET CMP0068 NEW) set(CMAKE_BUILD_WITH_INSTALL_NAME_DIR ON) - cmake_policy(SET CMP0075 NEW) endif() # Check if cilktools is built as a standalone project. @@ -56,12 +55,34 @@ if (CILKTOOLS_STANDALONE_BUILD) set_target_properties(intrinsics_gen PROPERTIES FOLDER "Cilktools Misc") endif() - # Find Python interpreter. - include(FindPythonInterp) - if(NOT PYTHONINTERP_FOUND) - message(FATAL_ERROR " - Unable to find Python interpreter required testing. Please install Python - or specify the PYTHON_EXECUTABLE CMake variable.") + if(CMAKE_VERSION VERSION_LESS 3.12) + # Find Python interpreter. + include(FindPythonInterp) + if(NOT PYTHONINTERP_FOUND) + message(FATAL_ERROR " + Unable to find Python interpreter required testing. Please install Python + or specify the PYTHON_EXECUTABLE CMake variable.") + endif() + + add_executable(Python3::Interpreter IMPORTED) + set_target_properties(Python3::Interpreter PROPERTIES + IMPORTED_LOCATION ${PYTHON_EXECUTABLE}) + set(Python3_EXECUTABLE ${PYTHON_EXECUTABLE}) + else() + find_package(Python3 COMPONENTS Interpreter) + if(NOT Python3_Interpreter_FOUND) + message(WARNING "Python3 not found, using python2 as a fallback") + find_package(Python2 COMPONENTS Interpreter REQUIRED) + if(Python2_VERSION VERSION_LESS 2.7) + message(SEND_ERROR "Python 2.7 or newer is required") + endif() + + # Treat python2 as python3 + add_executable(Python3::Interpreter IMPORTED) + set_target_properties(Python3::Interpreter PROPERTIES + IMPORTED_LOCATION ${Python2_EXECUTABLE}) + set(Python3_EXECUTABLE ${Python2_EXECUTABLE}) + endif() endif() # Ensure that fat libraries are built correctly on Darwin @@ -273,7 +294,6 @@ append_list_if(CILKTOOLS_HAS_NODEFAULTLIBS_FLAG -nodefaultlibs SANITIZER_COMMON_ append_list_if(CILKTOOLS_HAS_Z_TEXT -Wl,-z,text SANITIZER_COMMON_LINK_FLAGS) # if (CILKTOOLS_USE_BUILTINS_LIBRARY) -# list(APPEND SANITIZER_COMMON_LINK_LIBS ${CILKTOOLS_BUILTINS_LIBRARY}) # string(REPLACE "-Wl,-z,defs" "" CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}") # else() append_list_if(CILKTOOLS_HAS_GCC_S_LIB gcc_s SANITIZER_COMMON_LINK_LIBS) @@ -357,14 +377,11 @@ else() set(CILKTOOLS_LLD_PATH ${LLVM_MAIN_SRC_DIR}/../lld) if(EXISTS ${CILKTOOLS_LLD_PATH}/ AND LLVM_TOOL_LLD_BUILD) set(CILKTOOLS_HAS_LLD TRUE) - else() - set(CILKTOOLS_HAS_LLD ${CILKTOOLS_HAS_FUSE_LD_LLD_FLAG}) endif() endif() pythonize_bool(CILKTOOLS_HAS_LLD) include(AddCilktools) -include(SanitizerUtils) set(ALL_CILKTOOLS csi;cilksan;cilkscale) set(CILKTOOLS_TO_BUILD all CACHE STRING diff --git a/cmake/Modules/AddCilktools.cmake b/cmake/Modules/AddCilktools.cmake index 1803d68..724df46 100644 --- a/cmake/Modules/AddCilktools.cmake +++ b/cmake/Modules/AddCilktools.cmake @@ -108,11 +108,11 @@ endfunction() function(add_asm_sources output) set(${output} ${ARGN} PARENT_SCOPE) - # Xcode will try to compile asm files as C ('clang -x c'), and that will fail. - if (${CMAKE_GENERATOR} STREQUAL "Xcode") - enable_language(ASM) - else() - # Pass ASM file directly to the C++ compiler. + # CMake doesn't pass the correct architecture for Apple prior to CMake 3.19. https://gitlab.kitware.com/cmake/cmake/-/issues/20771 + # MinGW didn't work correctly with assembly prior to CMake 3.17. https://gitlab.kitware.com/cmake/cmake/-/merge_requests/4287 and https://reviews.llvm.org/rGb780df052dd2b246a760d00e00f7de9ebdab9d09 + # Workaround these two issues by compiling as C. + # Same workaround used in libunwind. Also update there if changed here. + if((APPLE AND CMAKE_VERSION VERSION_LESS 3.19) OR (MINGW AND CMAKE_VERSION VERSION_LESS 3.17)) set_source_files_properties(${ARGN} PROPERTIES LANGUAGE C) endif() endfunction() @@ -468,7 +468,13 @@ function(add_cilktools_test test_suite test_name arch) # trump. With MSVC we can't do that because CMake is set up to run link.exe # when linking, not the compiler. Here, we hack it to use the compiler # because we want to use -fsanitize flags. - if(NOT MSVC) + + # Only add CMAKE_EXE_LINKER_FLAGS when in a standalone bulid. + # Or else CMAKE_EXE_LINKER_FLAGS contains flags for build compiler of Clang/llvm. + # This might not be the same as what the COMPILER_RT_TEST_COMPILER supports. + # eg: the build compiler use lld linker and we build clang with default ld linker + # then to be tested clang will complain about lld options like --color-diagnostics. + if(NOT MSVC AND CILKTOOLS_STANDALONE_BUILD) set(TEST_LINK_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${TEST_LINK_FLAGS}") separate_arguments(TEST_LINK_FLAGS) endif() diff --git a/cmake/Modules/CilktoolsDarwinUtils.cmake b/cmake/Modules/CilktoolsDarwinUtils.cmake index e597f90..c9e3a3b 100644 --- a/cmake/Modules/CilktoolsDarwinUtils.cmake +++ b/cmake/Modules/CilktoolsDarwinUtils.cmake @@ -44,8 +44,11 @@ function(find_darwin_sdk_dir var sdk_name) endfunction() function(find_darwin_sdk_version var sdk_name) - # We deliberately don't cache the result here because - # CMake's caching causes too many problems. + if (DARWIN_${sdk_name}_OVERRIDE_SDK_VERSION) + message(WARNING "Overriding ${sdk_name} SDK version to ${DARWIN_${sdk_name}_OVERRIDE_SDK_VERSION}") + set(${var} "${DARWIN_${sdk_name}_OVERRIDE_SDK_VERSION}" PARENT_SCOPE) + return() + endif() set(result_process 1) if(NOT DARWIN_PREFER_PUBLIC_SDK) # Let's first try the internal SDK, otherwise use the public SDK. @@ -166,25 +169,46 @@ function(darwin_test_archs os valid_archs) CACHE STRING "List of valid architectures for platform ${os}." FORCE) endfunction() -# This function checks the host cpusubtype to see if it is post-haswell. Haswell -# and later machines can run x86_64h binaries. Haswell is cpusubtype 8. +# This function checks the host cputype/cpusubtype to filter supported +# architecture for the host OS. This is used to determine which tests are +# available for the host. function(darwin_filter_host_archs input output) list_intersect(tmp_var DARWIN_osx_ARCHS ${input}) execute_process( - COMMAND sysctl hw.cpusubtype - OUTPUT_VARIABLE SUBTYPE) - - string(REGEX MATCH "hw.cpusubtype: ([0-9]*)" - SUBTYPE_MATCHED "${SUBTYPE}") - set(HASWELL_SUPPORTED Off) - if(SUBTYPE_MATCHED) - if(${CMAKE_MATCH_1} GREATER 7) - set(HASWELL_SUPPORTED On) + COMMAND sysctl hw.cputype + OUTPUT_VARIABLE CPUTYPE) + string(REGEX MATCH "hw.cputype: ([0-9]*)" + CPUTYPE_MATCHED "${CPUTYPE}") + set(ARM_HOST Off) + if(CPUTYPE_MATCHED) + # ARM cputype is (0x01000000 | 12) and X86(_64) is always 7. + if(${CMAKE_MATCH_1} GREATER 11) + set(ARM_HOST On) endif() endif() - if(NOT HASWELL_SUPPORTED) - list(REMOVE_ITEM tmp_var x86_64h) + + if(ARM_HOST) + list(REMOVE_ITEM tmp_var i386) + else() + list(REMOVE_ITEM tmp_var arm64) + list(REMOVE_ITEM tmp_var arm64e) + execute_process( + COMMAND sysctl hw.cpusubtype + OUTPUT_VARIABLE SUBTYPE) + string(REGEX MATCH "hw.cpusubtype: ([0-9]*)" + SUBTYPE_MATCHED "${SUBTYPE}") + + set(HASWELL_SUPPORTED Off) + if(SUBTYPE_MATCHED) + if(${CMAKE_MATCH_1} GREATER 7) + set(HASWELL_SUPPORTED On) + endif() + endif() + if(NOT HASWELL_SUPPORTED) + list(REMOVE_ITEM tmp_var x86_64h) + endif() endif() + set(${output} ${tmp_var} PARENT_SCOPE) endfunction() @@ -320,6 +344,38 @@ function(darwin_lipo_libs name) endif() endfunction() +# Filter the list of builtin sources for Darwin, then delegate to the generic +# filtering. +# +# `exclude_or_include` must be one of: +# - EXCLUDE: remove every item whose name (w/o extension) matches a name in +# `excluded_list`. +# - INCLUDE: keep only items whose name (w/o extension) matches something +# in `excluded_list`. +function(darwin_filter_builtin_sources output_var name exclude_or_include excluded_list) + if(exclude_or_include STREQUAL "EXCLUDE") + set(filter_action GREATER) + set(filter_value -1) + elseif(exclude_or_include STREQUAL "INCLUDE") + set(filter_action LESS) + set(filter_value 0) + else() + message(FATAL_ERROR "darwin_filter_builtin_sources called without EXCLUDE|INCLUDE") + endif() + + set(intermediate ${ARGN}) + foreach(_file ${intermediate}) + get_filename_component(_name_we ${_file} NAME_WE) + list(FIND ${excluded_list} ${_name_we} _found) + if(_found ${filter_action} ${filter_value}) + list(REMOVE_ITEM intermediate ${_file}) + endif() + endforeach() + + filter_builtin_sources(intermediate ${name}) + set(${output_var} ${intermediate} PARENT_SCOPE) +endfunction() + # Generates builtin libraries for all operating systems specified in ARGN. Each # OS library is constructed by lipo-ing together single-architecture libraries. macro(darwin_add_builtin_libraries) @@ -342,7 +398,8 @@ macro(darwin_add_builtin_libraries) ARCH ${arch} MIN_VERSION ${DARWIN_${os}_BUILTIN_MIN_VER}) - filter_builtin_sources(filtered_sources + darwin_filter_builtin_sources(filtered_sources + ${os}_${arch} EXCLUDE ${arch}_${os}_EXCLUDED_BUILTINS ${${arch}_SOURCES}) @@ -364,7 +421,8 @@ macro(darwin_add_builtin_libraries) OS ${os} ARCH ${arch}) - filter_builtin_sources(filtered_sources + darwin_filter_builtin_sources(filtered_sources + cc_kext_${os}_${arch} EXCLUDE ${arch}_${os}_EXCLUDED_BUILTINS ${${arch}_SOURCES}) @@ -460,7 +518,8 @@ macro(darwin_add_embedded_builtin_libraries) set(x86_64_FUNCTIONS ${common_FUNCTIONS}) foreach(arch ${DARWIN_macho_embedded_ARCHS}) - filter_builtin_sources(${arch}_filtered_sources + darwin_filter_builtin_sources(${arch}_filtered_sources + macho_embedded_${arch} INCLUDE ${arch}_FUNCTIONS ${${arch}_SOURCES}) if(NOT ${arch}_filtered_sources) diff --git a/cmake/Modules/CilktoolsUtils.cmake b/cmake/Modules/CilktoolsUtils.cmake index c711e2e..248b240 100644 --- a/cmake/Modules/CilktoolsUtils.cmake +++ b/cmake/Modules/CilktoolsUtils.cmake @@ -166,6 +166,7 @@ macro(detect_target_arch) check_symbol_exists(__sparcv9 "" __SPARCV9) check_symbol_exists(__wasm32__ "" __WEBASSEMBLY32) check_symbol_exists(__wasm64__ "" __WEBASSEMBLY64) + check_symbol_exists(__ve__ "" __VE) if(__ARM) add_default_target_arch(arm) elseif(__AARCH64) @@ -200,6 +201,8 @@ macro(detect_target_arch) add_default_target_arch(wasm32) elseif(__WEBASSEMBLY64) add_default_target_arch(wasm64) + elseif(__VE) + add_default_target_arch(ve) endif() endmacro() @@ -248,6 +251,8 @@ macro(load_llvm_config) string(REGEX REPLACE "[ \t]*[\r\n]+[ \t]*" ";" CONFIG_OUTPUT ${CONFIG_OUTPUT}) list(GET CONFIG_OUTPUT 0 LDFLAGS) list(GET CONFIG_OUTPUT 1 LIBLIST) + file(TO_CMAKE_PATH "${LDFLAGS}" LDFLAGS) + file(TO_CMAKE_PATH "${LIBLIST}" LIBLIST) set(LLVM_XRAY_LDFLAGS ${LDFLAGS} CACHE STRING "Linker flags for LLVMXRay library") set(LLVM_XRAY_LIBLIST ${LIBLIST} CACHE STRING "Library list for LLVMXRay") set(CILKTOOLS_HAS_LLVMXRAY TRUE) @@ -261,13 +266,15 @@ macro(load_llvm_config) ERROR_QUIET) if (HAD_ERROR) message(WARNING "llvm-config finding testingsupport failed with status ${HAD_ERROR}") - else() + elseif(CILKTOOLS_INCLUDE_TESTS) string(REGEX REPLACE "[ \t]*[\r\n]+[ \t]*" ";" CONFIG_OUTPUT ${CONFIG_OUTPUT}) list(GET CONFIG_OUTPUT 0 LDFLAGS) list(GET CONFIG_OUTPUT 1 LIBLIST) if (LIBLIST STREQUAL "") message(WARNING "testingsupport library not installed, some tests will be skipped") else() + file(TO_CMAKE_PATH "${LDFLAGS}" LDFLAGS) + file(TO_CMAKE_PATH "${LIBLIST}" LIBLIST) set(LLVM_TESTINGSUPPORT_LDFLAGS ${LDFLAGS} CACHE STRING "Linker flags for LLVMTestingSupport library") set(LLVM_TESTINGSUPPORT_LIBLIST ${LIBLIST} CACHE STRING "Library list for LLVMTestingSupport") set(CILKTOOLS_HAS_LLVMTESTINGSUPPORT TRUE) @@ -325,33 +332,30 @@ macro(construct_cilktools_default_triple) endif() endmacro() -# Filter out generic versions of routines that are re-implemented in -# architecture specific manner. This prevents multiple definitions of the -# same symbols, making the symbol selection non-deterministic. -function(filter_builtin_sources output_var exclude_or_include excluded_list) - if(exclude_or_include STREQUAL "EXCLUDE") - set(filter_action GREATER) - set(filter_value -1) - elseif(exclude_or_include STREQUAL "INCLUDE") - set(filter_action LESS) - set(filter_value 0) - else() - message(FATAL_ERROR "filter_builtin_sources called without EXCLUDE|INCLUDE") - endif() - - set(intermediate ${ARGN}) - foreach (_file ${intermediate}) - get_filename_component(_name_we ${_file} NAME_WE) - list(FIND ${excluded_list} ${_name_we} _found) - if(_found ${filter_action} ${filter_value}) - list(REMOVE_ITEM intermediate ${_file}) - elseif(${_file} MATCHES ".*/.*\\.S" OR ${_file} MATCHES ".*/.*\\.c") +# Filter out generic versions of routines that are re-implemented in an +# architecture specific manner. This prevents multiple definitions of the same +# symbols, making the symbol selection non-deterministic. +# +# We follow the convention that a source file that exists in a sub-directory +# (e.g. `ppc/divtc3.c`) is architecture-specific and that if a generic +# implementation exists it will be a top-level source file with the same name +# modulo the file extension (e.g. `divtc3.c`). +function(filter_builtin_sources inout_var name) + set(intermediate ${${inout_var}}) + foreach(_file ${intermediate}) + get_filename_component(_file_dir ${_file} DIRECTORY) + if (NOT "${_file_dir}" STREQUAL "") + # Architecture specific file. If a generic version exists, print a notice + # and ensure that it is removed from the file list. get_filename_component(_name ${_file} NAME) - string(REPLACE ".S" ".c" _cname "${_name}") - list(REMOVE_ITEM intermediate ${_cname}) - endif () - endforeach () - set(${output_var} ${intermediate} PARENT_SCOPE) + string(REGEX REPLACE "\\.S$" ".c" _cname "${_name}") + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_cname}") + message(STATUS "For ${name} builtins preferring ${_file} to ${_cname}") + list(REMOVE_ITEM intermediate ${_cname}) + endif() + endif() + endforeach() + set(${inout_var} ${intermediate} PARENT_SCOPE) endfunction() function(get_cilktools_target arch variable) @@ -361,7 +365,7 @@ function(get_cilktools_target arch variable) # Use exact spelling when building only for the target specified to CMake. set(target "${CILKTOOLS_DEFAULT_TARGET_TRIPLE}") elseif(ANDROID AND ${arch} STREQUAL "i386") - set(target "i686${CILKTOOLS_OS_SUFFIX}${triple_suffix}") + set(target "i686${triple_suffix}") else() set(target "${arch}${triple_suffix}") endif() diff --git a/cmake/Modules/SanitizerUtils.cmake b/cmake/Modules/SanitizerUtils.cmake deleted file mode 100644 index 1087964..0000000 --- a/cmake/Modules/SanitizerUtils.cmake +++ /dev/null @@ -1,114 +0,0 @@ -include(CilktoolsUtils) - -set(SANITIZER_GEN_DYNAMIC_LIST - ${CILKTOOLS_SOURCE_DIR}/lib/sanitizer_common/scripts/gen_dynamic_list.py) - -set(SANITIZER_LINT_SCRIPT - ${CILKTOOLS_SOURCE_DIR}/lib/sanitizer_common/scripts/check_lint.sh) - -if(CMAKE_NM) - set(SANITIZER_NM "${CMAKE_NM}") -else() - set(SANITIZER_NM nm) -endif() - -# Create a target "--symbols" that would generate the list of -# symbols that need to be exported from sanitizer runtime "". Function -# interceptors are exported automatically, user can also provide files with -# symbol names that should be exported as well. -# add_sanitizer_rt_symbols( -# ARCHS -# PARENT_TARGET -# EXTRA ) -macro(add_sanitizer_rt_symbols name) - cmake_parse_arguments(ARG - "" - "PARENT_TARGET" - "ARCHS;EXTRA" - ${ARGN}) - foreach(arch ${ARG_ARCHS}) - set(target_name ${name}-${arch}) - set(stamp ${CMAKE_CURRENT_BINARY_DIR}/${target_name}.syms-stamp) - set(extra_args) - foreach(arg ${ARG_EXTRA}) - list(APPEND extra_args "--extra" ${arg}) - endforeach() - add_custom_command(OUTPUT ${stamp} - COMMAND ${PYTHON_EXECUTABLE} - ${SANITIZER_GEN_DYNAMIC_LIST} ${extra_args} $ - --nm-executable "${SANITIZER_NM}" -o $.syms - COMMAND ${CMAKE_COMMAND} -E touch ${stamp} - DEPENDS ${target_name} ${SANITIZER_GEN_DYNAMIC_LIST} ${ARG_EXTRA} - WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} - COMMENT "Generating exported symbols for ${target_name}" - VERBATIM) - add_custom_target(${target_name}-symbols ALL - DEPENDS ${stamp} - SOURCES ${SANITIZER_GEN_DYNAMIC_LIST} ${ARG_EXTRA}) - get_cilktools_install_dir(${arch} install_dir) - install(FILES $.syms - DESTINATION ${install_dir}) - if(ARG_PARENT_TARGET) - add_dependencies(${ARG_PARENT_TARGET} ${target_name}-symbols) - endif() - endforeach() -endmacro() - -# This function is only used on Darwin, where undefined symbols must be specified -# in the linker invocation. -function(add_weak_symbols libname link_flags) - set(weak_symbols_file "${CILKTOOLS_SOURCE_DIR}/lib/${libname}/weak_symbols.txt") - file(STRINGS "${weak_symbols_file}" WEAK_SYMBOLS) - # Add this file as a configure-time dependency so that changes to this - # file trigger a re-configure. This is necessary so that `${link_flags}` - # is changed when appropriate. - set_property( - DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" - APPEND - PROPERTY CMAKE_CONFIGURE_DEPENDS "${weak_symbols_file}") - set(local_link_flags ${${link_flags}}) - foreach(SYMBOL ${WEAK_SYMBOLS}) - set(local_link_flags ${local_link_flags} -Wl,-U,${SYMBOL}) - endforeach() - set(${link_flags} ${local_link_flags} PARENT_SCOPE) -endfunction() - -macro(add_sanitizer_rt_version_list name) - set(vers ${CMAKE_CURRENT_BINARY_DIR}/${name}.vers) - cmake_parse_arguments(ARG "" "" "LIBS;EXTRA" ${ARGN}) - set(args) - foreach(arg ${ARG_EXTRA}) - list(APPEND args "--extra" ${arg}) - endforeach() - foreach(arg ${ARG_LIBS}) - list(APPEND args "$") - endforeach() - add_custom_command(OUTPUT ${vers} - COMMAND ${PYTHON_EXECUTABLE} - ${SANITIZER_GEN_DYNAMIC_LIST} --version-list ${args} - --nm-executable "${SANITIZER_NM}" -o ${vers} - DEPENDS ${SANITIZER_GEN_DYNAMIC_LIST} ${ARG_EXTRA} ${ARG_LIBS} - WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} - COMMENT "Generating version list for ${name}" - VERBATIM) - - add_custom_target(${name}-version-list ALL - DEPENDS ${vers}) -endmacro() - -# Add target to check code style for sanitizer runtimes. -if(CMAKE_HOST_UNIX AND NOT OS_NAME MATCHES "OpenBSD") - add_custom_target(SanitizerLintCheck - COMMAND env LLVM_CHECKOUT=${LLVM_MAIN_SRC_DIR} SILENT=1 TMPDIR= - PYTHON_EXECUTABLE=${PYTHON_EXECUTABLE} - CILKTOOLS=${CILKTOOLS_SOURCE_DIR} - ${SANITIZER_LINT_SCRIPT} - DEPENDS ${SANITIZER_LINT_SCRIPT} - COMMENT "Running lint check for sanitizer sources..." - VERBATIM) -else() - add_custom_target(SanitizerLintCheck - COMMAND echo "No lint check") -endif() -set_target_properties(SanitizerLintCheck - PROPERTIES FOLDER "Cilktools Misc") diff --git a/cmake/base-config-ix.cmake b/cmake/base-config-ix.cmake index 6e90d0d..2bb59b4 100644 --- a/cmake/base-config-ix.cmake +++ b/cmake/base-config-ix.cmake @@ -5,6 +5,7 @@ include(CheckIncludeFile) include(CheckCXXSourceCompiles) +include(TestBigEndian) check_include_file(unwind.h HAVE_UNWIND_H) @@ -191,7 +192,7 @@ macro(test_targets) # Strip out -nodefaultlibs when calling TEST_BIG_ENDIAN. Configuration # will fail with this option when building with a sanitizer. cmake_push_check_state() - string(REPLACE "-nodefaultlibs" "" CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS}) + string(REPLACE "-nodefaultlibs" "" CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}") TEST_BIG_ENDIAN(HOST_IS_BIG_ENDIAN) cmake_pop_check_state() @@ -236,6 +237,8 @@ macro(test_targets) test_target_arch(wasm32 "" "--target=wasm32-unknown-unknown") elseif("${CILKTOOLS_DEFAULT_TARGET_ARCH}" MATCHES "wasm64") test_target_arch(wasm64 "" "--target=wasm64-unknown-unknown") + elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "ve") + test_target_arch(ve "__ve__" "--target=ve-unknown-none") endif() set(CILKTOOLS_OS_SUFFIX "") endif() diff --git a/cmake/config-ix.cmake b/cmake/config-ix.cmake index 9877d36..ceb50f3 100644 --- a/cmake/config-ix.cmake +++ b/cmake/config-ix.cmake @@ -1,6 +1,7 @@ include(CMakePushCheckState) include(CheckCCompilerFlag) include(CheckCXXCompilerFlag) +include(CheckIncludeFiles) include(CheckLibraryExists) include(CheckSymbolExists) include(TestBigEndian) @@ -120,6 +121,9 @@ check_cxx_compiler_flag(/wd4800 CILKTOOLS_HAS_WD4800_FLAG) # Symbols. check_symbol_exists(__func__ "" CILKTOOLS_HAS_FUNC_SYMBOL) +# Includes. +check_include_files("sys/auxv.h" COMPILER_RT_HAS_AUXV) + # Libraries. check_library_exists(dl dlopen "" CILKTOOLS_HAS_LIBDL) check_library_exists(rt shm_open "" CILKTOOLS_HAS_LIBRT) @@ -218,6 +222,18 @@ function(get_test_cflags_for_apple_platform platform arch cflags_out) set(${cflags_out} "${test_cflags_str}" PARENT_SCOPE) endfunction() +function(get_capitalized_apple_platform platform platform_capitalized) + # TODO(dliew): Remove uses of this function. It exists to preserve needlessly complex + # directory naming conventions used by the Sanitizer lit test suites. + is_valid_apple_platform("${platform}" is_valid_platform) + if (NOT is_valid_platform) + message(FATAL_ERROR "\"${platform}\" is not a valid apple platform") + endif() + string(TOUPPER "${platform}" platform_upper) + string(REGEX REPLACE "OSSIM$" "OSSim" platform_upper_capitalized "${platform_upper}") + set(${platform_capitalized} "${platform_upper_capitalized}" PARENT_SCOPE) +endfunction() + function(is_valid_apple_platform platform is_valid_out) set(is_valid FALSE) if ("${platform}" STREQUAL "") @@ -282,21 +298,33 @@ if(APPLE) if(CILKTOOLS_ENABLE_IOS) list(APPEND DARWIN_EMBEDDED_PLATFORMS ios) + set(DARWIN_ios_MIN_VER 9.0) set(DARWIN_ios_MIN_VER_FLAG -miphoneos-version-min) set(DARWIN_ios_SANITIZER_MIN_VER_FLAG - ${DARWIN_ios_MIN_VER_FLAG}=9.0) + ${DARWIN_ios_MIN_VER_FLAG}=${DARWIN_ios_MIN_VER}) + set(DARWIN_iossim_MIN_VER_FLAG -mios-simulator-version-min) + set(DARWIN_iossim_SANITIZER_MIN_VER_FLAG + ${DARWIN_iossim_MIN_VER_FLAG}=${DARWIN_ios_MIN_VER}) endif() if(CILKTOOLS_ENABLE_WATCHOS) list(APPEND DARWIN_EMBEDDED_PLATFORMS watchos) + set(DARWIN_watchos_MIN_VER 2.0) set(DARWIN_watchos_MIN_VER_FLAG -mwatchos-version-min) set(DARWIN_watchos_SANITIZER_MIN_VER_FLAG - ${DARWIN_watchos_MIN_VER_FLAG}=2.0) + ${DARWIN_watchos_MIN_VER_FLAG}=${DARWIN_watchos_MIN_VER}) + set(DARWIN_watchossim_MIN_VER_FLAG -mwatchos-simulator-version-min) + set(DARWIN_watchossim_SANITIZER_MIN_VER_FLAG + ${DARWIN_watchossim_MIN_VER_FLAG}=${DARWIN_watchos_MIN_VER}) endif() if(CILKTOOLS_ENABLE_TVOS) list(APPEND DARWIN_EMBEDDED_PLATFORMS tvos) + set(DARWIN_tvos_MIN_VER 9.0) set(DARWIN_tvos_MIN_VER_FLAG -mtvos-version-min) set(DARWIN_tvos_SANITIZER_MIN_VER_FLAG - ${DARWIN_tvos_MIN_VER_FLAG}=9.0) + ${DARWIN_tvos_MIN_VER_FLAG}=${DARWIN_tvos_MIN_VER}) + set(DARWIN_tvossim_MIN_VER_FLAG -mtvos-simulator-version-min) + set(DARWIN_tvossim_SANITIZER_MIN_VER_FLAG + ${DARWIN_tvossim_MIN_VER_FLAG}=${DARWIN_tvos_MIN_VER}) endif() set(CILKTOOL_SUPPORTED_OS osx) @@ -304,8 +332,9 @@ if(APPLE) # Note: In order to target x86_64h on OS X the minimum deployment target must # be 10.8 or higher. set(DEFAULT_SANITIZER_MIN_OSX_VERSION 10.10) + set(DARWIN_osx_MIN_VER_FLAG "-mmacosx-version-min") if(NOT SANITIZER_MIN_OSX_VERSION) - string(REGEX MATCH "-mmacosx-version-min=([.0-9]+)" + string(REGEX MATCH "${DARWIN_osx_MIN_VER_FLAG}=([.0-9]+)" MACOSX_VERSION_MIN_FLAG "${CMAKE_CXX_FLAGS}") if(MACOSX_VERSION_MIN_FLAG) set(SANITIZER_MIN_OSX_VERSION "${CMAKE_MATCH_1}") @@ -339,10 +368,10 @@ if(APPLE) set(DARWIN_osx_CFLAGS ${DARWIN_COMMON_CFLAGS} - -mmacosx-version-min=${SANITIZER_MIN_OSX_VERSION}) + ${DARWIN_osx_MIN_VER_FLAG}=${SANITIZER_MIN_OSX_VERSION}) set(DARWIN_osx_LINK_FLAGS ${DARWIN_COMMON_LINK_FLAGS} - -mmacosx-version-min=${SANITIZER_MIN_OSX_VERSION}) + ${DARWIN_osx_MIN_VER_FLAG}=${SANITIZER_MIN_OSX_VERSION}) if(DARWIN_osx_SYSROOT) list(APPEND DARWIN_osx_CFLAGS -isysroot ${DARWIN_osx_SYSROOT}) @@ -367,11 +396,11 @@ if(APPLE) if(DARWIN_${platform}sim_SYSROOT) set(DARWIN_${platform}sim_CFLAGS ${DARWIN_COMMON_CFLAGS} - ${DARWIN_${platform}_SANITIZER_MIN_VER_FLAG} + ${DARWIN_${platform}sim_SANITIZER_MIN_VER_FLAG} -isysroot ${DARWIN_${platform}sim_SYSROOT}) set(DARWIN_${platform}sim_LINK_FLAGS ${DARWIN_COMMON_LINK_FLAGS} - ${DARWIN_${platform}_SANITIZER_MIN_VER_FLAG} + ${DARWIN_${platform}sim_SANITIZER_MIN_VER_FLAG} -isysroot ${DARWIN_${platform}sim_SYSROOT}) set(DARWIN_${platform}sim_SKIP_CC_KEXT On)