5144927186

Committed 01 Jun 2023 01:25PM UTC coverage: 91.716% (-0.03%) from 91.742%

Build # 5144927186

Build Type

push

github

Committed by

randombit

Commit Message

Ignore this clang-tidy warning for now

Run Details

76171 of 83051 relevant lines covered (91.72%)

11840460.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.81

/src/lib/utils/cpuid/cpuid.cpp

/*
* Runtime CPU detection
* (C) 2009,2010,2013,2017,2023 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/internal/cpuid.h>

#include <botan/exceptn.h>
#include <botan/types.h>
#include <botan/internal/os_utils.h>
#include <botan/internal/parsing.h>
#include <ostream>

namespace Botan {

bool CPUID::has_simd_32() {
#if defined(BOTAN_TARGET_SUPPORTS_SSE2)
   return CPUID::has_sse2();
#elif defined(BOTAN_TARGET_SUPPORTS_ALTIVEC)
   return CPUID::has_altivec();
#elif defined(BOTAN_TARGET_SUPPORTS_NEON)
   return CPUID::has_neon();
#else
   return true;
#endif
}

//static
std::string CPUID::to_string() {
   std::vector<std::string> flags;

   auto append_fn = [&](bool flag, const char* flag_name) {
      if(flag) {
         flags.push_back(flag_name);
      }
   };

   // NOLINTNEXTLINE(*-macro-usage)
#define CPUID_PRINT(flag) append_fn(has_##flag(), #flag)

#if defined(BOTAN_TARGET_CPU_IS_X86_FAMILY)
   CPUID_PRINT(rdtsc);

   CPUID_PRINT(sse2);
   CPUID_PRINT(ssse3);
   CPUID_PRINT(avx2);

   CPUID_PRINT(bmi2);
   CPUID_PRINT(adx);

   CPUID_PRINT(aes_ni);
   CPUID_PRINT(clmul);
   CPUID_PRINT(rdrand);
   CPUID_PRINT(rdseed);
   CPUID_PRINT(intel_sha);

   CPUID_PRINT(avx512);
   CPUID_PRINT(avx512_aes);
   CPUID_PRINT(avx512_clmul);
#elif defined(BOTAN_TARGET_CPU_IS_PPC_FAMILY)
   CPUID_PRINT(altivec);
   CPUID_PRINT(power_crypto);
   CPUID_PRINT(darn_rng);
#elif defined(BOTAN_TARGET_CPU_IS_ARM_FAMILY)
   CPUID_PRINT(neon);
   CPUID_PRINT(arm_sve);

   CPUID_PRINT(arm_sha1);
   CPUID_PRINT(arm_sha2);
   CPUID_PRINT(arm_aes);
   CPUID_PRINT(arm_pmull);
   CPUID_PRINT(arm_sha2_512);
   CPUID_PRINT(arm_sha3);
   CPUID_PRINT(arm_sm3);
   CPUID_PRINT(arm_sm4);
#else
   BOTAN_UNUSED(append_fn);
#endif

#undef CPUID_PRINT

   return string_join(flags, ' ');
}

//static
void CPUID::initialize() { state() = CPUID_Data(); }

namespace {

// Returns true if big-endian
bool runtime_check_if_big_endian() {
   // Check runtime endian
   const uint32_t endian32 = 0x01234567;
   const uint8_t* e8 = reinterpret_cast<const uint8_t*>(&endian32);

   bool is_big_endian = false;

   if(e8[0] == 0x01 && e8[1] == 0x23 && e8[2] == 0x45 && e8[3] == 0x67) {
      is_big_endian = true;
   } else if(e8[0] == 0x67 && e8[1] == 0x45 && e8[2] == 0x23 && e8[3] == 0x01) {
      is_big_endian = false;
   } else {
      throw Internal_Error("Unexpected endian at runtime, neither big nor little");
   }

   // If we were compiled with a known endian, verify it matches at runtime
#if defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
   BOTAN_ASSERT(!is_big_endian, "Build and runtime endian match");
#elif defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
   BOTAN_ASSERT(is_big_endian, "Build and runtime endian match");
#endif

   return is_big_endian;
}

}  // namespace

CPUID::CPUID_Data::CPUID_Data() {
   m_processor_features = 0;

#if defined(BOTAN_TARGET_CPU_IS_PPC_FAMILY) || defined(BOTAN_TARGET_CPU_IS_ARM_FAMILY) || \
   defined(BOTAN_TARGET_CPU_IS_X86_FAMILY)

   m_processor_features = detect_cpu_features();

#endif

   m_processor_features |= CPUID::CPUID_INITIALIZED_BIT;

   if(runtime_check_if_big_endian()) {
      m_processor_features |= CPUID::CPUID_IS_BIG_ENDIAN_BIT;
   }

   std::string clear_cpuid_env;
   if(OS::read_env_variable(clear_cpuid_env, "BOTAN_CLEAR_CPUID")) {
      for(const auto& cpuid : split_on(clear_cpuid_env, ',')) {
         for(auto& bit : CPUID::bit_from_string(cpuid)) {
            const uint32_t cleared = ~static_cast<uint32_t>(bit);
            m_processor_features &= cleared;
         }
      }
   }
}

std::vector<CPUID::CPUID_bits> CPUID::bit_from_string(std::string_view tok) {
#if defined(BOTAN_TARGET_CPU_IS_X86_FAMILY)
   if(tok == "sse2" || tok == "simd") {
      return {CPUID::CPUID_SSE2_BIT};
   }
   if(tok == "ssse3") {
      return {CPUID::CPUID_SSSE3_BIT};
   }
   // aes_ni is the string printed on the console when running "botan cpuid"
   if(tok == "aesni" || tok == "aes_ni") {
      return {CPUID::CPUID_AESNI_BIT};
   }
   if(tok == "clmul") {
      return {CPUID::CPUID_CLMUL_BIT};
   }
   if(tok == "avx2") {
      return {CPUID::CPUID_AVX2_BIT};
   }
   if(tok == "avx512") {
      return {CPUID::CPUID_AVX512_BIT};
   }
   // there were two if statements testing "sha" and "intel_sha" separately; combined
   if(tok == "sha" || tok == "intel_sha") {
      return {CPUID::CPUID_SHA_BIT};
   }
   if(tok == "rdtsc") {
      return {CPUID::CPUID_RDTSC_BIT};
   }
   if(tok == "bmi2") {
      return {CPUID::CPUID_BMI_BIT};
   }
   if(tok == "adx") {
      return {CPUID::CPUID_ADX_BIT};
   }
   if(tok == "rdrand") {
      return {CPUID::CPUID_RDRAND_BIT};
   }
   if(tok == "rdseed") {
      return {CPUID::CPUID_RDSEED_BIT};
   }
   if(tok == "avx512_aes") {
      return {CPUID::CPUID_AVX512_AES_BIT};
   }
   if(tok == "avx512_clmul") {
      return {CPUID::CPUID_AVX512_CLMUL_BIT};
   }

#elif defined(BOTAN_TARGET_CPU_IS_PPC_FAMILY)
   if(tok == "altivec" || tok == "simd")
      return {CPUID::CPUID_ALTIVEC_BIT};
   if(tok == "power_crypto")
      return {CPUID::CPUID_POWER_CRYPTO_BIT};
   if(tok == "darn_rng")
      return {CPUID::CPUID_DARN_BIT};

#elif defined(BOTAN_TARGET_CPU_IS_ARM_FAMILY)
   if(tok == "neon" || tok == "simd")
      return {CPUID::CPUID_ARM_NEON_BIT};
   if(tok == "arm_sve")
      return {CPUID::CPUID_ARM_SVE_BIT};
   if(tok == "armv8sha1" || tok == "arm_sha1")
      return {CPUID::CPUID_ARM_SHA1_BIT};
   if(tok == "armv8sha2" || tok == "arm_sha2")
      return {CPUID::CPUID_ARM_SHA2_BIT};
   if(tok == "armv8aes" || tok == "arm_aes")
      return {CPUID::CPUID_ARM_AES_BIT};
   if(tok == "armv8pmull" || tok == "arm_pmull")
      return {CPUID::CPUID_ARM_PMULL_BIT};
   if(tok == "armv8sha3" || tok == "arm_sha3")
      return {CPUID::CPUID_ARM_SHA3_BIT};
   if(tok == "armv8sha2_512" || tok == "arm_sha2_512")
      return {CPUID::CPUID_ARM_SHA2_512_BIT};
   if(tok == "armv8sm3" || tok == "arm_sm3")
      return {CPUID::CPUID_ARM_SM3_BIT};
   if(tok == "armv8sm4" || tok == "arm_sm4")
      return {CPUID::CPUID_ARM_SM4_BIT};

#else
   BOTAN_UNUSED(tok);
#endif

   return {};
}

}  // namespace Botan

1	/*
2	* Runtime CPU detection
3	* (C) 2009,2010,2013,2017,2023 Jack Lloyd
4	*
5	* Botan is released under the Simplified BSD License (see license.txt)
6	*/
7
8	#include <botan/internal/cpuid.h>
9
10	#include <botan/exceptn.h>
11	#include <botan/types.h>
12	#include <botan/internal/os_utils.h>
13	#include <botan/internal/parsing.h>
14	#include <ostream>
15
16	namespace Botan {
17
18	bool CPUID::has_simd_32() {	299,205✔
19	#if defined(BOTAN_TARGET_SUPPORTS_SSE2)
20	return CPUID::has_sse2();	299,205✔
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	}
29
30	//static
31	std::string CPUID::to_string() {	14✔
32	std::vector<std::string> flags;	14✔
33
34	auto append_fn = [&](bool flag, const char* flag_name) {	210✔
35	if(flag) {	196✔
36	flags.push_back(flag_name);	196✔
37	}
38	};	196✔
39
40	// NOLINTNEXTLINE(*-macro-usage)
41	#define CPUID_PRINT(flag) append_fn(has_##flag(), #flag)
42
43	#if defined(BOTAN_TARGET_CPU_IS_X86_FAMILY)
44	CPUID_PRINT(rdtsc);	14✔
45
46	CPUID_PRINT(sse2);	14✔
47	CPUID_PRINT(ssse3);	14✔
48	CPUID_PRINT(avx2);	14✔
49
50	CPUID_PRINT(bmi2);	14✔
51	CPUID_PRINT(adx);	14✔
52
53	CPUID_PRINT(aes_ni);	14✔
54	CPUID_PRINT(clmul);	14✔
55	CPUID_PRINT(rdrand);	14✔
56	CPUID_PRINT(rdseed);	14✔
57	CPUID_PRINT(intel_sha);	14✔
58
59	CPUID_PRINT(avx512);	14✔
60	CPUID_PRINT(avx512_aes);	14✔
61	CPUID_PRINT(avx512_clmul);	14✔
62	#elif defined(BOTAN_TARGET_CPU_IS_PPC_FAMILY)
63	CPUID_PRINT(altivec);
64	CPUID_PRINT(power_crypto);
65	CPUID_PRINT(darn_rng);
66	#elif defined(BOTAN_TARGET_CPU_IS_ARM_FAMILY)
67	CPUID_PRINT(neon);
68	CPUID_PRINT(arm_sve);
69
70	CPUID_PRINT(arm_sha1);
71	CPUID_PRINT(arm_sha2);
72	CPUID_PRINT(arm_aes);
73	CPUID_PRINT(arm_pmull);
74	CPUID_PRINT(arm_sha2_512);
75	CPUID_PRINT(arm_sha3);
76	CPUID_PRINT(arm_sm3);
77	CPUID_PRINT(arm_sm4);
78	#else
79	BOTAN_UNUSED(append_fn);
80	#endif
81
82	#undef CPUID_PRINT
83
84	return string_join(flags, ' ');	28✔
85	}	14✔
86
87	//static
88	void CPUID::initialize() { state() = CPUID_Data(); }	5,604✔
89
90	namespace {
91
92	// Returns true if big-endian
93	bool runtime_check_if_big_endian() {	12,839✔
94	// Check runtime endian
95	const uint32_t endian32 = 0x01234567;	12,839✔
96	const uint8_t* e8 = reinterpret_cast<const uint8_t*>(&endian32);	12,839✔
97
98	bool is_big_endian = false;	12,839✔
99
100	if(e8[0] == 0x01 && e8[1] == 0x23 && e8[2] == 0x45 && e8[3] == 0x67) {	12,839✔
101	is_big_endian = true;
102	} else if(e8[0] == 0x67 && e8[1] == 0x45 && e8[2] == 0x23 && e8[3] == 0x01) {	12,839✔
103	is_big_endian = false;
104	} else {
105	throw Internal_Error("Unexpected endian at runtime, neither big nor little");
106	}
107
108	// If we were compiled with a known endian, verify it matches at runtime
109	#if defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
110	BOTAN_ASSERT(!is_big_endian, "Build and runtime endian match");	12,839✔
111	#elif defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
112	BOTAN_ASSERT(is_big_endian, "Build and runtime endian match");
113	#endif
114
115	return is_big_endian;	12,839✔
116	}
117
118	} // namespace
119
120	CPUID::CPUID_Data::CPUID_Data() {	12,839✔
121	m_processor_features = 0;	12,839✔
122
123	#if defined(BOTAN_TARGET_CPU_IS_PPC_FAMILY) \|\| defined(BOTAN_TARGET_CPU_IS_ARM_FAMILY) \|\| \
124	defined(BOTAN_TARGET_CPU_IS_X86_FAMILY)
125
126	m_processor_features = detect_cpu_features();	12,839✔
127
128	#endif
129
130	m_processor_features \|= CPUID::CPUID_INITIALIZED_BIT;	12,839✔
131
132	if(runtime_check_if_big_endian()) {	12,839✔
133	m_processor_features \|= CPUID::CPUID_IS_BIG_ENDIAN_BIT;
134	}
135
136	std::string clear_cpuid_env;	12,839✔
137	if(OS::read_env_variable(clear_cpuid_env, "BOTAN_CLEAR_CPUID")) {	12,839✔
138	for(const auto& cpuid : split_on(clear_cpuid_env, ',')) {	282✔
139	for(auto& bit : CPUID::bit_from_string(cpuid)) {	282✔
140	const uint32_t cleared = ~static_cast<uint32_t>(bit);	141✔
141	m_processor_features &= cleared;	141✔
142	}	141✔
143	}	141✔
144	}
145	}	12,839✔
146
147	std::vector<CPUID::CPUID_bits> CPUID::bit_from_string(std::string_view tok) {	181✔
148	#if defined(BOTAN_TARGET_CPU_IS_X86_FAMILY)
149	if(tok == "sse2" \|\| tok == "simd") {	213✔
150	return {CPUID::CPUID_SSE2_BIT};	7✔
151	}
152	if(tok == "ssse3") {	183✔
153	return {CPUID::CPUID_SSSE3_BIT};	6✔
154	}
155	// aes_ni is the string printed on the console when running "botan cpuid"
156	if(tok == "aesni" \|\| tok == "aes_ni") {	315✔
157	return {CPUID::CPUID_AESNI_BIT};	4✔
158	}
159	if(tok == "clmul") {	167✔
160	return {CPUID::CPUID_CLMUL_BIT};	3✔
161	}
162	if(tok == "avx2") {	167✔
163	return {CPUID::CPUID_AVX2_BIT};	6✔
164	}
165	if(tok == "avx512") {	290✔
166	return {CPUID::CPUID_AVX512_BIT};	2✔
167	}
168	// there were two if statements testing "sha" and "intel_sha" separately; combined
169	if(tok == "sha" \|\| tok == "intel_sha") {	158✔
170	return {CPUID::CPUID_SHA_BIT};	3✔
171	}
172	if(tok == "rdtsc") {	152✔
173	return {CPUID::CPUID_RDTSC_BIT};	1✔
174	}
175	if(tok == "bmi2") {	151✔
176	return {CPUID::CPUID_BMI_BIT};	4✔
177	}
178	if(tok == "adx") {	145✔
179	return {CPUID::CPUID_ADX_BIT};	×
180	}
181	if(tok == "rdrand") {	146✔
182	return {CPUID::CPUID_RDRAND_BIT};	134✔
183	}
184	if(tok == "rdseed") {	12✔
185	return {CPUID::CPUID_RDSEED_BIT};	×
186	}
187	if(tok == "avx512_aes") {	11✔
188	return {CPUID::CPUID_AVX512_AES_BIT};	×
189	}
190	if(tok == "avx512_clmul") {	12✔
191	return {CPUID::CPUID_AVX512_CLMUL_BIT};	×
192	}
193
194	#elif defined(BOTAN_TARGET_CPU_IS_PPC_FAMILY)
195	if(tok == "altivec" \|\| tok == "simd")
196	return {CPUID::CPUID_ALTIVEC_BIT};
197	if(tok == "power_crypto")
198	return {CPUID::CPUID_POWER_CRYPTO_BIT};
199	if(tok == "darn_rng")
200	return {CPUID::CPUID_DARN_BIT};
201
202	#elif defined(BOTAN_TARGET_CPU_IS_ARM_FAMILY)
203	if(tok == "neon" \|\| tok == "simd")
204	return {CPUID::CPUID_ARM_NEON_BIT};
205	if(tok == "arm_sve")
206	return {CPUID::CPUID_ARM_SVE_BIT};
207	if(tok == "armv8sha1" \|\| tok == "arm_sha1")
208	return {CPUID::CPUID_ARM_SHA1_BIT};
209	if(tok == "armv8sha2" \|\| tok == "arm_sha2")
210	return {CPUID::CPUID_ARM_SHA2_BIT};
211	if(tok == "armv8aes" \|\| tok == "arm_aes")
212	return {CPUID::CPUID_ARM_AES_BIT};
213	if(tok == "armv8pmull" \|\| tok == "arm_pmull")
214	return {CPUID::CPUID_ARM_PMULL_BIT};
215	if(tok == "armv8sha3" \|\| tok == "arm_sha3")
216	return {CPUID::CPUID_ARM_SHA3_BIT};
217	if(tok == "armv8sha2_512" \|\| tok == "arm_sha2_512")
218	return {CPUID::CPUID_ARM_SHA2_512_BIT};
219	if(tok == "armv8sm3" \|\| tok == "arm_sm3")
220	return {CPUID::CPUID_ARM_SM3_BIT};
221	if(tok == "armv8sm4" \|\| tok == "arm_sm4")
222	return {CPUID::CPUID_ARM_SM4_BIT};
223
224	#else
225	BOTAN_UNUSED(tok);
226	#endif
227
228	return {};	11✔
229	}
230
231	} // namespace Botan

randombit / botan / 5144927186

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous