maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/libc/cmake/modules/LLVMLibCCheckCpuFeatures.cmake

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

88 lines
2.9 KiB
CMake
Raw Normal View History

[libc] Adding memcpy implementation for x86_64 Summary: The patch is not ready yet and is here to discuss a few options: - How do we customize the implementation? (i.e. how to define `kRepMovsBSize`), - How do we specify custom compilation flags? (We'd need `-fno-builtin-memcpy` to be passed in), - How do we build? We may want to test in debug but build the libc with `-march=native` for instance, - Clang has a brand new builtin `__builtin_memcpy_inline` which makes the implementation easy and efficient, but: - If we compile with `gcc` or `msvc` we can't use it, resorting on less efficient code generation, - With gcc we can use `__builtin_memcpy` but then we'd need a postprocess step to check that the final assembly do not contain call to `memcpy` (unlikely but allowed), - For msvc we'd need to resort on the compiler optimization passes. Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits, courbet Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74397
2020-02-11 20:37:02 +08:00
# ------------------------------------------------------------------------------
[libc] Add CMake script to check host cpu features Summary: Tested on MacOSX and Linux. For robustness we can go the OpenCV way and add individual c++ files with intrinsics. https://github.com/opencv/opencv/blob/master/cmake/checks/cpu_avx2.cpp Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74897
2020-02-20 22:00:45 +08:00
# Cpu features definition and flags
[libc] Adding memcpy implementation for x86_64 Summary: The patch is not ready yet and is here to discuss a few options: - How do we customize the implementation? (i.e. how to define `kRepMovsBSize`), - How do we specify custom compilation flags? (We'd need `-fno-builtin-memcpy` to be passed in), - How do we build? We may want to test in debug but build the libc with `-march=native` for instance, - Clang has a brand new builtin `__builtin_memcpy_inline` which makes the implementation easy and efficient, but: - If we compile with `gcc` or `msvc` we can't use it, resorting on less efficient code generation, - With gcc we can use `__builtin_memcpy` but then we'd need a postprocess step to check that the final assembly do not contain call to `memcpy` (unlikely but allowed), - For msvc we'd need to resort on the compiler optimization passes. Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits, courbet Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74397
2020-02-11 20:37:02 +08:00
# ------------------------------------------------------------------------------
[libc] Add CMake script to check host cpu features Summary: Tested on MacOSX and Linux. For robustness we can go the OpenCV way and add individual c++ files with intrinsics. https://github.com/opencv/opencv/blob/master/cmake/checks/cpu_avx2.cpp Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74897
2020-02-20 22:00:45 +08:00
[libc] Simplifies multi implementations This is a roll forward of D101895 with two additional fixes: Original Patch description: > This is a follow up on D101524 which: > > - simplifies cpu features detection and usage, > - flattens target dependent optimizations so it's obvious which implementations are generated, > - provides an implementation targeting the host (march/mtune=native) for the mem* functions, > - makes sure all implementations are unittested (provided the host can run them). Additional fixes: - Fix uninitialized ALL_CPU_FEATURES - Use non pseudo microarch as it is only supported from Clang 12 on Differential Revision: https://reviews.llvm.org/D102233
2021-05-12 15:24:53 +08:00
# Initialize ALL_CPU_FEATURES as empty list.
set(ALL_CPU_FEATURES "")
[libc] Normalize LIBC_TARGET_MACHINE Current implementation defines LIBC_TARGET_MACHINE with the use of CMAKE_SYSTEM_PROCESSOR. Unfortunately CMAKE_SYSTEM_PROCESSOR is OS dependent and can produce different results. An evidence of this is the various matchers used to detect whether the architecture is x86. This patch normalizes LIBC_TARGET_MACHINE and renames it LIBC_TARGET_ARCHITECTURE. I've added many architectures but we may want to limit ourselves to x86 and ARM. Differential Revision: https://reviews.llvm.org/D101524
2021-05-05 23:52:42 +08:00
if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
[libc] Automatically add -mfma flag for architectures supporting FMA. Detect if the architecture supports FMA instructions and if the targets depend on fma. Reviewed By: gchatelet Differential Revision: https://reviews.llvm.org/D123615
2022-05-09 01:47:08 +08:00
set(ALL_CPU_FEATURES SSE2 SSE4_2 AVX2 AVX512F FMA)
[libc] Simplifies multi implementations This is a roll forward of D101895 with two additional fixes: Original Patch description: > This is a follow up on D101524 which: > > - simplifies cpu features detection and usage, > - flattens target dependent optimizations so it's obvious which implementations are generated, > - provides an implementation targeting the host (march/mtune=native) for the mem* functions, > - makes sure all implementations are unittested (provided the host can run them). Additional fixes: - Fix uninitialized ALL_CPU_FEATURES - Use non pseudo microarch as it is only supported from Clang 12 on Differential Revision: https://reviews.llvm.org/D102233
2021-05-12 15:24:53 +08:00
set(LIBC_COMPILE_OPTIONS_NATIVE -march=native)
elseif(${LIBC_TARGET_ARCHITECTURE_IS_AARCH64})
set(LIBC_COMPILE_OPTIONS_NATIVE -mcpu=native)
[libc] Add CMake script to check host cpu features Summary: Tested on MacOSX and Linux. For robustness we can go the OpenCV way and add individual c++ files with intrinsics. https://github.com/opencv/opencv/blob/master/cmake/checks/cpu_avx2.cpp Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74897
2020-02-20 22:00:45 +08:00
endif()
[libc] Simplifies multi implementations This is a roll forward of D101895 with two additional fixes: Original Patch description: > This is a follow up on D101524 which: > > - simplifies cpu features detection and usage, > - flattens target dependent optimizations so it's obvious which implementations are generated, > - provides an implementation targeting the host (march/mtune=native) for the mem* functions, > - makes sure all implementations are unittested (provided the host can run them). Additional fixes: - Fix uninitialized ALL_CPU_FEATURES - Use non pseudo microarch as it is only supported from Clang 12 on Differential Revision: https://reviews.llvm.org/D102233
2021-05-12 15:24:53 +08:00
# Making sure ALL_CPU_FEATURES is sorted.
list(SORT ALL_CPU_FEATURES)
[CMake][libc] Don't do CPU feature detection when cross-compiling We won't be able to run the compiled program since it will be compiled for different system. We instead allow passing the CPU features via CMake option in that case. Differential Revision: https://reviews.llvm.org/D95203
2021-01-22 13:21:48 +08:00
# Function to check whether the target CPU supports the provided set of features.
[libc] Adding memcpy implementation for x86_64 Summary: The patch is not ready yet and is here to discuss a few options: - How do we customize the implementation? (i.e. how to define `kRepMovsBSize`), - How do we specify custom compilation flags? (We'd need `-fno-builtin-memcpy` to be passed in), - How do we build? We may want to test in debug but build the libc with `-march=native` for instance, - Clang has a brand new builtin `__builtin_memcpy_inline` which makes the implementation easy and efficient, but: - If we compile with `gcc` or `msvc` we can't use it, resorting on less efficient code generation, - With gcc we can use `__builtin_memcpy` but then we'd need a postprocess step to check that the final assembly do not contain call to `memcpy` (unlikely but allowed), - For msvc we'd need to resort on the compiler optimization passes. Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits, courbet Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74397
2020-02-11 20:37:02 +08:00
# Usage:
[CMake][libc] Don't do CPU feature detection when cross-compiling We won't be able to run the compiled program since it will be compiled for different system. We instead allow passing the CPU features via CMake option in that case. Differential Revision: https://reviews.llvm.org/D95203
2021-01-22 13:21:48 +08:00
# cpu_supports(
[libc] Adding memcpy implementation for x86_64 Summary: The patch is not ready yet and is here to discuss a few options: - How do we customize the implementation? (i.e. how to define `kRepMovsBSize`), - How do we specify custom compilation flags? (We'd need `-fno-builtin-memcpy` to be passed in), - How do we build? We may want to test in debug but build the libc with `-march=native` for instance, - Clang has a brand new builtin `__builtin_memcpy_inline` which makes the implementation easy and efficient, but: - If we compile with `gcc` or `msvc` we can't use it, resorting on less efficient code generation, - With gcc we can use `__builtin_memcpy` but then we'd need a postprocess step to check that the final assembly do not contain call to `memcpy` (unlikely but allowed), - For msvc we'd need to resort on the compiler optimization passes. Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits, courbet Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74397
2020-02-11 20:37:02 +08:00
# <output variable>
# <list of cpu features>
# )
[CMake][libc] Don't do CPU feature detection when cross-compiling We won't be able to run the compiled program since it will be compiled for different system. We instead allow passing the CPU features via CMake option in that case. Differential Revision: https://reviews.llvm.org/D95203
2021-01-22 13:21:48 +08:00
function(cpu_supports output_var features)
_intersection(var "${LIBC_CPU_FEATURES}" "${features}")
if("${var}" STREQUAL "${features}")
[libc] Adding memcpy implementation for x86_64 Summary: The patch is not ready yet and is here to discuss a few options: - How do we customize the implementation? (i.e. how to define `kRepMovsBSize`), - How do we specify custom compilation flags? (We'd need `-fno-builtin-memcpy` to be passed in), - How do we build? We may want to test in debug but build the libc with `-march=native` for instance, - Clang has a brand new builtin `__builtin_memcpy_inline` which makes the implementation easy and efficient, but: - If we compile with `gcc` or `msvc` we can't use it, resorting on less efficient code generation, - With gcc we can use `__builtin_memcpy` but then we'd need a postprocess step to check that the final assembly do not contain call to `memcpy` (unlikely but allowed), - For msvc we'd need to resort on the compiler optimization passes. Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits, courbet Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74397
2020-02-11 20:37:02 +08:00
set(${output_var} TRUE PARENT_SCOPE)
else()
unset(${output_var} PARENT_SCOPE)
endif()
endfunction()
# ------------------------------------------------------------------------------
# Internal helpers and utilities.
# ------------------------------------------------------------------------------
[libc] Add CMake script to check host cpu features Summary: Tested on MacOSX and Linux. For robustness we can go the OpenCV way and add individual c++ files with intrinsics. https://github.com/opencv/opencv/blob/master/cmake/checks/cpu_avx2.cpp Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74897
2020-02-20 22:00:45 +08:00
[libc] Adding memcpy implementation for x86_64 Summary: The patch is not ready yet and is here to discuss a few options: - How do we customize the implementation? (i.e. how to define `kRepMovsBSize`), - How do we specify custom compilation flags? (We'd need `-fno-builtin-memcpy` to be passed in), - How do we build? We may want to test in debug but build the libc with `-march=native` for instance, - Clang has a brand new builtin `__builtin_memcpy_inline` which makes the implementation easy and efficient, but: - If we compile with `gcc` or `msvc` we can't use it, resorting on less efficient code generation, - With gcc we can use `__builtin_memcpy` but then we'd need a postprocess step to check that the final assembly do not contain call to `memcpy` (unlikely but allowed), - For msvc we'd need to resort on the compiler optimization passes. Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits, courbet Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74397
2020-02-11 20:37:02 +08:00
# Computes the intersection between two lists.
function(_intersection output_var list1 list2)
foreach(element IN LISTS list1)
if("${list2}" MATCHES "(^|;)${element}(;|$)")
list(APPEND tmp "${element}")
[libc] Add CMake script to check host cpu features Summary: Tested on MacOSX and Linux. For robustness we can go the OpenCV way and add individual c++ files with intrinsics. https://github.com/opencv/opencv/blob/master/cmake/checks/cpu_avx2.cpp Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74897
2020-02-20 22:00:45 +08:00
endif()
endforeach()
[libc] Adding memcpy implementation for x86_64 Summary: The patch is not ready yet and is here to discuss a few options: - How do we customize the implementation? (i.e. how to define `kRepMovsBSize`), - How do we specify custom compilation flags? (We'd need `-fno-builtin-memcpy` to be passed in), - How do we build? We may want to test in debug but build the libc with `-march=native` for instance, - Clang has a brand new builtin `__builtin_memcpy_inline` which makes the implementation easy and efficient, but: - If we compile with `gcc` or `msvc` we can't use it, resorting on less efficient code generation, - With gcc we can use `__builtin_memcpy` but then we'd need a postprocess step to check that the final assembly do not contain call to `memcpy` (unlikely but allowed), - For msvc we'd need to resort on the compiler optimization passes. Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits, courbet Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74397
2020-02-11 20:37:02 +08:00
set(${output_var} ${tmp} PARENT_SCOPE)
[libc] Add CMake script to check host cpu features Summary: Tested on MacOSX and Linux. For robustness we can go the OpenCV way and add individual c++ files with intrinsics. https://github.com/opencv/opencv/blob/master/cmake/checks/cpu_avx2.cpp Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74897
2020-02-20 22:00:45 +08:00
endfunction()
[libc] Adding memcpy implementation for x86_64 Summary: The patch is not ready yet and is here to discuss a few options: - How do we customize the implementation? (i.e. how to define `kRepMovsBSize`), - How do we specify custom compilation flags? (We'd need `-fno-builtin-memcpy` to be passed in), - How do we build? We may want to test in debug but build the libc with `-march=native` for instance, - Clang has a brand new builtin `__builtin_memcpy_inline` which makes the implementation easy and efficient, but: - If we compile with `gcc` or `msvc` we can't use it, resorting on less efficient code generation, - With gcc we can use `__builtin_memcpy` but then we'd need a postprocess step to check that the final assembly do not contain call to `memcpy` (unlikely but allowed), - For msvc we'd need to resort on the compiler optimization passes. Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits, courbet Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74397
2020-02-11 20:37:02 +08:00
# Generates a cpp file to introspect the compiler defined flags.
function(_generate_check_code)
foreach(feature IN LISTS ALL_CPU_FEATURES)
set(DEFINITIONS
"${DEFINITIONS}
#ifdef __${feature}__
\"${feature}\",
#endif")
[libc] Add CMake script to check host cpu features Summary: Tested on MacOSX and Linux. For robustness we can go the OpenCV way and add individual c++ files with intrinsics. https://github.com/opencv/opencv/blob/master/cmake/checks/cpu_avx2.cpp Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74897
2020-02-20 22:00:45 +08:00
endforeach()
[libc] Adding memcpy implementation for x86_64 Summary: The patch is not ready yet and is here to discuss a few options: - How do we customize the implementation? (i.e. how to define `kRepMovsBSize`), - How do we specify custom compilation flags? (We'd need `-fno-builtin-memcpy` to be passed in), - How do we build? We may want to test in debug but build the libc with `-march=native` for instance, - Clang has a brand new builtin `__builtin_memcpy_inline` which makes the implementation easy and efficient, but: - If we compile with `gcc` or `msvc` we can't use it, resorting on less efficient code generation, - With gcc we can use `__builtin_memcpy` but then we'd need a postprocess step to check that the final assembly do not contain call to `memcpy` (unlikely but allowed), - For msvc we'd need to resort on the compiler optimization passes. Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits, courbet Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74397
2020-02-11 20:37:02 +08:00
configure_file(
"${LIBC_SOURCE_DIR}/cmake/modules/cpu_features/check_cpu_features.cpp.in"
"cpu_features/check_cpu_features.cpp" @ONLY)
[libc] Add CMake script to check host cpu features Summary: Tested on MacOSX and Linux. For robustness we can go the OpenCV way and add individual c++ files with intrinsics. https://github.com/opencv/opencv/blob/master/cmake/checks/cpu_avx2.cpp Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74897
2020-02-20 22:00:45 +08:00
endfunction()
[libc] Adding memcpy implementation for x86_64 Summary: The patch is not ready yet and is here to discuss a few options: - How do we customize the implementation? (i.e. how to define `kRepMovsBSize`), - How do we specify custom compilation flags? (We'd need `-fno-builtin-memcpy` to be passed in), - How do we build? We may want to test in debug but build the libc with `-march=native` for instance, - Clang has a brand new builtin `__builtin_memcpy_inline` which makes the implementation easy and efficient, but: - If we compile with `gcc` or `msvc` we can't use it, resorting on less efficient code generation, - With gcc we can use `__builtin_memcpy` but then we'd need a postprocess step to check that the final assembly do not contain call to `memcpy` (unlikely but allowed), - For msvc we'd need to resort on the compiler optimization passes. Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits, courbet Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74397
2020-02-11 20:37:02 +08:00
_generate_check_code()
[libc] Add CMake script to check host cpu features Summary: Tested on MacOSX and Linux. For robustness we can go the OpenCV way and add individual c++ files with intrinsics. https://github.com/opencv/opencv/blob/master/cmake/checks/cpu_avx2.cpp Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74897
2020-02-20 22:00:45 +08:00
[libc] Simplifies multi implementations This is a roll forward of D101895 with two additional fixes: Original Patch description: > This is a follow up on D101524 which: > > - simplifies cpu features detection and usage, > - flattens target dependent optimizations so it's obvious which implementations are generated, > - provides an implementation targeting the host (march/mtune=native) for the mem* functions, > - makes sure all implementations are unittested (provided the host can run them). Additional fixes: - Fix uninitialized ALL_CPU_FEATURES - Use non pseudo microarch as it is only supported from Clang 12 on Differential Revision: https://reviews.llvm.org/D102233
2021-05-12 15:24:53 +08:00
set(LIBC_CPU_FEATURES "" CACHE PATH "Host supported CPU features")
if(CMAKE_CROSSCOMPILING)
_intersection(cpu_features "${ALL_CPU_FEATURES}" "${LIBC_CPU_FEATURES}")
if(NOT "${cpu_features}" STREQUAL "${LIBC_CPU_FEATURES}")
message(FATAL_ERROR "Unsupported CPU features: ${cpu_features}")
endif()
[libc] Automatically add -mfma flag for architectures supporting FMA. Detect if the architecture supports FMA instructions and if the targets depend on fma. Reviewed By: gchatelet Differential Revision: https://reviews.llvm.org/D123615
2022-05-09 01:47:08 +08:00
message(STATUS "Set CPU features: ${cpu_features}")
[libc] Simplifies multi implementations This is a roll forward of D101895 with two additional fixes: Original Patch description: > This is a follow up on D101524 which: > > - simplifies cpu features detection and usage, > - flattens target dependent optimizations so it's obvious which implementations are generated, > - provides an implementation targeting the host (march/mtune=native) for the mem* functions, > - makes sure all implementations are unittested (provided the host can run them). Additional fixes: - Fix uninitialized ALL_CPU_FEATURES - Use non pseudo microarch as it is only supported from Clang 12 on Differential Revision: https://reviews.llvm.org/D102233
2021-05-12 15:24:53 +08:00
set(LIBC_CPU_FEATURES "${cpu_features}")
else()
# Populates the LIBC_CPU_FEATURES list from host.
[libc] Add CMake script to check host cpu features Summary: Tested on MacOSX and Linux. For robustness we can go the OpenCV way and add individual c++ files with intrinsics. https://github.com/opencv/opencv/blob/master/cmake/checks/cpu_avx2.cpp Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74897
2020-02-20 22:00:45 +08:00
try_run(
[libc] Adding memcpy implementation for x86_64 Summary: The patch is not ready yet and is here to discuss a few options: - How do we customize the implementation? (i.e. how to define `kRepMovsBSize`), - How do we specify custom compilation flags? (We'd need `-fno-builtin-memcpy` to be passed in), - How do we build? We may want to test in debug but build the libc with `-march=native` for instance, - Clang has a brand new builtin `__builtin_memcpy_inline` which makes the implementation easy and efficient, but: - If we compile with `gcc` or `msvc` we can't use it, resorting on less efficient code generation, - With gcc we can use `__builtin_memcpy` but then we'd need a postprocess step to check that the final assembly do not contain call to `memcpy` (unlikely but allowed), - For msvc we'd need to resort on the compiler optimization passes. Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits, courbet Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74397
2020-02-11 20:37:02 +08:00
run_result compile_result "${CMAKE_CURRENT_BINARY_DIR}/check_${feature}"
"${CMAKE_CURRENT_BINARY_DIR}/cpu_features/check_cpu_features.cpp"
[libc] Simplifies multi implementations This is a roll forward of D101895 with two additional fixes: Original Patch description: > This is a follow up on D101524 which: > > - simplifies cpu features detection and usage, > - flattens target dependent optimizations so it's obvious which implementations are generated, > - provides an implementation targeting the host (march/mtune=native) for the mem* functions, > - makes sure all implementations are unittested (provided the host can run them). Additional fixes: - Fix uninitialized ALL_CPU_FEATURES - Use non pseudo microarch as it is only supported from Clang 12 on Differential Revision: https://reviews.llvm.org/D102233
2021-05-12 15:24:53 +08:00
COMPILE_DEFINITIONS ${LIBC_COMPILE_OPTIONS_NATIVE}
[libc] Adding memcpy implementation for x86_64 Summary: The patch is not ready yet and is here to discuss a few options: - How do we customize the implementation? (i.e. how to define `kRepMovsBSize`), - How do we specify custom compilation flags? (We'd need `-fno-builtin-memcpy` to be passed in), - How do we build? We may want to test in debug but build the libc with `-march=native` for instance, - Clang has a brand new builtin `__builtin_memcpy_inline` which makes the implementation easy and efficient, but: - If we compile with `gcc` or `msvc` we can't use it, resorting on less efficient code generation, - With gcc we can use `__builtin_memcpy` but then we'd need a postprocess step to check that the final assembly do not contain call to `memcpy` (unlikely but allowed), - For msvc we'd need to resort on the compiler optimization passes. Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits, courbet Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74397
2020-02-11 20:37:02 +08:00
COMPILE_OUTPUT_VARIABLE compile_output
RUN_OUTPUT_VARIABLE run_output)
[libc] Distinguish compiler and run failures This is useful for debugging issues, for example when cross-compiling. Differential Revision: https://reviews.llvm.org/D95118
2021-01-21 16:01:18 +08:00
if("${run_result}" EQUAL 0)
[libc] Automatically add -mfma flag for architectures supporting FMA. Detect if the architecture supports FMA instructions and if the targets depend on fma. Reviewed By: gchatelet Differential Revision: https://reviews.llvm.org/D123615
2022-05-09 01:47:08 +08:00
message(STATUS "Set CPU features: ${run_output}")
[libc] Simplifies multi implementations This is a roll forward of D101895 with two additional fixes: Original Patch description: > This is a follow up on D101524 which: > > - simplifies cpu features detection and usage, > - flattens target dependent optimizations so it's obvious which implementations are generated, > - provides an implementation targeting the host (march/mtune=native) for the mem* functions, > - makes sure all implementations are unittested (provided the host can run them). Additional fixes: - Fix uninitialized ALL_CPU_FEATURES - Use non pseudo microarch as it is only supported from Clang 12 on Differential Revision: https://reviews.llvm.org/D102233
2021-05-12 15:24:53 +08:00
set(LIBC_CPU_FEATURES "${run_output}")
[libc] Distinguish compiler and run failures This is useful for debugging issues, for example when cross-compiling. Differential Revision: https://reviews.llvm.org/D95118
2021-01-21 16:01:18 +08:00
elseif(NOT ${compile_result})
message(FATAL_ERROR "Failed to compile: ${compile_output}")
[libc] Adding memcpy implementation for x86_64 Summary: The patch is not ready yet and is here to discuss a few options: - How do we customize the implementation? (i.e. how to define `kRepMovsBSize`), - How do we specify custom compilation flags? (We'd need `-fno-builtin-memcpy` to be passed in), - How do we build? We may want to test in debug but build the libc with `-march=native` for instance, - Clang has a brand new builtin `__builtin_memcpy_inline` which makes the implementation easy and efficient, but: - If we compile with `gcc` or `msvc` we can't use it, resorting on less efficient code generation, - With gcc we can use `__builtin_memcpy` but then we'd need a postprocess step to check that the final assembly do not contain call to `memcpy` (unlikely but allowed), - For msvc we'd need to resort on the compiler optimization passes. Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits, courbet Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74397
2020-02-11 20:37:02 +08:00
else()
[libc] Distinguish compiler and run failures This is useful for debugging issues, for example when cross-compiling. Differential Revision: https://reviews.llvm.org/D95118
2021-01-21 16:01:18 +08:00
message(FATAL_ERROR "Failed to run: ${run_output}")
[libc] Add CMake script to check host cpu features Summary: Tested on MacOSX and Linux. For robustness we can go the OpenCV way and add individual c++ files with intrinsics. https://github.com/opencv/opencv/blob/master/cmake/checks/cpu_avx2.cpp Reviewers: sivachandra, abrachet Subscribers: mgorny, MaskRay, tschuett, libc-commits Tags: #libc-project Differential Revision: https://reviews.llvm.org/D74897
2020-02-20 22:00:45 +08:00
endif()
[libc][NFC] Make cpu feature check tolerate non-x86 architectures. The feature check should probably be enhanced for non-x86 architectures, but this change shields them from x86 specific pieces until then. This patch has been split out from https://reviews.llvm.org/D81533.
2020-06-11 01:55:00 +08:00
endif()