[libc] Simplifies multi implementations

[gchatelet]

Summary

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).

[gchatelet]

use D101524 as base revision

[gchatelet]

• revert local change

[gchatelet]

rebasing

[gchatelet]

• Differ changes to the benchmarking system to a later patch

[gchatelet]

• Differ changes to the benchmarking system to a later patch (for real)

[gchatelet]

• Amending commit to reflect the change (hopefully)

[gchatelet]

• One more time

[avieira]

LGTM otherwise.

libc/cmake/modules/LLVMLibCCheckCpuFeatures.cmake

8

I'd really use -mcpu here though, as it will also enable available features.

[gchatelet]

This is now ready for review (sorry for the many updates)

@sivachandra with this patch we now produce a memcpy_opt_host (resp. memset_opt_host, bzero_opt_host) variant that compiles to the host native architecture in addition to the memcpy, memset, bzero functions that compiles to the compiler default architecture.

I think we have the following scenarios:

• we compile a release and we want to specify which target to compile for (right now this is what the compiler decide is the default).
• we compile a release via cross compilation (ARM compiled on x86 or vice versa), so we want to explicitly specify which arch to target.
• we want to run benchmarks on a specific machine and want it to leverage -march/-mtune = native.

[gchatelet]

• Use mcpu instead of mtune for ARM

[avieira]

libc/src/string/CMakeLists.txt

233

During some of my experiments I learned that CMAKE prefers if you pass such options with "SHELL:-mllvm --tail-mege-threshold=0" just in case there is another '-mllvm opt' or '-A B' like option.

