blob: a5a5ba4ed5ce0579b2d617fcfcf81bc2c59e8176 [file]
// Copyright 2025 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <sys/auxv.h>
#include <array>
#include <cstdint>
#include <fstream>
#include <optional>
#include <ostream>
#include <sstream>
#include <string>
#include <string_view>
#include "gtest/gtest.h"
namespace {
#if defined(__arm__)
// The Linux sysroot headers predate these 32-bit ARM AT_HWCAP capability bits
// (`arch/arm/include/uapi/asm/hwcap.h`).
constexpr unsigned long kArch32HwcapFphp = 1UL << 22;
constexpr unsigned long kArch32HwcapAsimdhp = 1UL << 23;
constexpr unsigned long kArch32HwcapAsimdfhm = 1UL << 25;
constexpr std::array<std::string_view, 28> kHwcapStr = {
"swp", "half", "thumb", "26bit", "fastmult", "fpa", "vfp",
"edsp", "java", "iwmmxt", "crunch", "thumbee", "neon", "vfpv3",
"vfpv3d16", "tls", "vfpv4", "idiva", "idivt", "vfpd32", "lpae",
"evtstrm", "fphp", "asimdhp", "asimddp", "asimdfhm", "asimdbf16", "i8mm",
};
constexpr std::array<std::string_view, 7> kHwcap2Str = {
"aes", "pmull", "sha1", "sha2", "crc32", "sb", "ssbs",
};
#elif defined(__aarch64__)
// The Linux sysroot headers (`bits/hwcap.h`) predate these AArch64 AT_HWCAP/AT_HWCAP2 capability
// bits (`arch/arm64/include/uapi/asm/hwcap.h`).
constexpr unsigned long kHwcapFp = 1UL << 0;
constexpr unsigned long kHwcapAsimd = 1UL << 1;
constexpr unsigned long kHwcapFphp = 1UL << 9;
constexpr unsigned long kHwcapAsimdhp = 1UL << 10;
constexpr unsigned long kHwcapSve = 1UL << 22;
constexpr unsigned long kHwcap2Sve2 = 1UL << 1;
constexpr std::array<std::string_view, 32> kHwcapStr = {
"fp", "asimd", "evtstrm", "aes", "pmull", "sha1", "sha2", "crc32",
"atomics", "fphp", "asimdhp", "cpuid", "asimdrdm", "jscvt", "fcma", "lrcpc",
"dcpop", "sha3", "sm3", "sm4", "asimddp", "sha512", "sve", "asimdfhm",
"dit", "uscat", "ilrcpc", "flagm", "ssbs", "sb", "paca", "pacg",
};
constexpr std::array<std::string_view, 32> kHwcap2Str = {
"dcpodp", "sve2", "sveaes", "svepmull", "svebitperm", "svesha3", "svesm4",
"flagm2", "frint", "svei8mm", "svef32mm", "svef64mm", "svebf16", "i8mm",
"bf16", "dgh", "rng", "bti", "mte", "ecv", "afp",
"rpres", "mte3", "sme", "smei16i64", "smef64f64", "smei8i32", "smef16f32",
"smeb16f32", "smef32f32", "smefa64", "wfxt",
};
enum class SveVersion : int {
kDefault = 0,
kSve = 1,
kSve2 = 2,
};
std::ostream& operator<<(std::ostream& os, SveVersion version) {
switch (version) {
case SveVersion::kDefault:
return os << "default";
case SveVersion::kSve:
return os << "sve";
case SveVersion::kSve2:
return os << "sve2";
}
return os << "unknown(" << static_cast<int>(version) << ")";
}
__attribute__((target_version("default"))) uint64_t SveVectorBytesOrZero() { return 0; }
__attribute__((target_version("sve"))) uint64_t SveVectorBytesOrZero() {
uint64_t vl_bytes = 0;
__asm__("cntb %0" : "=r"(vl_bytes));
return vl_bytes;
}
__attribute__((target_version("default"))) SveVersion SelectSveOrDefault() {
return SveVersion::kDefault;
}
__attribute__((target_version("sve"))) SveVersion SelectSveOrDefault() { return SveVersion::kSve; }
__attribute__((target_version("default"))) SveVersion SelectSve2OrDefault() {
return SveVersion::kDefault;
}
__attribute__((target_version("sve2"))) SveVersion SelectSve2OrDefault() {
__asm__ volatile("ptrue p0.s\n\thistcnt z0.s, p0/z, z0.s, z0.s" : : : "z0", "p0");
return SveVersion::kSve2;
}
__attribute__((target_version("default"))) SveVersion SelectBestSveVersion() {
return SveVersion::kDefault;
}
__attribute__((target_version("sve"))) SveVersion SelectBestSveVersion() {
uint64_t vl_bytes = 0;
__asm__ volatile("cntb %0" : "=r"(vl_bytes));
(void)vl_bytes;
return SveVersion::kSve;
}
__attribute__((target_version("sve2"))) SveVersion SelectBestSveVersion() {
__asm__ volatile("ptrue p0.s\n\thistcnt z0.s, p0/z, z0.s, z0.s" : : : "z0", "p0");
return SveVersion::kSve2;
}
#endif // defined(__aarch64__)
class CpuinfoTest : public ::testing::Test {};
TEST_F(CpuinfoTest, Cpuinfo) {
std::fstream cpuinfo("/proc/cpuinfo");
ASSERT_TRUE(cpuinfo.is_open());
std::optional<std::string> features_line;
std::string line;
while (std::getline(cpuinfo, line)) {
if (!features_line && line.starts_with("Features\t:")) {
features_line = line;
}
}
EXPECT_TRUE(cpuinfo.eof());
#if defined(__arm__) || defined(__aarch64__)
std::stringstream ss;
ss << "Features\t:";
for (size_t i = 0; i < kHwcapStr.size(); i++) {
if (getauxval(AT_HWCAP) & (1UL << i)) {
ss << " " << kHwcapStr[i];
}
}
for (size_t i = 0; i < kHwcap2Str.size(); i++) {
if (getauxval(AT_HWCAP2) & (1UL << i)) {
ss << " " << kHwcap2Str[i];
}
}
const auto expected_features_line = ss.str();
ASSERT_TRUE(features_line.has_value());
EXPECT_EQ(*features_line, expected_features_line);
#endif
}
#if defined(__arm__)
TEST_F(CpuinfoTest, Arch32HwcapInvariants) {
const unsigned long hwcap = getauxval(AT_HWCAP);
const unsigned long hwcap2 = getauxval(AT_HWCAP2);
// SVE and SVE2 are AArch64-only (A64 ISA) extensions and do not exist in AArch32 execution state
// or 32-bit ARM AT_HWCAP/AT_HWCAP2. Verify 32-bit AT_HWCAP/AT_HWCAP2 invariants (including
// FEAT_FP16 HWCAP_FPHP/HWCAP_ASIMDHP when FEAT_FHM is present) and that /proc/cpuinfo does not
// expose AArch64-only SVE/SVE2 feature tokens to a 32-bit process.
EXPECT_EQ(hwcap & ~((1UL << kHwcapStr.size()) - 1), 0UL);
EXPECT_EQ(hwcap2 & ~((1UL << kHwcap2Str.size()) - 1), 0UL);
if ((hwcap & kArch32HwcapAsimdfhm) != 0) {
EXPECT_NE(hwcap & kArch32HwcapFphp, 0UL);
EXPECT_NE(hwcap & kArch32HwcapAsimdhp, 0UL);
}
std::ifstream cpuinfo("/proc/cpuinfo");
ASSERT_TRUE(cpuinfo.is_open());
std::string line;
while (std::getline(cpuinfo, line)) {
if (line.starts_with("Features\t:")) {
std::istringstream tokens(line.substr(sizeof("Features\t:") - 1));
std::string token;
while (tokens >> token) {
EXPECT_FALSE(token.starts_with("sve")) << "Unexpected SVE feature in arch32: " << token;
}
}
}
}
#elif defined(__aarch64__)
TEST_F(CpuinfoTest, SveFunctionMultiVersioning) {
const unsigned long hwcap = getauxval(AT_HWCAP);
const unsigned long hwcap2 = getauxval(AT_HWCAP2);
const bool has_sve = (hwcap & kHwcapSve) != 0;
const bool has_sve2 = (hwcap2 & kHwcap2Sve2) != 0;
if (has_sve2) {
EXPECT_TRUE(has_sve) << "HWCAP2_SVE2 must not be reported without HWCAP_SVE";
}
if (has_sve) {
// Per ACLE Function Multi-Versioning (FMV) dependency rules (used by LLVM/compiler-rt), "sve"
// and "sve2" targets transitively require FEAT_FP (HWCAP_FP) and FEAT_FP16 (HWCAP_FPHP).
EXPECT_NE(hwcap & kHwcapFp, 0UL);
EXPECT_NE(hwcap & kHwcapAsimd, 0UL);
EXPECT_NE(hwcap & kHwcapFphp, 0UL);
EXPECT_NE(hwcap & kHwcapAsimdhp, 0UL);
}
EXPECT_EQ(static_cast<bool>(__builtin_cpu_supports("sve")), has_sve);
EXPECT_EQ(static_cast<bool>(__builtin_cpu_supports("sve2")), has_sve2);
if (has_sve) {
EXPECT_EQ(SelectSveOrDefault(), SveVersion::kSve);
const uint64_t vl_bytes = SveVectorBytesOrZero();
EXPECT_GE(vl_bytes, 16u);
EXPECT_LE(vl_bytes, 256u);
EXPECT_EQ(vl_bytes % 16, 0u);
} else {
EXPECT_EQ(SelectSveOrDefault(), SveVersion::kDefault);
EXPECT_EQ(SveVectorBytesOrZero(), 0u);
}
if (has_sve2) {
EXPECT_EQ(SelectSve2OrDefault(), SveVersion::kSve2);
EXPECT_EQ(SelectBestSveVersion(), SveVersion::kSve2);
} else if (has_sve) {
EXPECT_EQ(SelectSve2OrDefault(), SveVersion::kDefault);
EXPECT_EQ(SelectBestSveVersion(), SveVersion::kSve);
} else {
EXPECT_EQ(SelectSve2OrDefault(), SveVersion::kDefault);
EXPECT_EQ(SelectBestSveVersion(), SveVersion::kDefault);
}
}
#endif // defined(__aarch64__)
} // namespace