Botan 3.0.0
Crypto and TLS for C&
Classes | Public Types | Static Public Member Functions | List of all members
Botan::CPUID Class Referencefinal

#include <cpuid.h>

Public Types

enum  CPUID_bits : uint32_t { CPUID_IS_BIG_ENDIAN_BIT = (1U << 30) , CPUID_INITIALIZED_BIT = (1U << 31) }
 

Static Public Member Functions

static std::vector< CPUID::CPUID_bits > bit_from_string (std::string_view tok)
 
static void clear_cpuid_bit (CPUID_bits bit)
 
static bool has_carryless_multiply ()
 
static bool has_cpuid_bit (CPUID_bits elem)
 
static bool has_hw_aes ()
 
static bool has_simd_32 ()
 
static bool has_vperm ()
 
static void initialize ()
 
static bool is_big_endian ()
 
static bool is_little_endian ()
 
static std::string to_string ()
 

Detailed Description

A class handling runtime CPU feature detection. It is limited to just the features necessary to implement CPU specific code in Botan, rather than being a general purpose utility.

This class supports:

Definition at line 36 of file cpuid.h.

Member Enumeration Documentation

◆ CPUID_bits

enum Botan::CPUID::CPUID_bits : uint32_t
Enumerator
CPUID_IS_BIG_ENDIAN_BIT 
CPUID_INITIALIZED_BIT 

Definition at line 82 of file cpuid.h.

82 : uint32_t {
83#if defined(BOTAN_TARGET_CPU_IS_X86_FAMILY)
84 // These values have no relation to cpuid bitfields
85
86 // SIMD instruction sets
87 CPUID_SSE2_BIT = (1U << 0),
88 CPUID_SSSE3_BIT = (1U << 1),
89 CPUID_AVX2_BIT = (1U << 2),
90 CPUID_AVX512_BIT = (1U << 3),
91
92 // Misc useful instructions
93 CPUID_RDTSC_BIT = (1U << 10),
94 CPUID_ADX_BIT = (1U << 11),
95 CPUID_BMI_BIT = (1U << 12),
96
97 // Crypto-specific ISAs
98 CPUID_AESNI_BIT = (1U << 16),
99 CPUID_CLMUL_BIT = (1U << 17),
100 CPUID_RDRAND_BIT = (1U << 18),
101 CPUID_RDSEED_BIT = (1U << 19),
102 CPUID_SHA_BIT = (1U << 20),
103 CPUID_AVX512_AES_BIT = (1U << 21),
104 CPUID_AVX512_CLMUL_BIT = (1U << 22),
105#endif
106
107#if defined(BOTAN_TARGET_CPU_IS_PPC_FAMILY)
108 CPUID_ALTIVEC_BIT = (1U << 0),
109 CPUID_POWER_CRYPTO_BIT = (1U << 1),
110 CPUID_DARN_BIT = (1U << 2),
111#endif
112
113#if defined(BOTAN_TARGET_CPU_IS_ARM_FAMILY)
114 CPUID_ARM_NEON_BIT = (1U << 0),
115 CPUID_ARM_SVE_BIT = (1U << 1),
116 CPUID_ARM_AES_BIT = (1U << 16),
117 CPUID_ARM_PMULL_BIT = (1U << 17),
118 CPUID_ARM_SHA1_BIT = (1U << 18),
119 CPUID_ARM_SHA2_BIT = (1U << 19),
120 CPUID_ARM_SHA3_BIT = (1U << 20),
121 CPUID_ARM_SHA2_512_BIT = (1U << 21),
122 CPUID_ARM_SM3_BIT = (1U << 22),
123 CPUID_ARM_SM4_BIT = (1U << 23),
124#endif
125
126 CPUID_IS_BIG_ENDIAN_BIT = (1U << 30),
127 CPUID_INITIALIZED_BIT = (1U << 31)
128 };
Botan::CPUID::CPUID_INITIALIZED_BIT
@ CPUID_INITIALIZED_BIT
Definition: cpuid.h:127
Botan::CPUID::CPUID_IS_BIG_ENDIAN_BIT
@ CPUID_IS_BIG_ENDIAN_BIT
Definition: cpuid.h:126

