Merge pull request wolfSSL#10199 from douzzer/20260412-clang-23_pre20260331

SparkiDev · web-flow · commit a50a5403a79c · 2026-04-13T10:39:11.000+10:00
20260412-clang-23_pre20260331
diff --git a/tests/api/test_ossl_x509_str.c b/tests/api/test_ossl_x509_str.c
@@ -1074,6 +1074,7 @@ int test_X509_STORE_InvalidCa(void)
     ExpectIntEQ(X509_STORE_CTX_init(ctx, str, cert, untrusted), 1);
     ExpectIntEQ(X509_verify_cert(ctx), 1);
     ExpectIntEQ(last_errcode, X509_V_ERR_INVALID_CA);
+    (void)last_errdepth;
     /* Defense in depth: ctx->error must not be clobbered back to X509_V_OK
      * by the later successful verification of the intermediate against the
      * trusted root.  The worst-seen error must persist. */
diff --git a/wolfcrypt/benchmark/benchmark.c b/wolfcrypt/benchmark/benchmark.c
@@ -4231,6 +4231,8 @@ static void* benchmarks_do(void* args)
     if (bench_all || (bench_kdf_algs & BENCH_SRTP_KDF)) {
         bench_srtpkdf();
     }
+#else
+    (void)bench_kdf_algs;
 #endif
 
 #ifdef HAVE_SCRYPT
@@ -4400,6 +4402,7 @@ static void* benchmarks_do(void* args)
     }
 #endif
 #endif
+    (void)bench_pq_hash_sig_algs;
 
 #if defined(HAVE_ECC) && !defined(WC_NO_RNG)
     if (bench_all || (bench_asym_algs & BENCH_ECC_MAKEKEY) ||
diff --git a/wolfcrypt/src/sha256.c b/wolfcrypt/src/sha256.c
@@ -562,7 +562,9 @@ static int InitSha256(wc_Sha256* sha256)
                                          word32 len);
                                                                     /* = NULL */
     static int transform_check = 0;
+    #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS
     static int Transform_Sha256_is_vectorized = 0;
+    #endif
 
     static WC_INLINE int inline_XTRANSFORM(wc_Sha256* S, const byte* D) {
         int ret;
@@ -607,14 +609,18 @@ static int InitSha256(wc_Sha256* sha256)
             if (IS_INTEL_AVX1(intel_flags)) {
                 Transform_Sha256_p = Transform_Sha256_AVX1_Sha;
                 Transform_Sha256_Len_p = Transform_Sha256_AVX1_Sha_Len;
+            #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS
                 Transform_Sha256_is_vectorized = 1;
+            #endif
             }
             else
         #endif
             {
                 Transform_Sha256_p = Transform_Sha256_SSE2_Sha;
                 Transform_Sha256_Len_p = Transform_Sha256_SSE2_Sha_Len;
+            #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS
                 Transform_Sha256_is_vectorized = 1;
+            #endif
             }
         }
         else
@@ -624,14 +630,18 @@ static int InitSha256(wc_Sha256* sha256)
             if (IS_INTEL_BMI2(intel_flags)) {
                 Transform_Sha256_p = Transform_Sha256_AVX2_RORX;
                 Transform_Sha256_Len_p = Transform_Sha256_AVX2_RORX_Len;
+            #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS
                 Transform_Sha256_is_vectorized = 1;
+            #endif
             }
             else
         #endif
             {
                 Transform_Sha256_p = Transform_Sha256_AVX2;
                 Transform_Sha256_Len_p = Transform_Sha256_AVX2_Len;
+            #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS
                 Transform_Sha256_is_vectorized = 1;
+            #endif
             }
         }
         else
