test/buildsystem/build_name.cmake

# SPDX-FileCopyrightText: The Eigen Authors
# SPDX-License-Identifier: MPL-2.0

cmake_minimum_required(VERSION 3.18)
include("${CMAKE_CURRENT_LIST_DIR}/../../cmake/EigenTesting.cmake")

set(CMAKE_SYSTEM Linux-test)
set(CMAKE_CXX_COMPILER_ID GNU)
set(CMAKE_CXX_COMPILER_VERSION 13.3.0)
set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT GNU)

function(assert_equal actual expected)
  if(NOT actual STREQUAL expected)
    message(FATAL_ERROR "Expected ${expected}, got ${actual}")
  endif()
endfunction()

function(check_flags expected)
  foreach(feature IN LISTS ARGN)
    set(EIGEN_TEST_${feature} ON)
  endforeach()
  ei_get_cxxflags(actual)
  assert_equal("${actual}" "${expected}")
endfunction()

# A 64-bit target does not imply SSE2. Host metadata must not affect the label.
set(CMAKE_SIZEOF_VOID_P 8)
set(CMAKE_HOST_SYSTEM_PROCESSOR AMD64)
set(CMAKE_SYSTEM_PROCESSOR aarch64)
check_flags(default)
set(CMAKE_SYSTEM_PROCESSOR mips64)
check_flags(MSA MSA)
set(CMAKE_SIZEOF_VOID_P 4)
check_flags(default)
foreach(feature IN ITEMS NEON NEON64 ZVECTOR Z14 VSX ALTIVEC MSA LSX SME
                         SSE2 SSE3 SSSE3 SSE4_1 SSE4_2 AVX AVX2 AVX512 AVX512DQ AVX512FP16 FMA F16C)
  check_flags("${feature}" "${feature}")
endforeach()
check_flags(AVX-AVX2-AVX512-FMA AVX AVX2 AVX512 FMA)
check_flags(AVX512DQ-AVX512FP16-F16C AVX512FP16 AVX512DQ F16C)
check_flags(NOVEC NO_EXPLICIT_VECTORIZATION)
check_flags(AVX-NOVEC AVX NO_EXPLICIT_VECTORIZATION)
check_flags(AVX2-NOVEC AVX2 NO_EXPLICIT_VECTORIZATION)
check_flags(F16C-NOVEC F16C NO_EXPLICIT_VECTORIZATION)
check_flags(AVX-FMA-F16C-NOVEC AVX FMA F16C NO_EXPLICIT_VECTORIZATION)
check_flags(default-OMP OPENMP)
set(EIGEN_TEST_SVE_VL 512)
check_flags(SVE512 SVE)
set(EIGEN_DEFAULT_TO_ROW_MAJOR ON)
check_flags(default-ROWMAJ)
check_flags(AVX2-OMP-ROWMAJ AVX2 OPENMP)
unset(EIGEN_DEFAULT_TO_ROW_MAJOR)

function(check_arch processor compiler_arch generator_platform expected)
  set(CMAKE_SYSTEM_PROCESSOR "${processor}")
  set(CMAKE_CXX_COMPILER_ARCHITECTURE_ID "${compiler_arch}")
  set(CMAKE_GENERATOR_PLATFORM "${generator_platform}")
  ei_get_target_architecture(actual)
  assert_equal("${actual}" "${expected}")
endfunction()

check_arch(aarch64 "" "" aarch64)
check_arch(AMD64 "" "" x86_64)
check_arch(i686 "" "" x86)
check_arch(ppc64le "" "" ppc64le)
check_arch(s390x "" "" s390x)
check_arch(riscv64 "" "" riscv64)
check_arch(loongarch64 "" "" loongarch64)
check_arch(AMD64 ARM64 "" aarch64)
check_arch(AMD64 "" "ARM64,version=10.0" aarch64)
check_arch(AMD64 "" ",version=10.0" x86_64)
check_arch(AMD64 "" Win32 x86)
check_arch(AMD64 ARM64EC ARM64 arm64ec)
check_arch("" "" "" unknown)

function(check_build expected)
  ei_set_build_string()
  assert_equal("${BUILDNAME}" "linux-test-${expected}")
endfunction()

function(check_target target)
  set(CMAKE_CXX_COMPILER_TARGET "${target}")
  check_arch(x86_64 "" "" "${target}")
  set(CMAKE_SYSTEM_PROCESSOR x86_64)
  set(CMAKE_SIZEOF_VOID_P 8)
  set(CMAKE_CXX_COMPILER_ID Clang)
  set(CMAKE_CXX_COMPILER_VERSION 18.1.3)
  check_build("${target}-clang-18.1.3-default-64bit")
endfunction()

foreach(target IN ITEMS aarch64-linux-gnu arm-linux-gnueabihf riscv64-linux-gnu
                        gcc_ntoaarch64le "8.3.0,gcc_ntoaarch64le")
  check_target("${target}")
endforeach()

function(check_apple_arch processor osx_arch expected)
  set(APPLE TRUE)
  set(CMAKE_OSX_ARCHITECTURES "${osx_arch}")
  check_arch("${processor}" x86_64 "" "${expected}")
endfunction()

check_apple_arch(x86_64 arm64 aarch64)
check_apple_arch(arm64 x86_64 x86_64)
check_apple_arch(x86_64 "x86_64;arm64" aarch64+x86_64)
check_apple_arch(arm64 "arm64;x86_64" aarch64+x86_64)
check_apple_arch(x86_64 "arm64;arm64" aarch64)
check_apple_arch(x86_64 arm64e arm64e)
check_apple_arch(x86_64 "" x86_64)

function(check_width bytes expected)
  set(CMAKE_SIZEOF_VOID_P "${bytes}")
  set(CMAKE_SYSTEM_PROCESSOR aarch64)
  set(EIGEN_TEST_EXTERNAL_BLAS ON)
  set(EIGEN_BUILD_STRING_SUFFIX probe)
  check_build("aarch64-gnu-13.3.0-default-external_blas-${expected}-probe")
endfunction()

check_width(4 32bit)
check_width(8 64bit)
check_width("" unknown-bits)

function(check_32bit gnu expected_arch expected_bits)
  set(CMAKE_COMPILER_IS_GNUCXX "${gnu}")
  set(EIGEN_TEST_32BIT ON)
  set(CMAKE_SYSTEM_PROCESSOR x86_64)
  set(CMAKE_SIZEOF_VOID_P 8)
  ei_get_target_architecture(actual)
  assert_equal("${actual}" "${expected_arch}")
  check_build("${expected_arch}-gnu-13.3.0-default-${expected_bits}bit")
endfunction()

check_32bit(TRUE x86 32)
check_32bit(FALSE x86_64 64)