Member Function Documentation

◆ bit_from_string()

std::vector< CPUID::CPUID_bits > Botan::CPUID::bit_from_string ( std::string_view  tok)
static

Definition at line 149 of file cpuid.cpp.

150 {
151#if defined(BOTAN_TARGET_CPU_IS_X86_FAMILY)
152 if(tok == "sse2" || tok == "simd")
153 return {CPUID::CPUID_SSE2_BIT};
154 if(tok == "ssse3")
155 return {CPUID::CPUID_SSSE3_BIT};
156 // aes_ni is the string printed on the console when running "botan cpuid"
157 if(tok == "aesni" || tok == "aes_ni")
158 return {CPUID::CPUID_AESNI_BIT};
159 if(tok == "clmul")
160 return {CPUID::CPUID_CLMUL_BIT};
161 if(tok == "avx2")
162 return {CPUID::CPUID_AVX2_BIT};
163 if(tok == "avx512")
164 return {CPUID::CPUID_AVX512_BIT};
165 // there were two if statements testing "sha" and "intel_sha" separately; combined
166 if(tok == "sha" || tok == "intel_sha")
167 return {CPUID::CPUID_SHA_BIT};
168 if(tok == "rdtsc")
169 return {CPUID::CPUID_RDTSC_BIT};
170 if(tok == "bmi2")
171 return {CPUID::CPUID_BMI_BIT};
172 if(tok == "adx")
173 return {CPUID::CPUID_ADX_BIT};
174 if(tok == "rdrand")
175 return {CPUID::CPUID_RDRAND_BIT};
176 if(tok == "rdseed")
177 return {CPUID::CPUID_RDSEED_BIT};
178 if(tok == "avx512_aes")
179 return {CPUID::CPUID_AVX512_AES_BIT};
180 if(tok == "avx512_clmul")
181 return {CPUID::CPUID_AVX512_CLMUL_BIT};
182
183#elif defined(BOTAN_TARGET_CPU_IS_PPC_FAMILY)
184 if(tok == "altivec" || tok == "simd")
185 return {CPUID::CPUID_ALTIVEC_BIT};
186 if(tok == "power_crypto")
187 return {CPUID::CPUID_POWER_CRYPTO_BIT};
188 if(tok == "darn_rng")
189 return {CPUID::CPUID_DARN_BIT};
190
191#elif defined(BOTAN_TARGET_CPU_IS_ARM_FAMILY)
192 if(tok == "neon" || tok == "simd")
193 return {CPUID::CPUID_ARM_NEON_BIT};
194 if(tok == "arm_sve")
195 return {CPUID::CPUID_ARM_SVE_BIT};
196 if(tok == "armv8sha1" || tok == "arm_sha1")
197 return {CPUID::CPUID_ARM_SHA1_BIT};
198 if(tok == "armv8sha2" || tok == "arm_sha2")
199 return {CPUID::CPUID_ARM_SHA2_BIT};
200 if(tok == "armv8aes" || tok == "arm_aes")
201 return {CPUID::CPUID_ARM_AES_BIT};
202 if(tok == "armv8pmull" || tok == "arm_pmull")
203 return {CPUID::CPUID_ARM_PMULL_BIT};
204 if(tok == "armv8sha3" || tok == "arm_sha3")
205 return {CPUID::CPUID_ARM_SHA3_BIT};
206 if(tok == "armv8sha2_512" || tok == "arm_sha2_512")
207 return {CPUID::CPUID_ARM_SHA2_512_BIT};
208 if(tok == "armv8sm3" || tok == "arm_sm3")
209 return {CPUID::CPUID_ARM_SM3_BIT};
210 if(tok == "armv8sm4" || tok == "arm_sm4")
211 return {CPUID::CPUID_ARM_SM4_BIT};
212
213#else
214 BOTAN_UNUSED(tok);
215#endif
216
217 return {};
218 }
BOTAN_UNUSED
#define BOTAN_UNUSED(...)
Definition: assert.h:141

References BOTAN_UNUSED.

◆ clear_cpuid_bit()

static void Botan::CPUID::clear_cpuid_bit ( CPUID_bits  bit)
inlinestatic