@@ -642,22 +652,28 @@ static int InitSha256(wc_Sha256* sha256)
             if (IS_INTEL_BMI2(intel_flags)) {
                 Transform_Sha256_p = Transform_Sha256_AVX1_RORX;
                 Transform_Sha256_Len_p = Transform_Sha256_AVX1_RORX_Len;
+            #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS
                 Transform_Sha256_is_vectorized = 1;
+            #endif
             }
             else
         #endif
             {
                 Transform_Sha256_p = Transform_Sha256_AVX1;
                 Transform_Sha256_Len_p = Transform_Sha256_AVX1_Len;
+            #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS
                 Transform_Sha256_is_vectorized = 1;
+            #endif
             }
         }
         else
     #endif
         {
             Transform_Sha256_p = Transform_Sha256;
             Transform_Sha256_Len_p = NULL;
+        #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS
             Transform_Sha256_is_vectorized = 0;
+        #endif
         }
 
         transform_check = 1;
diff --git a/wolfcrypt/src/sha512.c b/wolfcrypt/src/sha512.c
@@ -722,7 +722,9 @@ static int InitSha512_256(wc_Sha512* sha512)
     static int (*Transform_Sha512_p)(wc_Sha512* sha512) = _Transform_Sha512;
     static int (*Transform_Sha512_Len_p)(wc_Sha512* sha512, word32 len) = NULL;
     static int transform_check = 0;
+    #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS
     static int Transform_Sha512_is_vectorized = 0;
+    #endif
 
     static WC_INLINE int Transform_Sha512(wc_Sha512 *sha512) {
         int ret;
@@ -764,14 +766,18 @@ static int InitSha512_256(wc_Sha512* sha512)
             if (IS_INTEL_BMI2(intel_flags)) {
                 Transform_Sha512_p = Transform_Sha512_AVX2_RORX;
                 Transform_Sha512_Len_p = Transform_Sha512_AVX2_RORX_Len;
+            #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS
                 Transform_Sha512_is_vectorized = 1;
+            #endif
             }
             else
         #endif
             {
                 Transform_Sha512_p = Transform_Sha512_AVX2;
                 Transform_Sha512_Len_p = Transform_Sha512_AVX2_Len;
+            #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS
                 Transform_Sha512_is_vectorized = 1;
+            #endif
             }
         }
         else
@@ -782,22 +788,28 @@ static int InitSha512_256(wc_Sha512* sha512)
             if (IS_INTEL_BMI2(intel_flags)) {
                 Transform_Sha512_p = Transform_Sha512_AVX1_RORX;
                 Transform_Sha512_Len_p = Transform_Sha512_AVX1_RORX_Len;
+            #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS
                 Transform_Sha512_is_vectorized = 1;
+            #endif
             }
             else
         #endif
             {
                 Transform_Sha512_p = Transform_Sha512_AVX1;
                 Transform_Sha512_Len_p = Transform_Sha512_AVX1_Len;
+            #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS
                 Transform_Sha512_is_vectorized = 1;
+            #endif
             }
         }
         else
     #endif
         {
             Transform_Sha512_p = _Transform_Sha512;
             Transform_Sha512_Len_p = NULL;
+        #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS
             Transform_Sha512_is_vectorized = 0;
+        #endif
         }
 
         transform_check = 1;

Original file line number	Diff line number	Diff line change
`@@ -4231,6 +4231,8 @@ static void* benchmarks_do(void* args)`
`4231`	`4231`	`if (bench_all \|\| (bench_kdf_algs & BENCH_SRTP_KDF)) {`
`4232`	`4232`	`bench_srtpkdf();`
`4233`	`4233`	`}`
	`4234`	`+#else`
	`4235`	`+ (void)bench_kdf_algs;`
`4234`	`4236`	`#endif`
`4235`	`4237`
`4236`	`4238`	`#ifdef HAVE_SCRYPT`
`@@ -4400,6 +4402,7 @@ static void* benchmarks_do(void* args)`
`4400`	`4402`	`}`
`4401`	`4403`	`#endif`
`4402`	`4404`	`#endif`
	`4405`	`+ (void)bench_pq_hash_sig_algs;`