Having said this, I am not seeing (with either SHELL or not) this option being passed when I do `ninja libc-benchmark-main -v -v', but don't quote me on this just yet, I might need to update all the patches you've put up for review.

Any chance you can verify you are seeing the same on your side?

[gchatelet]

libc/src/string/CMakeLists.txt

233

I confirm that it does not work : D
For one, I need to remove the double quotes, then SHELL does not seem to work.
I'm looking into it and will provide an update shortly.

[gchatelet]

libc/src/string/CMakeLists.txt

233

So the proper way to do it is to double quote AND use SHELL at the same time, e.g.

add_memcpy(memcpy COMPILE_OPTIONS "SHELL:-mllvm --tail-merge-threshold=0"
                  COMPILE_OPTIONS "SHELL:-mllvm --combiner-global-alias-analysis")

If SHELL is not provided we should not double quote. I'll update the patch soonish.

[gchatelet]

• Fix CMake flag deduplication issue

[sivachandra]

Overall LGTM. I have few questions I want to get clarity on.

I think we have the following scenarios:

• we compile a release and we want to specify which target to compile for (right now this is what the compiler decide is the default).

In other words, when compiling for the host, we will let the compiler decide the best options?

• we compile a release via cross compilation (ARM compiled on x86 or vice versa), so we want to explicitly specify which arch to target.

In other words, when cross-compiling, we will have to specify certain CMake vars explicitly?

• we want to run benchmarks on a specific machine and want it to leverage -march/-mtune = native.

Does it mean that benchmarks are always compiled for the host?

[gchatelet]

In D101895#2742165, @sivachandra wrote:

I think we have the following scenarios:

• we compile a release and we want to specify which target to compile for (right now this is what the compiler decide is the default).

In other words, when compiling for the host, we will let the compiler decide the best options?

Compiling for the host means using -march=native / -mcpu=native. Here I'm just talking about compiling llvm-libc without any options.
That is: when doing a full build, what is the targeted architecture?
AFAIU right now, the compiler decides. With a new version of the compiler the default may change and the targeted architecture as well.
It may be best to explicitly say "I want to compile llvm-libc for haswell when on x86".
AFAICT compilers are being very conservative and by default you get SSE2 only for x86 (check predefined macros without specifying march).

This is the rationale behind https://reviews.llvm.org/D101991

• we compile a release via cross compilation (ARM compiled on x86 or vice versa), so we want to explicitly specify which arch to target.

In other words, when cross-compiling, we will have to specify certain CMake vars explicitly?

Yes as for the previous bullet point I believe.
You always want to specify what you are targeting.

• we want to run benchmarks on a specific machine and want it to leverage -march/-mtune = native.

Does it mean that benchmarks are always compiled for the host?

We want to be able to benchmark all the implementations, presumably the host one will perform best.
I removed this part from the patch but we will provide one benchmark per function and per implementation so people can easily test and compare them out.

[sivachandra]

Thanks for explaining.

[gchatelet]

I'll wait for D101991 before submitting this one.

[sivachandra]

Unfortunately, I had to revert this as the bots were failing like this: https://lab.llvm.org/buildbot/#/builders/78/builds/11551.
I looked around for a bit to see if I can fix forward, but I do not think I know enough about the various x86_64 arch names. May be -march=k8 is all we need, but I will let you decide what the best course of action is.

[sivachandra]

This change also triggers a failure on the aarch64 bots like this: https://lab.llvm.org/buildbot/#/builders/138/builds/4761

[gchatelet]

In D101895#2748607, @sivachandra wrote:

Unfortunately, I had to revert this as the bots were failing like this: https://lab.llvm.org/buildbot/#/builders/78/builds/11551.
I looked around for a bit to see if I can fix forward, but I do not think I know enough about the various x86_64 arch names. May be -march=k8 is all we need, but I will let you decide what the best course of action is.

Thx for the revert Siva. I was AFK when I saw the failure.
These pseudo archs are available from Clang 12 on. Do you happen to know which clang version is being used by the buildbot?
We can target more genuine architectures instead, that said those pseudo arch better capture the requirements.

[sivachandra]

In D101895#2748627, @gchatelet wrote:

Do you happen to know which clang version is being used by the buildbot?

The builders use clang-7 but I am working on upgrading them to clang-11. If you think clang-12 would be ideal, I can try getting it up to clang-12. I will try now and report back here.

[gchatelet]

In D101895#2748625, @sivachandra wrote:

This change also triggers a failure on the aarch64 bots like this: https://lab.llvm.org/buildbot/#/builders/138/builds/4761

Where can I see the real error? I can't find it on the page you linked in. All I can find is the python executor error which is not helpful :-/
Also, I'm puzzled as to why the failures triggers right now, the patch has been sent more than 9h ago.

[sivachandra]

In D101895#2748649, @gchatelet wrote:

Where can I see the real error? I can't find it on the page you linked in. All I can find is the python executor error which is not helpful :-/
Also, I'm puzzled as to why the failures triggers right now, the patch has been sent more than 9h ago.

Yes, the timing of the x86_64 failures confused me as well. The aarch64 bot dropped off the network over the weekend so I had to bring it back up. I noticed the failure as soon as I brought it up. About the full failure, if you click on the stdio links on the build page, it will take you to the full log like this: https://lab.llvm.org/buildbot/#/builders/138/builds/4761/steps/4/logs/stdio.

[sivachandra]

In D101895#2748640, @sivachandra wrote:

The builders use clang-7 but I am working on upgrading them to clang-11. If you think clang-12 would be ideal, I can try getting it up to clang-12. I will try now and report back here.

There is no easy way to go to clang-12. Can we work with clang-11? I will try to move to clang-11 now.

[gchatelet]

In D101895#2748666, @sivachandra wrote:

In D101895#2748649, @gchatelet wrote:

Where can I see the real error? I can't find it on the page you linked in. All I can find is the python executor error which is not helpful :-/
Also, I'm puzzled as to why the failures triggers right now, the patch has been sent more than 9h ago.

Yes, the timing of the x86_64 failures confused me as well. The aarch64 bot dropped off the network over the weekend so I had to bring it back up. I noticed the failure as soon as I brought it up. About the full failure, if you click on the stdio links on the build page, it will take you to the full log like this: https://lab.llvm.org/buildbot/#/builders/138/builds/4761/steps/4/logs/stdio.

Thank you! I'll create a separate patch with the roll forward and the fixes for both aarch64 and x86.

[gchatelet]

In D101895#2748691, @sivachandra wrote:

In D101895#2748640, @sivachandra wrote:

The builders use clang-7 but I am working on upgrading them to clang-11. If you think clang-12 would be ideal, I can try getting it up to clang-12. I will try now and report back here.

There is no easy way to go to clang-12. Can we work with clang-11? I will try to move to clang-11 now.

Yes it's fine, I'll use a different scheme, I think it's better to stick to what's broadly available. thx 👍

libc/CMakeLists.txt

 # Path libc/scripts directory.
 set(LIBC_BUILD_SCRIPTS_DIR "${LIBC_SOURCE_DIR}/utils/build_scripts")
 
 set(LIBC_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX} CACHE PATH "Define libc destination prefix.")
 
 set(LIBC_TARGET_OS ${CMAKE_SYSTEM_NAME})
 string(TOLOWER ${LIBC_TARGET_OS} LIBC_TARGET_OS)
 
-set(LIBC_TARGET_MACHINE ${CMAKE_SYSTEM_PROCESSOR})
+# Defines LIBC_TARGET_ARCHITECTURE and associated macros.
+include(LLVMLibCArchitectures)
 
 # Check --print-resource-dir to find the compiler resource dir if this flag
 # is supported by the compiler.
 execute_process(
   OUTPUT_STRIP_TRAILING_WHITESPACE
   COMMAND ${CMAKE_CXX_COMPILER} --print-resource-dir
   RESULT_VARIABLE COMMAND_RETURN_CODE
   OUTPUT_VARIABLE COMPILER_RESOURCE_DIR
message(WARNING "
     This is not recommended, to enable set LLVM_LIBC_ENABLE_LINTING to ON
     (pass -DLLVM_LIBC_ENABLE_LINTING=ON to cmake).")
 endif()
 
 include(CMakeParseArguments)
 include(LLVMLibCRules)
 include(LLVMLibCCheckCpuFeatures)
 
-include("${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/${LIBC_TARGET_MACHINE}/entrypoints.txt")
-include("${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/${LIBC_TARGET_MACHINE}/headers.txt")
+include("${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/${LIBC_TARGET_ARCHITECTURE}/entrypoints.txt")
+include("${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/${LIBC_TARGET_ARCHITECTURE}/headers.txt")
 
 set(TARGET_ENTRYPOINT_NAME_LIST "")
 foreach(entrypoint IN LISTS TARGET_LLVMLIBC_ENTRYPOINTS)
   string(FIND ${entrypoint} "." last_dot_loc REVERSE)
   if(${last_dot_loc} EQUAL -1)
     message(FATAL "Invalid entrypoint target name ${entrypoint}; Expected a '.' "
                   "(dot) in the name.")
   endif()

libc/benchmarks/CMakeLists.txt

add_libc_benchmark_unittest(json-test
     SRCS JSONTest.cpp
     DEPENDS json
 )
 
 #==============================================================================
 # Benchmarking tool
 #==============================================================================
 
-add_executable(libc-benchmark-main
+# Benchmark all implementations that can run on the target CPU.
+function(add_libc_multi_impl_benchmark name)
+  get_property(fq_implementations GLOBAL PROPERTY ${name}_implementations)
+  foreach(fq_config_name IN LISTS fq_implementations)
+    get_target_property(required_cpu_features ${fq_config_name} REQUIRE_CPU_FEATURES)
+    cpu_supports(can_run "${required_cpu_features}")
+    if(can_run)
+        set(benchmark_name ${fq_config_name}_benchmark)
+        add_executable(${benchmark_name}
             EXCLUDE_FROM_ALL
             LibcMemoryBenchmarkMain.cpp
         )
-foreach(entrypoint_target libc.src.string.memcpy libc.src.string.memset)
-    get_target_property(entrypoint_object_file ${entrypoint_target} "OBJECT_FILE_RAW")
-    target_link_libraries(libc-benchmark-main PUBLIC json ${entrypoint_object_file})
+        get_target_property(entrypoint_object_file ${fq_config_name} "OBJECT_FILE_RAW")
+        target_link_libraries(${benchmark_name} PUBLIC json ${entrypoint_object_file})
+        string(TOUPPER ${name} name_upper)
+        target_compile_definitions(${benchmark_name} PRIVATE "-DLIBC_BENCHMARK_FUNCTION_${name_upper}=1" "-DLIBC_BENCHMARK_FUNCTION_NAME=\"${fq_config_name}\"")
+    else()
+      message(STATUS "Skipping benchmark for '${fq_config_name}' insufficient host cpu features '${required_cpu_features}'")
+    endif()
   endforeach()
+endfunction()
+
+add_libc_multi_impl_benchmark(memcpy)
+add_libc_multi_impl_benchmark(memset)

libc/benchmarks/LibcMemoryBenchmarkMain.cpp

 extern void *memcpy(void *__restrict, const void *__restrict, size_t);
 extern void *memset(void *, int, size_t);
 
 } // namespace __llvm_libc
 
 namespace llvm {
 namespace libc_benchmarks {
 
-enum Function { memcpy, memset };
-
 static cl::opt<std::string>
     StudyName("study-name", cl::desc("The name for this study"), cl::Required);
 
-static cl::opt<Function>
-    MemoryFunction("function", cl::desc("Sets the function to benchmark:"),
-                   cl::values(clEnumVal(memcpy, "__llvm_libc::memcpy"),
-                              clEnumVal(memset, "__llvm_libc::memset")),
-                   cl::Required);
-
 static cl::opt<std::string>
     SizeDistributionName("size-distribution-name",
                          cl::desc("The name of the distribution to use"));
 
 static cl::opt<bool>
     SweepMode("sweep-mode",
               cl::desc("If set, benchmark all sizes from 0 to sweep-max-size"));
 

 static constexpr int64_t ParameterStorageBytes = 4 * KiB;
 static constexpr int64_t L1LeftAsideBytes = 1 * KiB;
 
 struct ParameterType {
   unsigned OffsetBytes : 16; // max : 16 KiB - 1
   unsigned SizeBytes : 16;   // max : 16 KiB - 1
 };
 
-struct MemcpyBenchmark {
+#if defined(LIBC_BENCHMARK_FUNCTION_MEMCPY)
+struct Benchmark {
   static constexpr auto GetDistributions = &getMemcpySizeDistributions;
   static constexpr size_t BufferCount = 2;
-  static void amend(Study &S) { S.Configuration.Function = "memcpy"; }
 
-  MemcpyBenchmark(const size_t BufferSize)
+  Benchmark(const size_t BufferSize)
       : SrcBuffer(BufferSize), DstBuffer(BufferSize) {}
 
   inline auto functor() {
     return [this](ParameterType P) {
       __llvm_libc::memcpy(DstBuffer + P.OffsetBytes, SrcBuffer + P.OffsetBytes,
                           P.SizeBytes);
       return DstBuffer + P.OffsetBytes;
     };
   }
 
   AlignedBuffer SrcBuffer;
   AlignedBuffer DstBuffer;
 };
-
-struct MemsetBenchmark {
+#elif defined(LIBC_BENCHMARK_FUNCTION_MEMSET)
+struct Benchmark {
   static constexpr auto GetDistributions = &getMemsetSizeDistributions;
   static constexpr size_t BufferCount = 1;
-  static void amend(Study &S) { S.Configuration.Function = "memset"; }
 
-  MemsetBenchmark(const size_t BufferSize) : DstBuffer(BufferSize) {}
+  Benchmark(const size_t BufferSize) : DstBuffer(BufferSize) {}
 
   inline auto functor() {
     return [this](ParameterType P) {
       __llvm_libc::memset(DstBuffer + P.OffsetBytes, P.OffsetBytes & 0xFF,
                           P.SizeBytes);
       return DstBuffer + P.OffsetBytes;
     };
   }
 
   AlignedBuffer DstBuffer;
 };
+#else
+#error "Missing LIBC_BENCHMARK_FUNCTION_XXX definition"
+#endif
 
-template <typename Benchmark> struct Harness : Benchmark {
+struct Harness : Benchmark {
   using Benchmark::functor;
 
   Harness(const size_t BufferSize, size_t BatchParameterCount,
           std::function<unsigned()> SizeSampler,
           std::function<unsigned()> OffsetSampler)
       : Benchmark(BufferSize), BufferSize(BufferSize),
         Parameters(BatchParameterCount), SizeSampler(SizeSampler),
         OffsetSampler(OffsetSampler) {}

 
 private:
   const size_t BufferSize;
   std::vector<ParameterType> Parameters;
   std::function<unsigned()> SizeSampler;
   std::function<unsigned()> OffsetSampler;
 };
 
-struct IBenchmark {
-  virtual ~IBenchmark() {}
-  virtual Study run() = 0;
-};
-
 size_t getL1DataCacheSize() {
   const std::vector<CacheInfo> &CacheInfos = HostState::get().Caches;
   const auto IsL1DataCache = [](const CacheInfo &CI) {
     return CI.Type == "Data" && CI.Level == 1;
   };
   const auto CacheIt = find_if(CacheInfos, IsL1DataCache);
   if (CacheIt != CacheInfos.end())
     return CacheIt->Size;
   report_fatal_error("Unable to read L1 Cache Data Size");
 }
 
-template <typename Benchmark> struct MemfunctionBenchmark : IBenchmark {
+struct MemfunctionBenchmark {
   MemfunctionBenchmark(int64_t L1Size = getL1DataCacheSize())
       : AvailableSize(L1Size - L1LeftAsideBytes - ParameterStorageBytes),
         BufferSize(AvailableSize / Benchmark::BufferCount),
         BatchParameterCount(BufferSize / sizeof(ParameterType)) {
     // Handling command line flags
     if (AvailableSize <= 0 || BufferSize <= 0 || BatchParameterCount < 100)
       report_fatal_error("Not enough L1 cache");
 
MemfunctionBenchmark(int64_t L1Size = getL1DataCacheSize())
     SC.IsSweepMode = SweepMode;
     if (SweepMode)
       SC.SweepModeMaxSize = SweepMaxSize;
     else
       SC.SizeDistributionName = SizeDistributionName;
     SC.AccessAlignment = MaybeAlign(AlignedAccess);
 
     // Delegate specific flags and configuration.
-    Benchmark::amend(Study);
+    Study.Configuration.Function = LIBC_BENCHMARK_FUNCTION_NAME;
   }
 
-  Study run() override {
+  Study run() {
     if (SweepMode)
       runSweepMode();
     else
       runDistributionMode();
     return Study;
   }
 
 private:
void reportProgress() {
     for (; I <= 100; ++I)
       errs() << '_';
     errs() << "] " << Percent << '%' << '\r';
   }
 
   void runTrials(const BenchmarkOptions &Options,
                  std::function<unsigned()> SizeSampler,
                  std::function<unsigned()> OffsetSampler) {
-    Harness<Benchmark> B(BufferSize, BatchParameterCount, SizeSampler,
-                         OffsetSampler);
+    Harness B(BufferSize, BatchParameterCount, SizeSampler, OffsetSampler);
     for (size_t i = 0; i < NumTrials; ++i) {
       const BenchmarkResult Result = benchmark(Options, B, B.functor());
       Study.Measurements.push_back(Result.BestGuess);
       reportProgress();
     }
   }
 
   void runSweepMode() {
void runDistributionMode() {
     BenchmarkOptions &BO = Study.Runtime.BenchmarkOptions;
     BO.MinDuration = std::chrono::milliseconds(10);
     BO.InitialIterations = BatchParameterCount * 10;
 
     runTrials(BO, getSizeSampler(), geOffsetSampler());
   }
 };
 
-std::unique_ptr<IBenchmark> getMemfunctionBenchmark() {
-  switch (MemoryFunction) {
-  case memcpy:
-    return std::make_unique<MemfunctionBenchmark<MemcpyBenchmark>>();
-  case memset:
-    return std::make_unique<MemfunctionBenchmark<MemsetBenchmark>>();
-  }
-}
-
 void writeStudy(const Study &S) {
   std::error_code EC;
   raw_fd_ostream FOS(Output, EC);
   if (EC)
     report_fatal_error(Twine("Could not open file: ")
                            .concat(EC.message())
                            .concat(", ")
                            .concat(Output));
   json::OStream JOS(FOS);
   serializeToJson(S, JOS);
   FOS << "\n";
 }
 
 void main() {
   checkRequirements();
-  auto MB = getMemfunctionBenchmark();
-  writeStudy(MB->run());
+  MemfunctionBenchmark MB;
+  writeStudy(MB.run());
 }
 
 } // namespace libc_benchmarks
 } // namespace llvm
 
 int main(int argc, char **argv) {
   llvm::cl::ParseCommandLineOptions(argc, argv);
 #ifndef NDEBUG
   static_assert(
       false,
       "For reproducibility benchmarks should not be compiled in DEBUG mode.");
 #endif
   llvm::libc_benchmarks::main();
   return EXIT_SUCCESS;
 }

libc/cmake/modules/LLVMLibCArchitectures.cmake

+# ------------------------------------------------------------------------------
+# Architecture definitions
+# ------------------------------------------------------------------------------
+
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "^mips")
+  set(LIBC_TARGET_ARCHITECTURE_IS_MIPS TRUE)
+  set(LIBC_TARGET_ARCHITECTURE "mips")
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^arm")
+  set(LIBC_TARGET_ARCHITECTURE_IS_ARM TRUE)
+  set(LIBC_TARGET_ARCHITECTURE "arm")
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^aarch64")
+  set(LIBC_TARGET_ARCHITECTURE_IS_AARCH64 TRUE)
+  set(LIBC_TARGET_ARCHITECTURE "aarch64")
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "(x86_64)|(AMD64|amd64)|(^i.86$)")
+  set(LIBC_TARGET_ARCHITECTURE_IS_X86 TRUE)
+  set(LIBC_TARGET_ARCHITECTURE "x86_64")
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)")
+  set(LIBC_TARGET_ARCHITECTURE_IS_POWER TRUE)
+  set(LIBC_TARGET_ARCHITECTURE "power")
+else()
+  message(FATAL_ERROR "Unsupported processor ${CMAKE_SYSTEM_PROCESSOR}")
+endif()

libc/cmake/modules/LLVMLibCCheckCpuFeatures.cmake

 # ------------------------------------------------------------------------------
 # Cpu features definition and flags
 # ------------------------------------------------------------------------------
 
-if(${LIBC_TARGET_MACHINE} MATCHES "x86|x86_64")
-  set(ALL_CPU_FEATURES SSE SSE2 AVX AVX2 AVX512F)
-  list(SORT ALL_CPU_FEATURES)
+if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
+  set(ALL_CPU_FEATURES SSE2 SSE4_2 AVX2 AVX512F)
+  set(LIBC_COMPILE_OPTIONS_NATIVE -march=native)
+elseif(${LIBC_TARGET_ARCHITECTURE_IS_AARCH64})
+  set(LIBC_COMPILE_OPTIONS_NATIVE -mtune=native)
 endif()
 
+list(SORT ALL_CPU_FEATURES)
+
 # Function to check whether the target CPU supports the provided set of features.
 # Usage:
 # cpu_supports(
 #   <output variable>
 #   <list of cpu features>
 # )
 function(cpu_supports output_var features)
   _intersection(var "${LIBC_CPU_FEATURES}" "${features}")
   if("${var}" STREQUAL "${features}")
     set(${output_var} TRUE PARENT_SCOPE)
   else()
     unset(${output_var} PARENT_SCOPE)
   endif()
 endfunction()
 
-# Function to compute the flags to pass down to the compiler.
-# Usage:
-# compute_flags(
-#   <output variable>
-#   MARCH <arch name or "native">
-#   REQUIRE <list of mandatory features to enable>
-#   REJECT <list of features to disable>
-# )
-function(compute_flags output_var)
-  cmake_parse_arguments(
-    "COMPUTE_FLAGS"
-    "" # Optional arguments
-    "MARCH" # Single value arguments
-    "REQUIRE;REJECT" # Multi value arguments
-    ${ARGN})
-  # Check that features are not required and rejected at the same time.
-  if(COMPUTE_FLAGS_REQUIRE AND COMPUTE_FLAGS_REJECT)
-    _intersection(var ${COMPUTE_FLAGS_REQUIRE} ${COMPUTE_FLAGS_REJECT})
-    if(var)
-      message(FATAL_ERROR "Cpu Features REQUIRE and REJECT ${var}")
-    endif()
-  endif()
-  # Generate the compiler flags in `current`.
-  if(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang|GNU")
-    if(COMPUTE_FLAGS_MARCH)
-      list(APPEND current "-march=${COMPUTE_FLAGS_MARCH}")
-    endif()
-    foreach(feature IN LISTS COMPUTE_FLAGS_REQUIRE)
-      string(TOLOWER ${feature} lowercase_feature)
-      list(APPEND current "-m${lowercase_feature}")
-    endforeach()
-    foreach(feature IN LISTS COMPUTE_FLAGS_REJECT)
-      string(TOLOWER ${feature} lowercase_feature)
-      list(APPEND current "-mno-${lowercase_feature}")
-    endforeach()
-  else()
-    # In future, we can extend for other compilers.
-    message(FATAL_ERROR "Unkown compiler ${CMAKE_CXX_COMPILER_ID}.")
-  endif()
-  # Export the list of flags.
-  set(${output_var} "${current}" PARENT_SCOPE)
-endfunction()
-
 # ------------------------------------------------------------------------------
 # Internal helpers and utilities.
 # ------------------------------------------------------------------------------
 
 # Computes the intersection between two lists.
 function(_intersection output_var list1 list2)
   foreach(element IN LISTS list1)
     if("${list2}" MATCHES "(^|;)${element}(;|$)")

 #endif")
   endforeach()
   configure_file(
     "${LIBC_SOURCE_DIR}/cmake/modules/cpu_features/check_cpu_features.cpp.in"
     "cpu_features/check_cpu_features.cpp" @ONLY)
 endfunction()
 _generate_check_code()
 
-# Compiles and runs the code generated above with the specified requirements.
-# This is helpful to infer which features a particular target supports or if
-# a specific features implies other features (e.g. BMI2 implies SSE2 and SSE).
-function(_check_defined_cpu_feature output_var)
-  cmake_parse_arguments(
-    "CHECK_DEFINED"
-    "" # Optional arguments
-    "MARCH" # Single value arguments
-    "REQUIRE;REJECT" # Multi value arguments
-    ${ARGN})
-  compute_flags(
-    flags
-    MARCH  ${CHECK_DEFINED_MARCH}
-    REQUIRE ${CHECK_DEFINED_REQUIRE}
-    REJECT  ${CHECK_DEFINED_REJECT})
+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()
+  set(LIBC_CPU_FEATURES "${cpu_features}")
+else()
+  # Populates the LIBC_CPU_FEATURES list from host.
   try_run(
     run_result compile_result "${CMAKE_CURRENT_BINARY_DIR}/check_${feature}"
     "${CMAKE_CURRENT_BINARY_DIR}/cpu_features/check_cpu_features.cpp"
-    COMPILE_DEFINITIONS ${flags}
+    COMPILE_DEFINITIONS ${LIBC_COMPILE_OPTIONS_NATIVE}
     COMPILE_OUTPUT_VARIABLE compile_output
     RUN_OUTPUT_VARIABLE run_output)
   if("${run_result}" EQUAL 0)
-    set(${output_var}
-        "${run_output}"
-        PARENT_SCOPE)
+    set(LIBC_CPU_FEATURES "${run_output}")
   elseif(NOT ${compile_result})
     message(FATAL_ERROR "Failed to compile: ${compile_output}")
   else()
     message(FATAL_ERROR "Failed to run: ${run_output}")
   endif()
-endfunction()
-
-set(LIBC_CPU_FEATURES "" CACHE PATH "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()
-  set(LIBC_CPU_FEATURES "${cpu_features}")
-else()
-  # Populates the LIBC_CPU_FEATURES list.
-  # Use -march=native only when the compiler supports it.
-  include(CheckCXXCompilerFlag)
-  CHECK_CXX_COMPILER_FLAG("-march=native" COMPILER_SUPPORTS_MARCH_NATIVE)
-  if(COMPILER_SUPPORTS_MARCH_NATIVE)
-    _check_defined_cpu_feature(LIBC_CPU_FEATURES MARCH native)
-  else()
-    _check_defined_cpu_feature(LIBC_CPU_FEATURES)
-  endif()
 endif()

libc/config/linux/CMakeLists.txt

 add_gen_header(
   linux_syscall_h
   DEF_FILE syscall.h.def
   GEN_HDR syscall.h
   PARAMS
-    inline_syscalls=${LIBC_TARGET_MACHINE}/syscall.h.inc
+    inline_syscalls=${LIBC_TARGET_ARCHITECTURE}/syscall.h.inc
   DATA_FILES
-    ${LIBC_TARGET_MACHINE}/syscall.h.inc
+    ${LIBC_TARGET_ARCHITECTURE}/syscall.h.inc
   DEPENDS
     libc.src.__support.common
 )
 
 add_header(
   app_h
   HDR
     app.h
 )

libc/fuzzing/CMakeLists.txt

 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=fuzzer")
 add_custom_target(libc-fuzzer)
-add_dependencies(check-libc libc-fuzzer)
+# add_dependencies(check-libc libc-fuzzer)
 
 add_subdirectory(math)
 add_subdirectory(string)

libc/loader/linux/CMakeLists.txt

set_target_properties(
     ${fq_target_name}
     PROPERTIES
       "TARGET_TYPE" "${OBJECT_LIBRARY_TARGET_TYPE}"
       "OBJECT_FILES" ""
       "DEPS" "${fq_target_name}.__objects__"
   )
 endfunction()
 
-if(NOT (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_MACHINE}))
-  message(STATUS "Skipping loader for target machine ${LIBC_TARGET_MACHINE}")
+if(NOT (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_ARCHITECTURE}))
+  message(STATUS "Skipping loader for target architecture ${LIBC_TARGET_ARCHITECTURE}")
   return()
 endif()
 
-add_subdirectory(${LIBC_TARGET_MACHINE})
+add_subdirectory(${LIBC_TARGET_ARCHITECTURE})
 
 add_loader_object(
   crt1
   ALIAS
   DEPENDS
-    .${LIBC_TARGET_MACHINE}.crt1
+    .${LIBC_TARGET_ARCHITECTURE}.crt1
 )

libc/src/math/CMakeLists.txt

 add_subdirectory(generic)
-if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_MACHINE})
-  add_subdirectory(${LIBC_TARGET_MACHINE})
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_ARCHITECTURE})
+  add_subdirectory(${LIBC_TARGET_ARCHITECTURE})
 endif()
 
 function(add_math_entrypoint_object name)
   # We prefer machine specific implementation if available. Hence we check
   # that first and retrun early if we are able to add an alias target for the
   # machine specific implementation.
-  get_fq_target_name("${LIBC_TARGET_MACHINE}.${name}" fq_machine_specific_target_name)
+  get_fq_target_name("${LIBC_TARGET_ARCHITECTURE}.${name}" fq_machine_specific_target_name)
   if(TARGET ${fq_machine_specific_target_name})
     add_entrypoint_object(
       ${name}
       ALIAS
       DEPENDS
-        .${LIBC_TARGET_MACHINE}.${name}
+        .${LIBC_TARGET_ARCHITECTURE}.${name}
     )
     return()
   endif()
 
   get_fq_target_name("generic.${name}" fq_generic_target_name)
   if(TARGET ${fq_generic_target_name})
     add_entrypoint_object(
       ${name}

libc/src/string/CMakeLists.txt

 # - Computes flags to satisfy required/rejected features and arch,
 # - Declares an entry point,
 # - Attach the REQUIRE_CPU_FEATURES property to the target,
 # - Add the fully qualified target to `${name}_implementations` global property for tests.
 function(add_implementation name impl_name)
   cmake_parse_arguments(
     "ADD_IMPL"
     "" # Optional arguments
-    "MARCH" # Single value arguments
-    "REQUIRE;REJECT;SRCS;HDRS;DEPENDS;COMPILE_OPTIONS" # Multi value arguments
+    "" # Single value arguments
+    "REQUIRE;SRCS;HDRS;DEPENDS;COMPILE_OPTIONS" # Multi value arguments
     ${ARGN})
-  compute_flags(flags
-    MARCH ${ADD_IMPL_MARCH}
-    REQUIRE ${ADD_IMPL_REQUIRE}
-    REJECT ${ADD_IMPL_REJECT}
-  )
   add_entrypoint_object(${impl_name}
     NAME ${name}
     SRCS ${ADD_IMPL_SRCS}
     HDRS ${ADD_IMPL_HDRS}
     DEPENDS ${ADD_IMPL_DEPENDS}
-    COMPILE_OPTIONS ${ADD_IMPL_COMPILE_OPTIONS} ${flags} -O2
+    COMPILE_OPTIONS ${ADD_IMPL_COMPILE_OPTIONS}
   )
   get_fq_target_name(${impl_name} fq_target_name)
   set_target_properties(${fq_target_name} PROPERTIES REQUIRE_CPU_FEATURES "${ADD_IMPL_REQUIRE}")
   set_property(GLOBAL APPEND PROPERTY "${name}_implementations" "${fq_target_name}")
 endfunction()
 
 # ------------------------------------------------------------------------------
 # memcpy
 # ------------------------------------------------------------------------------
 
-# include the relevant architecture specific implementations
-if(${LIBC_TARGET_MACHINE} STREQUAL "x86_64")
-  set(LIBC_STRING_TARGET_ARCH "x86")
-  set(MEMCPY_SRC ${LIBC_SOURCE_DIR}/src/string/x86/memcpy.cpp)
-elseif(${LIBC_TARGET_MACHINE} STREQUAL "aarch64")
-  set(LIBC_STRING_TARGET_ARCH "aarch64")
-  set(MEMCPY_SRC ${LIBC_SOURCE_DIR}/src/string/aarch64/memcpy.cpp)
-#Disable tail merging as it leads to lower performance
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mllvm --tail-merge-threshold=0")
-else()
-  set(LIBC_STRING_TARGET_ARCH ${LIBC_TARGET_MACHINE})
-  set(MEMCPY_SRC ${LIBC_SOURCE_DIR}/src/string/memcpy.cpp)
-endif()
-
 function(add_memcpy memcpy_name)
   add_implementation(memcpy ${memcpy_name}
     SRCS ${MEMCPY_SRC}
     HDRS ${LIBC_SOURCE_DIR}/src/string/memcpy.h
     DEPENDS
       .memory_utils.memory_utils
       libc.include.string
     COMPILE_OPTIONS
       -fno-builtin-memcpy
     ${ARGN}
   )
 endfunction()
 
-if(${LIBC_STRING_TARGET_ARCH} STREQUAL "x86")
-  add_memcpy(memcpy MARCH native)
+if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
+  set(MEMCPY_SRC ${LIBC_SOURCE_DIR}/src/string/x86_64/memcpy.cpp)
+  add_memcpy(memcpy_x86_64_opt_sse2   COMPILE_OPTIONS -march=x86-64    REQUIRE SSE2)
+  add_memcpy(memcpy_x86_64_opt_sse4   COMPILE_OPTIONS -march=x86-64-v2 REQUIRE SSE4_2)
+  add_memcpy(memcpy_x86_64_opt_avx2   COMPILE_OPTIONS -march=x86-64-v3 REQUIRE AVX2)
+  add_memcpy(memcpy_x86_64_opt_avx512 COMPILE_OPTIONS -march=x86-64-v4 REQUIRE AVX512F)
+  add_memcpy(memcpy_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
+  add_memcpy(memcpy)
+elseif(${LIBC_TARGET_ARCHITECTURE_IS_AARCH64})
+  set(MEMCPY_SRC ${LIBC_SOURCE_DIR}/src/string/aarch64/memcpy.cpp)
+  #Disable tail merging as it leads to lower performance
+  add_memcpy(memcpy_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE}
+                                      COMPILE_OPTIONS "-mllvm --tail-merge-threshold=0")
+  add_memcpy(memcpy                   COMPILE_OPTIONS "-mllvm --tail-merge-threshold=0")
 else()
+  set(MEMCPY_SRC ${LIBC_SOURCE_DIR}/src/string/memcpy.cpp)
+  add_memcpy(memcpy_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
   add_memcpy(memcpy)
 endif()
 
 # ------------------------------------------------------------------------------
 # memset
 # ------------------------------------------------------------------------------
 
 function(add_memset memset_name)
   add_implementation(memset ${memset_name}
     SRCS ${LIBC_SOURCE_DIR}/src/string/memset.cpp
     HDRS ${LIBC_SOURCE_DIR}/src/string/memset.h
     DEPENDS
       .memory_utils.memory_utils
       libc.include.string
     COMPILE_OPTIONS
       -fno-builtin-memset
     ${ARGN}
   )
 endfunction()
 
-if(${LIBC_STRING_TARGET_ARCH} STREQUAL "x86")
-  add_memset(memset MARCH native)
+if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
+  add_memset(memset_x86_64_opt_sse2   COMPILE_OPTIONS -march=x86-64    REQUIRE SSE2)
+  add_memset(memset_x86_64_opt_sse4   COMPILE_OPTIONS -march=x86-64-v2 REQUIRE SSE4_2)
+  add_memset(memset_x86_64_opt_avx2   COMPILE_OPTIONS -march=x86-64-v3 REQUIRE AVX2)
+  add_memset(memset_x86_64_opt_avx512 COMPILE_OPTIONS -march=x86-64-v4 REQUIRE AVX512F)
+  add_memset(memset_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
+  add_memset(memset)
 else()
+  add_memset(memset_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
   add_memset(memset)
 endif()
 
 # ------------------------------------------------------------------------------
 # bzero
 # ------------------------------------------------------------------------------
 
 function(add_bzero bzero_name)
   add_implementation(bzero ${bzero_name}
     SRCS ${LIBC_SOURCE_DIR}/src/string/bzero.cpp
     HDRS ${LIBC_SOURCE_DIR}/src/string/bzero.h
     DEPENDS
       .memory_utils.memory_utils
       libc.include.string
     COMPILE_OPTIONS
       -fno-builtin-memset
       -fno-builtin-bzero
     ${ARGN}
   )
 endfunction()
 
-if(${LIBC_STRING_TARGET_ARCH} STREQUAL "x86")
-  add_bzero(bzero MARCH native)
+if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
+  add_bzero(bzero_x86_64_opt_sse2   COMPILE_OPTIONS -march=x86-64    REQUIRE SSE2)
+  add_bzero(bzero_x86_64_opt_sse4   COMPILE_OPTIONS -march=x86-64-v2 REQUIRE SSE4_2)
+  add_bzero(bzero_x86_64_opt_avx2   COMPILE_OPTIONS -march=x86-64-v3 REQUIRE AVX2)
+  add_bzero(bzero_x86_64_opt_avx512 COMPILE_OPTIONS -march=x86-64-v4 REQUIRE AVX512F)
+  add_bzero(bzero_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
+  add_bzero(bzero)
 else()
+  add_bzero(bzero_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
   add_bzero(bzero)
 endif()
-
-# ------------------------------------------------------------------------------
-# Add all other relevant implementations for the native target.
-# ------------------------------------------------------------------------------
-
-if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_STRING_TARGET_ARCH})
-  include(${LIBC_STRING_TARGET_ARCH}/CMakeLists.txt)
-endif()

libc/src/string/aarch64/CMakeLists.txt

-add_memcpy("memcpy_${LIBC_TARGET_MACHINE}")

libc/src/string/x86/CMakeLists.txt

-add_memcpy("memcpy_${LIBC_TARGET_MACHINE}_opt_none" REJECT "${ALL_CPU_FEATURES}")
-add_memcpy("memcpy_${LIBC_TARGET_MACHINE}_opt_sse" REQUIRE "SSE" REJECT "SSE2")
-add_memcpy("memcpy_${LIBC_TARGET_MACHINE}_opt_avx" REQUIRE "AVX" REJECT "AVX2")
-add_memcpy("memcpy_${LIBC_TARGET_MACHINE}_opt_avx512f" REQUIRE "AVX512F")
-
-add_memset("memset_${LIBC_TARGET_MACHINE}_opt_none" REJECT "${ALL_CPU_FEATURES}")
-add_memset("memset_${LIBC_TARGET_MACHINE}_opt_sse" REQUIRE "SSE" REJECT "SSE2")
-add_memset("memset_${LIBC_TARGET_MACHINE}_opt_avx" REQUIRE "AVX" REJECT "AVX2")
-add_memset("memset_${LIBC_TARGET_MACHINE}_opt_avx512f" REQUIRE "AVX512F")
-
-add_bzero("bzero_${LIBC_TARGET_MACHINE}_opt_none" REJECT "${ALL_CPU_FEATURES}")
-add_bzero("bzero_${LIBC_TARGET_MACHINE}_opt_sse" REQUIRE "SSE" REJECT "SSE2")
-add_bzero("bzero_${LIBC_TARGET_MACHINE}_opt_avx" REQUIRE "AVX" REJECT "AVX2")
-add_bzero("bzero_${LIBC_TARGET_MACHINE}_opt_avx512f" REQUIRE "AVX512F")

libc/src/string/x86_64/memcpy.cpp

 //===-- Implementation of memcpy ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/memcpy.h"
 #include "src/__support/common.h"
 #include "src/string/memory_utils/memcpy_utils.h"
 
 namespace __llvm_libc {
 
 // Whether to use only rep;movsb.
 constexpr bool kUseOnlyRepMovsb =
     LLVM_LIBC_IS_DEFINED(LLVM_LIBC_MEMCPY_X86_USE_ONLY_REPMOVSB);
 
 // kRepMovsBSize == -1 : Only CopyAligned is used.
 // kRepMovsBSize ==  0 : Only RepMovsb is used.
 // else CopyAligned is used up to kRepMovsBSize and then RepMovsb.
 constexpr size_t kRepMovsBSize =
 #ifdef LLVM_LIBC_MEMCPY_X86_USE_REPMOVSB_FROM_SIZE
     LLVM_LIBC_MEMCPY_X86_USE_REPMOVSB_FROM_SIZE;
 #else
     -1;
 #endif // LLVM_LIBC_MEMCPY_X86_USE_REPMOVSB_FROM_SIZE
 
 // Whether target supports AVX instructions.
 constexpr bool kHasAvx = LLVM_LIBC_IS_DEFINED(__AVX__);
 
 // The chunk size used for the loop copy strategy.
 constexpr size_t kLoopCopyBlockSize = kHasAvx ? 64 : 32;
 
 static void CopyRepMovsb(char *__restrict dst, const char *__restrict src,
                          size_t count) {
   // FIXME: Add MSVC support with
   // #include <intrin.h>
   // __movsb(reinterpret_cast<unsigned char *>(dst),
   //         reinterpret_cast<const unsigned char *>(src), count);
   asm volatile("rep movsb" : "+D"(dst), "+S"(src), "+c"(count) : : "memory");
 }
 
 // Design rationale
 // ================
 //
 // Using a profiler to observe size distributions for calls into libc
 // functions, it was found most operations act on a small number of bytes.
 // This makes it important to favor small sizes.
 //
 // The tests for `count` are in ascending order so the cost of branching is
 // proportional to the cost of copying.
 //
 // The function is written in C++ for several reasons:
 // - The compiler can __see__ the code, this is useful when performing Profile
 //   Guided Optimization as the optimized code can take advantage of branching
 //   probabilities.
 // - It also allows for easier customization and favors testing multiple
 //   implementation parameters.
 // - As compilers and processors get better, the generated code is improved
 //   with little change on the code side.
 static void memcpy_x86(char *__restrict dst, const char *__restrict src,
                        size_t count) {
   if (kUseOnlyRepMovsb)
     return CopyRepMovsb(dst, src, count);
 
   if (count == 0)
     return;
   if (count == 1)
     return CopyBlock<1>(dst, src);
   if (count == 2)
     return CopyBlock<2>(dst, src);
   if (count == 3)
     return CopyBlock<3>(dst, src);
   if (count == 4)
     return CopyBlock<4>(dst, src);
   if (count < 8)
     return CopyBlockOverlap<4>(dst, src, count);
   if (count < 16)
     return CopyBlockOverlap<8>(dst, src, count);
   if (count < 32)
     return CopyBlockOverlap<16>(dst, src, count);
   if (count < 64)
     return CopyBlockOverlap<32>(dst, src, count);
   if (count < 128)
     return CopyBlockOverlap<64>(dst, src, count);
   if (kHasAvx && count < 256)
     return CopyBlockOverlap<128>(dst, src, count);
   if (count <= kRepMovsBSize)
     return CopyDstAlignedBlocks<kLoopCopyBlockSize, 32>(dst, src, count);
   return CopyRepMovsb(dst, src, count);
 }
 
 LLVM_LIBC_FUNCTION(void *, memcpy,
                    (void *__restrict dst, const void *__restrict src,
                     size_t size)) {
   memcpy_x86(reinterpret_cast<char *>(dst), reinterpret_cast<const char *>(src),
              size);
   return dst;
 }
 
 } // namespace __llvm_libc

libc/src/threads/linux/CMakeLists.txt

 add_gen_header(
   thread_start_args_h
   DEF_FILE thread_start_args.h.def
   GEN_HDR thread_start_args.h
   PARAMS
-    thread_start_args=${LIBC_TARGET_MACHINE}/thread_start_args.h.in
+    thread_start_args=${LIBC_TARGET_ARCHITECTURE}/thread_start_args.h.in
   DATA_FILES
-    ${LIBC_TARGET_MACHINE}/thread_start_args.h.in
+    ${LIBC_TARGET_ARCHITECTURE}/thread_start_args.h.in
 )
 
 add_entrypoint_object(
   call_once
   SRCS
     call_once.cpp
   HDRS
     ../call_once.h

libc/test/config/linux/CMakeLists.txt

 add_libc_testsuite(libc_linux_tests)
 
-if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_MACHINE})
-  add_subdirectory(${LIBC_TARGET_MACHINE})
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_ARCHITECTURE})
+  add_subdirectory(${LIBC_TARGET_ARCHITECTURE})
 endif()

libc/test/loader/linux/CMakeLists.txt

-if(NOT (EXISTS ${LIBC_SOURCE_DIR}/loader/linux/${LIBC_TARGET_MACHINE}))
-  message("Skipping loader tests for target machine ${LIBC_TARGET_MACHINE}.")
+if(NOT (EXISTS ${LIBC_SOURCE_DIR}/loader/linux/${LIBC_TARGET_ARCHITECTURE}))
+  message("Skipping loader tests for target architecture ${LIBC_TARGET_ARCHITECTURE}.")
   return()
 endif()
 
 add_loader_test(
   loader_args_test
   SRC
     args_test.cpp
   DEPENDS

libc/test/src/math/CMakeLists.txt

DEPENDS
     libc.src.math.sqrt
     libc.utils.FPUtil.fputil
 )
 
 # The quad precision test for sqrt against MPFR currently suffers
 # from insufficient precision in MPFR calculations leading to
 # https://hal.archives-ouvertes.fr/hal-01091186/document. We will
 # renable after fixing the precision issue.
-if(${LIBC_TARGET_MACHINE} MATCHES "x86_64")
+if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   add_fp_unittest(
     sqrtl_test
     NEED_MPFR
     SUITE
       libc_math_unittests
     SRCS
       sqrtl_test.cpp
     DEPENDS

libc/test/src/string/CMakeLists.txt

foreach(fq_config_name IN LISTS fq_implementations)
     cpu_supports(can_run "${required_cpu_features}")
     if(can_run)
       add_libc_unittest(
         ${fq_config_name}_test
         SUITE
           libc_string_unittests
         DEPENDS
           ${fq_config_name}
+        COMPILE_OPTIONS
+          ${LIBC_COMPILE_OPTIONS_NATIVE}
         ${ARGN}
       )
     else()
       message(STATUS "Skipping test for '${fq_config_name}' insufficient host cpu features '${required_cpu_features}'")
     endif()
   endforeach()
 endfunction()
 
 add_libc_multi_impl_test(memcpy SRCS memcpy_test.cpp)
 add_libc_multi_impl_test(memset SRCS memset_test.cpp)
 add_libc_multi_impl_test(bzero SRCS bzero_test.cpp)

libc/test/utils/FPUtil/CMakeLists.txt

-if((${LIBC_TARGET_OS} STREQUAL "linux") AND (${LIBC_TARGET_MACHINE} MATCHES "i386|x86_64"))
+if((${LIBC_TARGET_OS} STREQUAL "linux") AND (${LIBC_TARGET_ARCHITECTURE_IS_X86}))
   add_libc_unittest(
     x86_long_double_test
     SRCS
       x86_long_double_test.cpp
     DEPENDS
       libc.include.math
       libc.utils.FPUtil.fputil
   )
 endif()

libc/utils/FPUtil/CMakeLists.txt

-if(${LIBC_TARGET_MACHINE} MATCHES "^x86.*")
+if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   set(LONG_DOUBLE_HDR LongDoubleBitsX86.h)
 else()
   set(LONG_DOUBLE_HDR)
 endif()
 
-if(EXISTS ${LIBC_TARGET_MACHINE})
-  set(FENV_IMPL ${LIBC_TARGET_MACHINE}/FEnv.h)
+if(EXISTS ${LIBC_TARGET_ARCHITECTURE})
+  set(FENV_IMPL ${LIBC_TARGET_ARCHITECTURE}/FEnv.h)
 else()
   set(FENV_IMPL DummyFEnv.h)
 endif()
 
 add_header_library(
   fputil
   HDRS
     ${LONG_DOUBLE_HDR}