[libc] Normalize LIBC_TARGET_MACHINE

[gchatelet]

Summary

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.

[gchatelet]

• Remove unrelated change

[gchatelet]

@sivachandra do you mind having a look?

[sivachandra]

Sorry I missed this.

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

 endif()
 
 option(LLVM_LIBC_FULL_BUILD "Build and test LLVM libc as if it is the full libc" OFF)
 
 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/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")
+if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   set(ALL_CPU_FEATURES SSE SSE2 AVX AVX2 AVX512F)
   list(SORT ALL_CPU_FEATURES)
 endif()
 
 # Function to check whether the target CPU supports the provided set of features.
 # Usage:
 # cpu_supports(
 #   <output variable>

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

function(add_implementation name impl_name)
   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)
+if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
+  set(MEMCPY_SRC ${LIBC_SOURCE_DIR}/src/string/${LIBC_TARGET_ARCHITECTURE}/memcpy.cpp)
+elseif(${LIBC_TARGET_ARCHITECTURE_IS_AARCH64})
+  set(MEMCPY_SRC ${LIBC_SOURCE_DIR}/src/string/${LIBC_TARGET_ARCHITECTURE}/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")
+if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   add_memcpy(memcpy MARCH native)
 else()
   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")
+if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   add_memset(memset MARCH native)
 else()
   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")
+if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   add_bzero(bzero MARCH native)
 else()
   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)
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_ARCHITECTURE})
+  include(${LIBC_TARGET_ARCHITECTURE}/CMakeLists.txt)
 endif()

libc/src/string/aarch64/CMakeLists.txt

-add_memcpy("memcpy_${LIBC_TARGET_MACHINE}")
+add_memcpy("memcpy_${LIBC_TARGET_ARCHITECTURE}")

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/CMakeLists.txt

+add_memcpy("memcpy_${LIBC_TARGET_ARCHITECTURE}_opt_none" REJECT "${ALL_CPU_FEATURES}")
+add_memcpy("memcpy_${LIBC_TARGET_ARCHITECTURE}_opt_sse" REQUIRE "SSE" REJECT "SSE2")
+add_memcpy("memcpy_${LIBC_TARGET_ARCHITECTURE}_opt_avx" REQUIRE "AVX" REJECT "AVX2")
+add_memcpy("memcpy_${LIBC_TARGET_ARCHITECTURE}_opt_avx512f" REQUIRE "AVX512F")
+
+add_memset("memset_${LIBC_TARGET_ARCHITECTURE}_opt_none" REJECT "${ALL_CPU_FEATURES}")
+add_memset("memset_${LIBC_TARGET_ARCHITECTURE}_opt_sse" REQUIRE "SSE" REJECT "SSE2")
+add_memset("memset_${LIBC_TARGET_ARCHITECTURE}_opt_avx" REQUIRE "AVX" REJECT "AVX2")
+add_memset("memset_${LIBC_TARGET_ARCHITECTURE}_opt_avx512f" REQUIRE "AVX512F")
+
+add_bzero("bzero_${LIBC_TARGET_ARCHITECTURE}_opt_none" REJECT "${ALL_CPU_FEATURES}")
+add_bzero("bzero_${LIBC_TARGET_ARCHITECTURE}_opt_sse" REQUIRE "SSE" REJECT "SSE2")
+add_bzero("bzero_${LIBC_TARGET_ARCHITECTURE}_opt_avx" REQUIRE "AVX" REJECT "AVX2")
+add_bzero("bzero_${LIBC_TARGET_ARCHITECTURE}_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/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}