`4403`	`4406`
`4404`	`4407`	`#if defined(HAVE_ECC) && !defined(WC_NO_RNG)`
`4405`	`4408`	`if (bench_all \|\| (bench_asym_algs & BENCH_ECC_MAKEKEY) \|\|`
Original file line number	Diff line number	Diff line change
`@@ -562,7 +562,9 @@ static int InitSha256(wc_Sha256* sha256)`
`562`	`562`	`word32 len);`
`563`	`563`	`/* = NULL */`
`564`	`564`	`static int transform_check = 0;`
	`565`	`+ #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS`
`565`	`566`	`static int Transform_Sha256_is_vectorized = 0;`
	`567`	`+ #endif`
`566`	`568`
`567`	`569`	`static WC_INLINE int inline_XTRANSFORM(wc_Sha256* S, const byte* D) {`
`568`	`570`	`int ret;`
`@@ -607,14 +609,18 @@ static int InitSha256(wc_Sha256* sha256)`
`607`	`609`	`if (IS_INTEL_AVX1(intel_flags)) {`
`608`	`610`	`Transform_Sha256_p = Transform_Sha256_AVX1_Sha;`
`609`	`611`	`Transform_Sha256_Len_p = Transform_Sha256_AVX1_Sha_Len;`
	`612`	`+ #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS`
`610`	`613`	`Transform_Sha256_is_vectorized = 1;`
	`614`	`+ #endif`
`611`	`615`	`}`
`612`	`616`	`else`
`613`	`617`	`#endif`
`614`	`618`	`{`
`615`	`619`	`Transform_Sha256_p = Transform_Sha256_SSE2_Sha;`
`616`	`620`	`Transform_Sha256_Len_p = Transform_Sha256_SSE2_Sha_Len;`
	`621`	`+ #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS`
`617`	`622`	`Transform_Sha256_is_vectorized = 1;`
	`623`	`+ #endif`
`618`	`624`	`}`
`619`	`625`	`}`
`620`	`626`	`else`
`@@ -624,14 +630,18 @@ static int InitSha256(wc_Sha256* sha256)`
`624`	`630`	`if (IS_INTEL_BMI2(intel_flags)) {`
`625`	`631`	`Transform_Sha256_p = Transform_Sha256_AVX2_RORX;`
`626`	`632`	`Transform_Sha256_Len_p = Transform_Sha256_AVX2_RORX_Len;`
	`633`	`+ #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS`
`627`	`634`	`Transform_Sha256_is_vectorized = 1;`
	`635`	`+ #endif`
`628`	`636`	`}`
`629`	`637`	`else`
`630`	`638`	`#endif`
`631`	`639`	`{`
`632`	`640`	`Transform_Sha256_p = Transform_Sha256_AVX2;`
`633`	`641`	`Transform_Sha256_Len_p = Transform_Sha256_AVX2_Len;`
	`642`	`+ #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS`
`634`	`643`	`Transform_Sha256_is_vectorized = 1;`
	`644`	`+ #endif`
`635`	`645`	`}`
`636`	`646`	`}`
`637`	`647`	`else`
`@@ -642,22 +652,28 @@ static int InitSha256(wc_Sha256* sha256)`
`642`	`652`	`if (IS_INTEL_BMI2(intel_flags)) {`
`643`	`653`	`Transform_Sha256_p = Transform_Sha256_AVX1_RORX;`
`644`	`654`	`Transform_Sha256_Len_p = Transform_Sha256_AVX1_RORX_Len;`
	`655`	`+ #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS`
`645`	`656`	`Transform_Sha256_is_vectorized = 1;`
	`657`	`+ #endif`
`646`	`658`	`}`
`647`	`659`	`else`
`648`	`660`	`#endif`
`649`	`661`	`{`
`650`	`662`	`Transform_Sha256_p = Transform_Sha256_AVX1;`
`651`	`663`	`Transform_Sha256_Len_p = Transform_Sha256_AVX1_Len;`
	`664`	`+ #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS`
`652`	`665`	`Transform_Sha256_is_vectorized = 1;`
	`666`	`+ #endif`