Definition at line 360 of file cpuid.h.

361 {
362 state().clear_cpuid_bit(static_cast<uint32_t>(bit));
363 }

◆ has_carryless_multiply()

static bool Botan::CPUID::has_carryless_multiply ( )
inlinestatic

Check if the processor supports carryless multiply (CLMUL, PMULL)

Definition at line 340 of file cpuid.h.

341 {
342#if defined(BOTAN_TARGET_CPU_IS_X86_FAMILY)
343 return has_clmul();
344#elif defined(BOTAN_TARGET_CPU_IS_ARM_FAMILY)
345 return has_arm_pmull();
346#elif defined(BOTAN_TARGET_ARCH_IS_PPC64)
347 return has_power_crypto();
348#else
349 return false;
350#endif
351 }

Referenced by Botan::GHASH::provider().

◆ has_cpuid_bit()

static bool Botan::CPUID::has_cpuid_bit ( CPUID_bits  elem)
inlinestatic

Definition at line 369 of file cpuid.h.

370 {
371 const uint32_t elem32 = static_cast<uint32_t>(elem);
372 return state().has_bit(elem32);
373 }

◆ has_hw_aes()

static bool Botan::CPUID::has_hw_aes ( )
inlinestatic

Check if the processor supports hardware AES instructions

Definition at line 323 of file cpuid.h.

324 {
325#if defined(BOTAN_TARGET_CPU_IS_X86_FAMILY)
326 return has_aes_ni();
327#elif defined(BOTAN_TARGET_CPU_IS_ARM_FAMILY)
328 return has_arm_aes();
329#elif defined(BOTAN_TARGET_CPU_IS_PPC_FAMILY)
330 return has_power_crypto();
331#else
332 return false;
333#endif
334 }

Referenced by Botan::AES_128::decrypt_n(), Botan::AES_192::decrypt_n(), Botan::AES_256::decrypt_n(), Botan::AES_128::encrypt_n(), Botan::AES_192::encrypt_n(), and Botan::AES_256::encrypt_n().

◆ has_simd_32()

bool Botan::CPUID::has_simd_32 ( )
static

Return true if a 4x32 SIMD instruction set is available (SSE2, NEON, or Altivec/VMX)

Definition at line 17 of file cpuid.cpp.

18 {
19#if defined(BOTAN_TARGET_SUPPORTS_SSE2)
20 return CPUID::has_sse2();
21#elif defined(BOTAN_TARGET_SUPPORTS_ALTIVEC)
22 return CPUID::has_altivec();
23#elif defined(BOTAN_TARGET_SUPPORTS_NEON)
24 return CPUID::has_neon();
25#else
26 return true;
27#endif
28 }

Referenced by Botan::Noekeon::decrypt_n(), Botan::Serpent::decrypt_n(), Botan::SHACAL2::decrypt_n(), Botan::Noekeon::encrypt_n(), Botan::Serpent::encrypt_n(), Botan::SHACAL2::encrypt_n(), Botan::Noekeon::parallelism(), Botan::SHACAL2::parallelism(), Botan::Noekeon::provider(), Botan::Serpent::provider(), Botan::SHACAL2::provider(), and Botan::ChaCha::provider().

◆ has_vperm()

static bool Botan::CPUID::has_vperm ( )
inlinestatic

Check if the processor supports byte-level vector permutes (SSSE3, NEON, Altivec)

Definition at line 307 of file cpuid.h.

308 {
309#if defined(BOTAN_TARGET_CPU_IS_X86_FAMILY)
310 return has_ssse3();
311#elif defined(BOTAN_TARGET_CPU_IS_ARM_FAMILY)
312 return has_neon();
313#elif defined(BOTAN_TARGET_CPU_IS_PPC_FAMILY)
314 return has_altivec();
315#else
316 return false;
317#endif
318 }

Referenced by Botan::AES_128::decrypt_n(), Botan::AES_192::decrypt_n(), Botan::AES_256::decrypt_n(), Botan::AES_128::encrypt_n(), Botan::AES_192::encrypt_n(), Botan::AES_256::encrypt_n(), Botan::ZFEC::provider(), and Botan::GHASH::provider().

◆ initialize()