`653`	`667`	`}`
`654`	`668`	`}`
`655`	`669`	`else`
`656`	`670`	`#endif`
`657`	`671`	`{`
`658`	`672`	`Transform_Sha256_p = Transform_Sha256;`
`659`	`673`	`Transform_Sha256_Len_p = NULL;`
	`674`	`+ #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS`
`660`	`675`	`Transform_Sha256_is_vectorized = 0;`
	`676`	`+ #endif`
`661`	`677`	`}`
`662`	`678`
`663`	`679`	`transform_check = 1;`
Original file line number	Diff line number	Diff line change
`@@ -722,7 +722,9 @@ static int InitSha512_256(wc_Sha512* sha512)`
`722`	`722`	`static int (Transform_Sha512_p)(wc_Sha512 sha512) = _Transform_Sha512;`
`723`	`723`	`static int (Transform_Sha512_Len_p)(wc_Sha512 sha512, word32 len) = NULL;`
`724`	`724`	`static int transform_check = 0;`
	`725`	`+ #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS`
`725`	`726`	`static int Transform_Sha512_is_vectorized = 0;`
	`727`	`+ #endif`
`726`	`728`
`727`	`729`	`static WC_INLINE int Transform_Sha512(wc_Sha512 *sha512) {`
`728`	`730`	`int ret;`
`@@ -764,14 +766,18 @@ static int InitSha512_256(wc_Sha512* sha512)`
`764`	`766`	`if (IS_INTEL_BMI2(intel_flags)) {`
`765`	`767`	`Transform_Sha512_p = Transform_Sha512_AVX2_RORX;`
`766`	`768`	`Transform_Sha512_Len_p = Transform_Sha512_AVX2_RORX_Len;`
	`769`	`+ #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS`
`767`	`770`	`Transform_Sha512_is_vectorized = 1;`
	`771`	`+ #endif`
`768`	`772`	`}`
`769`	`773`	`else`
`770`	`774`	`#endif`
`771`	`775`	`{`
`772`	`776`	`Transform_Sha512_p = Transform_Sha512_AVX2;`
`773`	`777`	`Transform_Sha512_Len_p = Transform_Sha512_AVX2_Len;`
	`778`	`+ #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS`
`774`	`779`	`Transform_Sha512_is_vectorized = 1;`
	`780`	`+ #endif`
`775`	`781`	`}`
`776`	`782`	`}`
`777`	`783`	`else`
`@@ -782,22 +788,28 @@ static int InitSha512_256(wc_Sha512* sha512)`
`782`	`788`	`if (IS_INTEL_BMI2(intel_flags)) {`
`783`	`789`	`Transform_Sha512_p = Transform_Sha512_AVX1_RORX;`
`784`	`790`	`Transform_Sha512_Len_p = Transform_Sha512_AVX1_RORX_Len;`
	`791`	`+ #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS`
`785`	`792`	`Transform_Sha512_is_vectorized = 1;`
	`793`	`+ #endif`
`786`	`794`	`}`
`787`	`795`	`else`
`788`	`796`	`#endif`
`789`	`797`	`{`
`790`	`798`	`Transform_Sha512_p = Transform_Sha512_AVX1;`
`791`	`799`	`Transform_Sha512_Len_p = Transform_Sha512_AVX1_Len;`
	`800`	`+ #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS`
`792`	`801`	`Transform_Sha512_is_vectorized = 1;`
	`802`	`+ #endif`
`793`	`803`	`}`
`794`	`804`	`}`
`795`	`805`	`else`
`796`	`806`	`#endif`
`797`	`807`	`{`
`798`	`808`	`Transform_Sha512_p = _Transform_Sha512;`
`799`	`809`	`Transform_Sha512_Len_p = NULL;`
	`810`	`+ #ifdef WOLFSSL_USE_SAVE_VECTOR_REGISTERS`
`800`	`811`	`Transform_Sha512_is_vectorized = 0;`
	`812`	`+ #endif`
`801`	`813`	`}`
`802`	`814`
`803`	`815`	`transform_check = 1;`