void Botan::CPUID::initialize ( )
static

Probe the CPU and see what extensions are supported

Definition at line 89 of file cpuid.cpp.

90 {
91 state() = CPUID_Data();
92 }

◆ is_big_endian()

static bool Botan::CPUID::is_big_endian ( )
inlinestatic

Definition at line 71 of file cpuid.h.

72 {
73#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
74 return true;
75#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
76 return false;
77#else
78 return has_cpuid_bit(CPUID_IS_BIG_ENDIAN_BIT);
79#endif
80 }
Botan::CPUID::has_cpuid_bit
static bool has_cpuid_bit(CPUID_bits elem)
Definition: cpuid.h:369

Referenced by Botan::SIMD_4x32::load_le().

◆ is_little_endian()

static bool Botan::CPUID::is_little_endian ( )
inlinestatic

Definition at line 60 of file cpuid.h.

61 {
62#if defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
63 return true;
64#elif defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
65 return false;
66#else
67 return !has_cpuid_bit(CPUID_IS_BIG_ENDIAN_BIT);
68#endif
69 }

Referenced by Botan::XMSS_Tools::concat(), Botan::SIMD_4x32::load_be(), Botan::SIMD_4x32::store_be(), and Botan::SIMD_4x32::store_le().

◆ to_string()

std::string Botan::CPUID::to_string ( )
static

Return a possibly empty string containing list of known CPU extensions. Each name will be seperated by a space, and the ordering will be arbitrary. This list only contains values that are useful to Botan (for example FMA instructions are not checked).

Example outputs "sse2 ssse3 rdtsc", "neon arm_aes", "altivec"

Definition at line 31 of file cpuid.cpp.

32 {
33 std::vector<std::string> flags;
34
35 auto append_fn = [&](bool flag, const char* flag_name)
36 {
37 if(flag)
38 flags.push_back(flag_name);
39 };
40
41 // NOLINTNEXTLINE(*-macro-usage)
42#define CPUID_PRINT(flag) append_fn(has_##flag(), #flag)
43
44#if defined(BOTAN_TARGET_CPU_IS_X86_FAMILY)
45 CPUID_PRINT(rdtsc);
46
47 CPUID_PRINT(sse2);
48 CPUID_PRINT(ssse3);
49 CPUID_PRINT(avx2);
50
51 CPUID_PRINT(bmi2);
52 CPUID_PRINT(adx);
53
54 CPUID_PRINT(aes_ni);
55 CPUID_PRINT(clmul);
56 CPUID_PRINT(rdrand);
57 CPUID_PRINT(rdseed);
58 CPUID_PRINT(intel_sha);
59
60 CPUID_PRINT(avx512);
61 CPUID_PRINT(avx512_aes);
62 CPUID_PRINT(avx512_clmul);
63#elif defined(BOTAN_TARGET_CPU_IS_PPC_FAMILY)
64 CPUID_PRINT(altivec);
65 CPUID_PRINT(power_crypto);
66 CPUID_PRINT(darn_rng);
67#elif defined(BOTAN_TARGET_CPU_IS_ARM_FAMILY)
68 CPUID_PRINT(neon);
69 CPUID_PRINT(arm_sve);
70
71 CPUID_PRINT(arm_sha1);
72 CPUID_PRINT(arm_sha2);
73 CPUID_PRINT(arm_aes);
74 CPUID_PRINT(arm_pmull);
75 CPUID_PRINT(arm_sha2_512);
76 CPUID_PRINT(arm_sha3);
77 CPUID_PRINT(arm_sm3);
78 CPUID_PRINT(arm_sm4);
79#else
80 BOTAN_UNUSED(append_fn);
81#endif
82
83#undef CPUID_PRINT
84
85 return string_join(flags, ' ');
86 }
CPUID_PRINT
#define CPUID_PRINT(flag)
Botan::PKCS11::flags
Flags flags(Flag flags)
Definition: p11.h:860
Botan::string_join
std::string string_join(const std::vector< std::string > &strs, char delim)
Definition: parsing.cpp:147

References BOTAN_UNUSED, CPUID_PRINT, and Botan::string_join().

The documentation for this class was generated from the following files:
Generated by doxygen 1.9.6