src/ssl.c and wolfssl/ssl.h: fix signature on wolfSSL_CTX_get0_privatekey() -- ctx is not const;

douzzer · douzzer · commit c430cc75eafa · 2025-11-13T17:11:52.000-06:00
wolfcrypt/src/wc_port.c and wolfssl/wolfcrypt/wc_port.h: tweak gates on atomic implementations to maximize availability within currently supported targets;

fix some whitespace.
diff --git a/.wolfssl_known_macro_extras b/.wolfssl_known_macro_extras
@@ -969,6 +969,7 @@ __ARCH_STRSTR_NO_REDIRECT
 __ARM_ARCH_7M__
 __ARM_FEATURE_CRYPTO
 __ASSEMBLER__
+__ATOMIC_CONSUME
 __ATOMIC_RELAXED
 __AVR_ARCH__
 __AVR__
diff --git a/src/ssl.c b/src/ssl.c
@@ -7559,7 +7559,7 @@ int wolfSSL_CTX_check_private_key(const WOLFSSL_CTX* ctx)
  * Return the private key of the WOLFSSL_CTX struct
  * @return WOLFSSL_EVP_PKEY* The caller doesn *NOT*` free the returned object.
  */
-WOLFSSL_EVP_PKEY* wolfSSL_CTX_get0_privatekey(const WOLFSSL_CTX* ctx)
+WOLFSSL_EVP_PKEY* wolfSSL_CTX_get0_privatekey(WOLFSSL_CTX* ctx)
 {
     WOLFSSL_EVP_PKEY* res;
     const unsigned char *key;
diff --git a/wolfcrypt/src/wc_port.c b/wolfcrypt/src/wc_port.c
@@ -1273,75 +1273,80 @@ char* wc_strdup_ex(const char *src, int memType) {
 
 #if defined(WOLFSSL_ATOMIC_OPS) && !defined(SINGLE_THREADED)
 
-#ifdef HAVE_C___ATOMIC
-/* Atomic ops using standard C lib */
-#ifdef __cplusplus
-/* C++ using direct calls to compiler built-in functions */
+#if defined(WOLFSSL_USER_DEFINED_ATOMICS)
+
+#elif defined(HAVE_C___ATOMIC) && defined(WOLFSSL_HAVE_ATOMIC_H)
+
+/* Default C Implementation */
 void wolfSSL_Atomic_Int_Init(wolfSSL_Atomic_Int* c, int i)
 {
-    *c = i;
+    atomic_init(c, i);
 }
 
 void wolfSSL_Atomic_Uint_Init(wolfSSL_Atomic_Uint* c, unsigned int i)
 {
-    *c = i;
+    atomic_init(c, i);
 }
 
 int wolfSSL_Atomic_Int_FetchAdd(wolfSSL_Atomic_Int* c, int i)
 {
-    return __atomic_fetch_add(c, i, __ATOMIC_RELAXED);
+    return atomic_fetch_add_explicit(c, i, memory_order_relaxed);
 }
 
 int wolfSSL_Atomic_Int_FetchSub(wolfSSL_Atomic_Int* c, int i)
 {
-    return __atomic_fetch_sub(c, i, __ATOMIC_RELAXED);
+    return atomic_fetch_sub_explicit(c, i, memory_order_relaxed);
 }
 
 int wolfSSL_Atomic_Int_AddFetch(wolfSSL_Atomic_Int* c, int i)
 {
-    return __atomic_add_fetch(c, i, __ATOMIC_RELAXED);
+    int ret = atomic_fetch_add_explicit(c, i, memory_order_relaxed);
+    return ret + i;
 }
 
 int wolfSSL_Atomic_Int_SubFetch(wolfSSL_Atomic_Int* c, int i)
 {
-    return __atomic_sub_fetch(c, i, __ATOMIC_RELAXED);
+    int ret = atomic_fetch_sub_explicit(c, i, memory_order_relaxed);
+    return ret - i;
 }
 
-int wolfSSL_Atomic_Int_CompareExchange(wolfSSL_Atomic_Int* c, int *expected_i,
-                                       int new_i)
+int wolfSSL_Atomic_Int_CompareExchange(
+    wolfSSL_Atomic_Int* c, int *expected_i, int new_i)
 {
     /* For the success path, use full synchronization with barriers --
      * "Sequentially-consistent ordering" -- so that all threads see the same
      * "single total modification order of all atomic operations" -- but on
      * failure we just need to be sure we acquire the value that changed out
      * from under us.
      */
-    return __atomic_compare_exchange_n(c, expected_i, new_i, 0 /* weak */,
-                                       __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
+    return atomic_compare_exchange_strong_explicit(
+        c, expected_i, new_i, memory_order_seq_cst, memory_order_acquire);
 }
 
 unsigned int wolfSSL_Atomic_Uint_FetchAdd(wolfSSL_Atomic_Uint* c,
                                           unsigned int i)
 {
-    return __atomic_fetch_add(c, i, __ATOMIC_RELAXED);
+    return atomic_fetch_add_explicit(c, i, memory_order_relaxed);
 }
 
 unsigned int wolfSSL_Atomic_Uint_FetchSub(wolfSSL_Atomic_Uint* c,
                                           unsigned int i)
 {
-    return __atomic_fetch_sub(c, i, __ATOMIC_RELAXED);
+    return atomic_fetch_sub_explicit(c, i, memory_order_relaxed);
 }
 
 unsigned int wolfSSL_Atomic_Uint_AddFetch(wolfSSL_Atomic_Uint* c,
                                           unsigned int i)
 {
-    return __atomic_add_fetch(c, i, __ATOMIC_RELAXED);
+    unsigned int ret = atomic_fetch_add_explicit(c, i, memory_order_relaxed);
+    return ret + i;
 }
 
 unsigned int wolfSSL_Atomic_Uint_SubFetch(wolfSSL_Atomic_Uint* c,
                                           unsigned int i)
 {
-    return __atomic_sub_fetch(c, i, __ATOMIC_RELAXED);
+    unsigned int ret = atomic_fetch_sub_explicit(c, i, memory_order_relaxed);
+    return ret - i;
 }
 
 int wolfSSL_Atomic_Uint_CompareExchange(
@@ -1353,89 +1358,90 @@ int wolfSSL_Atomic_Uint_CompareExchange(
      * failure we just need to be sure we acquire the value that changed out
      * from under us.
      */
-    return __atomic_compare_exchange_n(
-        c, expected_i, new_i, 0 /* weak */, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
+    return atomic_compare_exchange_strong_explicit(
+        c, expected_i, new_i, memory_order_seq_cst, memory_order_acquire);
 }
 
 int wolfSSL_Atomic_Ptr_CompareExchange(
     void **c, void **expected_ptr, void *new_ptr)
 {
+    /* use gcc-built-in __atomic_compare_exchange_n(), not
+     * atomic_compare_exchange_strong_explicit(), to sidestep _Atomic type
+     * requirements.
+     */
     return __atomic_compare_exchange_n(
-        c, expected_ptr, new_ptr, 0 /* weak */, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
+        c, expected_ptr, new_ptr, 0 /* weak */,
+        __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
 }
 
-#else
+#elif defined(__GNUC__) && defined(__ATOMIC_RELAXED)
+/* direct calls using gcc-style compiler built-ins */
 
-/* Default C Implementation */
 void wolfSSL_Atomic_Int_Init(wolfSSL_Atomic_Int* c, int i)
 {
-    atomic_init(c, i);
+    *c = i;
 }
 
 void wolfSSL_Atomic_Uint_Init(wolfSSL_Atomic_Uint* c, unsigned int i)
 {
-    atomic_init(c, i);
+    *c = i;
 }
 
 int wolfSSL_Atomic_Int_FetchAdd(wolfSSL_Atomic_Int* c, int i)
 {
-    return atomic_fetch_add_explicit(c, i, memory_order_relaxed);
+    return __atomic_fetch_add(c, i, __ATOMIC_RELAXED);
 }
 
 int wolfSSL_Atomic_Int_FetchSub(wolfSSL_Atomic_Int* c, int i)
 {
-    return atomic_fetch_sub_explicit(c, i, memory_order_relaxed);
+    return __atomic_fetch_sub(c, i, __ATOMIC_RELAXED);
 }
 
 int wolfSSL_Atomic_Int_AddFetch(wolfSSL_Atomic_Int* c, int i)
 {
-    int ret = atomic_fetch_add_explicit(c, i, memory_order_relaxed);
-    return ret + i;
+    return __atomic_add_fetch(c, i, __ATOMIC_RELAXED);
 }
 
 int wolfSSL_Atomic_Int_SubFetch(wolfSSL_Atomic_Int* c, int i)
 {
-    int ret = atomic_fetch_sub_explicit(c, i, memory_order_relaxed);
-    return ret - i;
+    return __atomic_sub_fetch(c, i, __ATOMIC_RELAXED);
 }
 
-int wolfSSL_Atomic_Int_CompareExchange(
-    wolfSSL_Atomic_Int* c, int *expected_i, int new_i)
+int wolfSSL_Atomic_Int_CompareExchange(wolfSSL_Atomic_Int* c, int *expected_i,
+                                       int new_i)
 {
     /* For the success path, use full synchronization with barriers --
      * "Sequentially-consistent ordering" -- so that all threads see the same
      * "single total modification order of all atomic operations" -- but on
      * failure we just need to be sure we acquire the value that changed out
      * from under us.
      */
-    return atomic_compare_exchange_strong_explicit(
-        c, expected_i, new_i, memory_order_seq_cst, memory_order_acquire);
+    return __atomic_compare_exchange_n(c, expected_i, new_i, 0 /* weak */,
+                                       __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
 }
 
 unsigned int wolfSSL_Atomic_Uint_FetchAdd(wolfSSL_Atomic_Uint* c,
                                           unsigned int i)
 {
-    return atomic_fetch_add_explicit(c, i, memory_order_relaxed);
+    return __atomic_fetch_add(c, i, __ATOMIC_RELAXED);
 }
 
 unsigned int wolfSSL_Atomic_Uint_FetchSub(wolfSSL_Atomic_Uint* c,
                                           unsigned int i)
 {
-    return atomic_fetch_sub_explicit(c, i, memory_order_relaxed);
+    return __atomic_fetch_sub(c, i, __ATOMIC_RELAXED);
 }
 
 unsigned int wolfSSL_Atomic_Uint_AddFetch(wolfSSL_Atomic_Uint* c,
                                           unsigned int i)
 {
-    unsigned int ret = atomic_fetch_add_explicit(c, i, memory_order_relaxed);
-    return ret + i;
+    return __atomic_add_fetch(c, i, __ATOMIC_RELAXED);
 }
 
 unsigned int wolfSSL_Atomic_Uint_SubFetch(wolfSSL_Atomic_Uint* c,
                                           unsigned int i)
 {
-    unsigned int ret = atomic_fetch_sub_explicit(c, i, memory_order_relaxed);
-    return ret - i;
+    return __atomic_sub_fetch(c, i, __ATOMIC_RELAXED);
 }
 
 int wolfSSL_Atomic_Uint_CompareExchange(
@@ -1447,24 +1453,19 @@ int wolfSSL_Atomic_Uint_CompareExchange(
      * failure we just need to be sure we acquire the value that changed out
      * from under us.
      */
-    return atomic_compare_exchange_strong_explicit(
-        c, expected_i, new_i, memory_order_seq_cst, memory_order_acquire);
+    return __atomic_compare_exchange_n(
+        c, expected_i, new_i, 0 /* weak */, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
 }
 
 int wolfSSL_Atomic_Ptr_CompareExchange(
     void **c, void **expected_ptr, void *new_ptr)
 {
-    /* use gcc-built-in __atomic_compare_exchange_n(), not
-     * atomic_compare_exchange_strong_explicit(), to sidestep _Atomic type
-     * requirements.
-     */
     return __atomic_compare_exchange_n(
-        c, expected_ptr, new_ptr, 0 /* weak */, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
+        c, expected_ptr, new_ptr, 0 /* weak */,
+        __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
 }
 
-#endif /* __cplusplus */
-
-#elif defined(_MSC_VER)
+#elif defined(_MSC_VER) && !defined(WOLFSSL_NOT_WINDOWS_API)
 
 void wolfSSL_Atomic_Int_Init(wolfSSL_Atomic_Int* c, int i)
 {
@@ -1545,8 +1546,8 @@ unsigned int wolfSSL_Atomic_Uint_SubFetch(wolfSSL_Atomic_Uint* c,
 int wolfSSL_Atomic_Uint_CompareExchange(
     wolfSSL_Atomic_Uint* c, unsigned int *expected_i, unsigned int new_i)
 {
-    long actual_i = InterlockedCompareExchange
-        ((wolfSSL_Atomic_Int *)c, (long)new_i, (long)*expected_i);
+    long actual_i = InterlockedCompareExchange(
+        (wolfSSL_Atomic_Int *)c, (long)new_i, (long)*expected_i);
     if (actual_i == (long)*expected_i) {
         return 1;
     }
@@ -1560,23 +1561,23 @@ int wolfSSL_Atomic_Uint_CompareExchange(
     void ** c, void **expected_ptr, void *new_ptr)
 {
 #ifdef _WIN64
-    LONG64 actual_ptr = InterlockedCompareExchange64
-    ((LONG64 *)c, (LONG64)new_i, (LONG64)*expected_i);
-    if (actual_ptr == (LONG64)*expected_i) {
+    LONG64 actual_ptr = InterlockedCompareExchange64(
+        (LONG64 *)c, (LONG64)new_ptr, (LONG64)*expected_ptr);
+    if (actual_ptr == (LONG64)*expected_ptr) {
         return 1;
     }
     else {
-        *expected_i = (void *)actual_ptr;
+        *expected_ptr = (void *)actual_ptr;
         return 0;
     }
 #else /* !_WIN64 */
-    LONG actual_ptr = InterlockedCompareExchange
-    ((LONG *)c, (LONG)new_i, (LONG)*expected_i);
-    if (actual_ptr == (LONG)*expected_i) {
+    LONG actual_ptr = InterlockedCompareExchange(
+        (LONG *)c, (LONG)new_ptr, (LONG)*expected_ptr);
+    if (actual_ptr == (LONG)*expected_ptr) {
         return 1;
     }
     else {
-        *expected_i = (void *)actual_ptr;
+        *expected_ptr = (void *)actual_ptr;
         return 0;
     }
 #endif /* !_WIN64 */
diff --git a/wolfssl/ssl.h b/wolfssl/ssl.h
@@ -3228,7 +3228,7 @@ WOLFSSL_API int wolfSSL_want_write(WOLFSSL* ssl);
 #ifdef OPENSSL_EXTRA
 WOLFSSL_API int wolfSSL_want(WOLFSSL* ssl);
 
-WOLFSSL_API WOLFSSL_EVP_PKEY* wolfSSL_CTX_get0_privatekey(const WOLFSSL_CTX* ctx);
+WOLFSSL_API WOLFSSL_EVP_PKEY* wolfSSL_CTX_get0_privatekey(WOLFSSL_CTX* ctx);
 
 #include <stdarg.h> /* var_arg */
 WOLFSSL_API int wolfSSL_BIO_vprintf(WOLFSSL_BIO* bio, const char* format,
diff --git a/wolfssl/wolfcrypt/wc_port.h b/wolfssl/wolfcrypt/wc_port.h
@@ -494,31 +494,25 @@
         #define WOLFSSL_ATOMIC_LOAD(x) (x)
         #define WOLFSSL_ATOMIC_STORE(x, val) (x) = (val)
         #define WOLFSSL_ATOMIC_OPS
-    #elif defined(HAVE_C___ATOMIC)
-        #ifdef __cplusplus
-            #if defined(__GNUC__) && defined(__ATOMIC_RELAXED)
-                /* C++ using direct calls to compiler built-in functions */
-                typedef volatile int wolfSSL_Atomic_Int;
-                typedef volatile unsigned int wolfSSL_Atomic_Uint;
-                #define WOLFSSL_ATOMIC_INITIALIZER(x) (x)
-                #define WOLFSSL_ATOMIC_LOAD(x) __atomic_load_n(&(x), \
-                                                               __ATOMIC_CONSUME)
-                #define WOLFSSL_ATOMIC_STORE(x, val) __atomic_store_n(&(x), \
-                                                          val, __ATOMIC_RELEASE)
-                #define WOLFSSL_ATOMIC_OPS
-            #endif
-        #else
-            #ifdef WOLFSSL_HAVE_ATOMIC_H
-                /* Default C Implementation */
-                #include <stdatomic.h>
-                typedef atomic_int wolfSSL_Atomic_Int;
-                typedef atomic_uint wolfSSL_Atomic_Uint;
-                #define WOLFSSL_ATOMIC_INITIALIZER(x) (x)
-                #define WOLFSSL_ATOMIC_LOAD(x) atomic_load(&(x))
-                #define WOLFSSL_ATOMIC_STORE(x, val) atomic_store(&(x), val)
-                #define WOLFSSL_ATOMIC_OPS
-            #endif /* WOLFSSL_HAVE_ATOMIC_H */
-        #endif
+    #elif defined(HAVE_C___ATOMIC) && defined(WOLFSSL_HAVE_ATOMIC_H)
+        /* Default C Implementation */
+        #include <stdatomic.h>
+        typedef atomic_int wolfSSL_Atomic_Int;
+        typedef atomic_uint wolfSSL_Atomic_Uint;
+        #define WOLFSSL_ATOMIC_INITIALIZER(x) (x)
+        #define WOLFSSL_ATOMIC_LOAD(x) atomic_load(&(x))
+        #define WOLFSSL_ATOMIC_STORE(x, val) atomic_store(&(x), val)
+        #define WOLFSSL_ATOMIC_OPS
+    #elif defined(__GNUC__) && defined(__ATOMIC_CONSUME)
+        /* direct calls using gcc-style compiler built-ins */
+        typedef volatile int wolfSSL_Atomic_Int;
+        typedef volatile unsigned int wolfSSL_Atomic_Uint;
+        #define WOLFSSL_ATOMIC_INITIALIZER(x) (x)
+        #define WOLFSSL_ATOMIC_LOAD(x) __atomic_load_n(&(x), \
+                                                       __ATOMIC_CONSUME)
+        #define WOLFSSL_ATOMIC_STORE(x, val) __atomic_store_n(&(x), \
+                                                  val, __ATOMIC_RELEASE)
+        #define WOLFSSL_ATOMIC_OPS
     #elif defined(_MSC_VER) && !defined(WOLFSSL_NOT_WINDOWS_API)
         /* Use MSVC compiler intrinsics for atomic ops */
         #ifdef _WIN32_WCE
@@ -534,8 +528,8 @@
         #define WOLFSSL_ATOMIC_OPS
     #endif
 
-    #ifndef WOLFSSL_ATOMIC_INITIALIZER
-        /* If we weren't able to implement atomics above, disable them here. */
+    /* If we weren't able to implement atomics above, disable them here. */
+    #ifndef WOLFSSL_ATOMIC_OPS
         #define WOLFSSL_NO_ATOMICS
     #endif
 #endif

Original file line number	Diff line number	Diff line change
`@@ -7559,7 +7559,7 @@ int wolfSSL_CTX_check_private_key(const WOLFSSL_CTX* ctx)`
`7559`	`7559`	`* Return the private key of the WOLFSSL_CTX struct`
`7560`	`7560`	* @return WOLFSSL_EVP_PKEY* The caller doesn NOT` free the returned object.
`7561`	`7561`	`*/`
`7562`		`-WOLFSSL_EVP_PKEY* wolfSSL_CTX_get0_privatekey(const WOLFSSL_CTX* ctx)`
	`7562`	`+WOLFSSL_EVP_PKEY* wolfSSL_CTX_get0_privatekey(WOLFSSL_CTX* ctx)`
`7563`	`7563`	`{`
`7564`	`7564`	`WOLFSSL_EVP_PKEY* res;`
`7565`	`7565`	`const unsigned char *key;`
Original file line number	Diff line number	Diff line change
`@@ -1273,75 +1273,80 @@ char* wc_strdup_ex(const char *src, int memType) {`
`1273`	`1273`
`1274`	`1274`	`#if defined(WOLFSSL_ATOMIC_OPS) && !defined(SINGLE_THREADED)`
`1275`	`1275`
`1276`		`-#ifdef HAVE_C___ATOMIC`
`1277`		`-/* Atomic ops using standard C lib */`
`1278`		`-#ifdef __cplusplus`
`1279`		`-/* C++ using direct calls to compiler built-in functions */`
	`1276`	`+#if defined(WOLFSSL_USER_DEFINED_ATOMICS)`
	`1277`	`+`
	`1278`	`+#elif defined(HAVE_C___ATOMIC) && defined(WOLFSSL_HAVE_ATOMIC_H)`
	`1279`	`+`
	`1280`	`+/* Default C Implementation */`
`1280`	`1281`	`void wolfSSL_Atomic_Int_Init(wolfSSL_Atomic_Int* c, int i)`
`1281`	`1282`	`{`
`1282`		`- *c = i;`
	`1283`	`+ atomic_init(c, i);`
`1283`	`1284`	`}`
`1284`	`1285`
`1285`	`1286`	`void wolfSSL_Atomic_Uint_Init(wolfSSL_Atomic_Uint* c, unsigned int i)`
`1286`	`1287`	`{`
`1287`		`- *c = i;`
	`1288`	`+ atomic_init(c, i);`
`1288`	`1289`	`}`
`1289`	`1290`
`1290`	`1291`	`int wolfSSL_Atomic_Int_FetchAdd(wolfSSL_Atomic_Int* c, int i)`
`1291`	`1292`	`{`
`1292`		`- return __atomic_fetch_add(c, i, __ATOMIC_RELAXED);`
	`1293`	`+ return atomic_fetch_add_explicit(c, i, memory_order_relaxed);`
`1293`	`1294`	`}`
`1294`	`1295`
`1295`	`1296`	`int wolfSSL_Atomic_Int_FetchSub(wolfSSL_Atomic_Int* c, int i)`
`1296`	`1297`	`{`
`1297`		`- return __atomic_fetch_sub(c, i, __ATOMIC_RELAXED);`
	`1298`	`+ return atomic_fetch_sub_explicit(c, i, memory_order_relaxed);`
`1298`	`1299`	`}`
`1299`	`1300`
`1300`	`1301`	`int wolfSSL_Atomic_Int_AddFetch(wolfSSL_Atomic_Int* c, int i)`
`1301`	`1302`	`{`
`1302`		`- return __atomic_add_fetch(c, i, __ATOMIC_RELAXED);`
	`1303`	`+ int ret = atomic_fetch_add_explicit(c, i, memory_order_relaxed);`
	`1304`	`+ return ret + i;`
`1303`	`1305`	`}`
`1304`	`1306`
`1305`	`1307`	`int wolfSSL_Atomic_Int_SubFetch(wolfSSL_Atomic_Int* c, int i)`
`1306`	`1308`	`{`
`1307`		`- return __atomic_sub_fetch(c, i, __ATOMIC_RELAXED);`
	`1309`	`+ int ret = atomic_fetch_sub_explicit(c, i, memory_order_relaxed);`
	`1310`	`+ return ret - i;`
`1308`	`1311`	`}`
`1309`	`1312`
`1310`		`-int wolfSSL_Atomic_Int_CompareExchange(wolfSSL_Atomic_Int* c, int *expected_i,`
`1311`		`- int new_i)`
	`1313`	`+int wolfSSL_Atomic_Int_CompareExchange(`
	`1314`	`+ wolfSSL_Atomic_Int* c, int *expected_i, int new_i)`
`1312`	`1315`	`{`
`1313`	`1316`	`/* For the success path, use full synchronization with barriers --`
`1314`	`1317`	`* "Sequentially-consistent ordering" -- so that all threads see the same`
`1315`	`1318`	`* "single total modification order of all atomic operations" -- but on`
`1316`	`1319`	`* failure we just need to be sure we acquire the value that changed out`
`1317`	`1320`	`* from under us.`
`1318`	`1321`	`*/`
`1319`		`- return __atomic_compare_exchange_n(c, expected_i, new_i, 0 /* weak */,`
`1320`		`- __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);`
	`1322`	`+ return atomic_compare_exchange_strong_explicit(`
	`1323`	`+ c, expected_i, new_i, memory_order_seq_cst, memory_order_acquire);`
`1321`	`1324`	`}`
`1322`	`1325`
`1323`	`1326`	`unsigned int wolfSSL_Atomic_Uint_FetchAdd(wolfSSL_Atomic_Uint* c,`
`1324`	`1327`	`unsigned int i)`
`1325`	`1328`	`{`
`1326`		`- return __atomic_fetch_add(c, i, __ATOMIC_RELAXED);`
	`1329`	`+ return atomic_fetch_add_explicit(c, i, memory_order_relaxed);`
`1327`	`1330`	`}`
`1328`	`1331`
`1329`	`1332`	`unsigned int wolfSSL_Atomic_Uint_FetchSub(wolfSSL_Atomic_Uint* c,`
`1330`	`1333`	`unsigned int i)`
`1331`	`1334`	`{`
`1332`		`- return __atomic_fetch_sub(c, i, __ATOMIC_RELAXED);`
	`1335`	`+ return atomic_fetch_sub_explicit(c, i, memory_order_relaxed);`
`1333`	`1336`	`}`
`1334`	`1337`
`1335`	`1338`	`unsigned int wolfSSL_Atomic_Uint_AddFetch(wolfSSL_Atomic_Uint* c,`
`1336`	`1339`	`unsigned int i)`
`1337`	`1340`	`{`
`1338`		`- return __atomic_add_fetch(c, i, __ATOMIC_RELAXED);`
	`1341`	`+ unsigned int ret = atomic_fetch_add_explicit(c, i, memory_order_relaxed);`
	`1342`	`+ return ret + i;`
`1339`	`1343`	`}`
`1340`	`1344`
`1341`	`1345`	`unsigned int wolfSSL_Atomic_Uint_SubFetch(wolfSSL_Atomic_Uint* c,`
`1342`	`1346`	`unsigned int i)`
`1343`	`1347`	`{`
`1344`		`- return __atomic_sub_fetch(c, i, __ATOMIC_RELAXED);`
	`1348`	`+ unsigned int ret = atomic_fetch_sub_explicit(c, i, memory_order_relaxed);`
	`1349`	`+ return ret - i;`
`1345`	`1350`	`}`
`1346`	`1351`
`1347`	`1352`	`int wolfSSL_Atomic_Uint_CompareExchange(`
`@@ -1353,89 +1358,90 @@ int wolfSSL_Atomic_Uint_CompareExchange(`
`1353`	`1358`	`* failure we just need to be sure we acquire the value that changed out`
`1354`	`1359`	`* from under us.`
`1355`	`1360`	`*/`
`1356`		`- return __atomic_compare_exchange_n(`
`1357`		`- c, expected_i, new_i, 0 /* weak */, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);`
	`1361`	`+ return atomic_compare_exchange_strong_explicit(`
	`1362`	`+ c, expected_i, new_i, memory_order_seq_cst, memory_order_acquire);`
`1358`	`1363`	`}`
`1359`	`1364`
`1360`	`1365`	`int wolfSSL_Atomic_Ptr_CompareExchange(`
`1361`	`1366`	`void c, void expected_ptr, void *new_ptr)`
`1362`	`1367`	`{`
	`1368`	`+ /* use gcc-built-in __atomic_compare_exchange_n(), not`
	`1369`	`+ * atomic_compare_exchange_strong_explicit(), to sidestep _Atomic type`
	`1370`	`+ * requirements.`
	`1371`	`+ */`
`1363`	`1372`	`return __atomic_compare_exchange_n(`
`1364`		`- c, expected_ptr, new_ptr, 0 /* weak */, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);`
	`1373`	`+ c, expected_ptr, new_ptr, 0 /* weak */,`
	`1374`	`+ __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);`
`1365`	`1375`	`}`
`1366`	`1376`
`1367`		`-#else`
	`1377`	`+#elif defined(__GNUC__) && defined(__ATOMIC_RELAXED)`
	`1378`	`+/* direct calls using gcc-style compiler built-ins */`
`1368`	`1379`
`1369`		`-/* Default C Implementation */`
`1370`	`1380`	`void wolfSSL_Atomic_Int_Init(wolfSSL_Atomic_Int* c, int i)`
`1371`	`1381`	`{`
`1372`		`- atomic_init(c, i);`
	`1382`	`+ *c = i;`
`1373`	`1383`	`}`
`1374`	`1384`
`1375`	`1385`	`void wolfSSL_Atomic_Uint_Init(wolfSSL_Atomic_Uint* c, unsigned int i)`
`1376`	`1386`	`{`
`1377`		`- atomic_init(c, i);`
	`1387`	`+ *c = i;`
`1378`	`1388`	`}`
`1379`	`1389`
`1380`	`1390`	`int wolfSSL_Atomic_Int_FetchAdd(wolfSSL_Atomic_Int* c, int i)`
`1381`	`1391`	`{`
`1382`		`- return atomic_fetch_add_explicit(c, i, memory_order_relaxed);`
	`1392`	`+ return __atomic_fetch_add(c, i, __ATOMIC_RELAXED);`
`1383`	`1393`	`}`
`1384`	`1394`
`1385`	`1395`	`int wolfSSL_Atomic_Int_FetchSub(wolfSSL_Atomic_Int* c, int i)`
`1386`	`1396`	`{`
`1387`		`- return atomic_fetch_sub_explicit(c, i, memory_order_relaxed);`
	`1397`	`+ return __atomic_fetch_sub(c, i, __ATOMIC_RELAXED);`
`1388`	`1398`	`}`
`1389`	`1399`
`1390`	`1400`	`int wolfSSL_Atomic_Int_AddFetch(wolfSSL_Atomic_Int* c, int i)`
`1391`	`1401`	`{`
`1392`		`- int ret = atomic_fetch_add_explicit(c, i, memory_order_relaxed);`
`1393`		`- return ret + i;`
	`1402`	`+ return __atomic_add_fetch(c, i, __ATOMIC_RELAXED);`
`1394`	`1403`	`}`
`1395`	`1404`
`1396`	`1405`	`int wolfSSL_Atomic_Int_SubFetch(wolfSSL_Atomic_Int* c, int i)`
`1397`	`1406`	`{`
`1398`		`- int ret = atomic_fetch_sub_explicit(c, i, memory_order_relaxed);`
`1399`		`- return ret - i;`
	`1407`	`+ return __atomic_sub_fetch(c, i, __ATOMIC_RELAXED);`
`1400`	`1408`	`}`
`1401`	`1409`
`1402`		`-int wolfSSL_Atomic_Int_CompareExchange(`
`1403`		`- wolfSSL_Atomic_Int* c, int *expected_i, int new_i)`
	`1410`	`+int wolfSSL_Atomic_Int_CompareExchange(wolfSSL_Atomic_Int* c, int *expected_i,`
	`1411`	`+ int new_i)`
`1404`	`1412`	`{`
`1405`	`1413`	`/* For the success path, use full synchronization with barriers --`
`1406`	`1414`	`* "Sequentially-consistent ordering" -- so that all threads see the same`
`1407`	`1415`	`* "single total modification order of all atomic operations" -- but on`
`1408`	`1416`	`* failure we just need to be sure we acquire the value that changed out`
`1409`	`1417`	`* from under us.`
`1410`	`1418`	`*/`
`1411`		`- return atomic_compare_exchange_strong_explicit(`
`1412`		`- c, expected_i, new_i, memory_order_seq_cst, memory_order_acquire);`
	`1419`	`+ return __atomic_compare_exchange_n(c, expected_i, new_i, 0 /* weak */,`
	`1420`	`+ __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);`
`1413`	`1421`	`}`
`1414`	`1422`
`1415`	`1423`	`unsigned int wolfSSL_Atomic_Uint_FetchAdd(wolfSSL_Atomic_Uint* c,`
`1416`	`1424`	`unsigned int i)`
`1417`	`1425`	`{`
`1418`		`- return atomic_fetch_add_explicit(c, i, memory_order_relaxed);`
	`1426`	`+ return __atomic_fetch_add(c, i, __ATOMIC_RELAXED);`
`1419`	`1427`	`}`
`1420`	`1428`
`1421`	`1429`	`unsigned int wolfSSL_Atomic_Uint_FetchSub(wolfSSL_Atomic_Uint* c,`
`1422`	`1430`	`unsigned int i)`
`1423`	`1431`	`{`
`1424`		`- return atomic_fetch_sub_explicit(c, i, memory_order_relaxed);`
	`1432`	`+ return __atomic_fetch_sub(c, i, __ATOMIC_RELAXED);`
`1425`	`1433`	`}`
`1426`	`1434`
`1427`	`1435`	`unsigned int wolfSSL_Atomic_Uint_AddFetch(wolfSSL_Atomic_Uint* c,`
`1428`	`1436`	`unsigned int i)`
`1429`	`1437`	`{`
`1430`		`- unsigned int ret = atomic_fetch_add_explicit(c, i, memory_order_relaxed);`
`1431`		`- return ret + i;`
	`1438`	`+ return __atomic_add_fetch(c, i, __ATOMIC_RELAXED);`
`1432`	`1439`	`}`
`1433`	`1440`
`1434`	`1441`	`unsigned int wolfSSL_Atomic_Uint_SubFetch(wolfSSL_Atomic_Uint* c,`
`1435`	`1442`	`unsigned int i)`
`1436`	`1443`	`{`
`1437`		`- unsigned int ret = atomic_fetch_sub_explicit(c, i, memory_order_relaxed);`
`1438`		`- return ret - i;`
	`1444`	`+ return __atomic_sub_fetch(c, i, __ATOMIC_RELAXED);`
`1439`	`1445`	`}`
`1440`	`1446`
`1441`	`1447`	`int wolfSSL_Atomic_Uint_CompareExchange(`
`@@ -1447,24 +1453,19 @@ int wolfSSL_Atomic_Uint_CompareExchange(`
`1447`	`1453`	`* failure we just need to be sure we acquire the value that changed out`
`1448`	`1454`	`* from under us.`
`1449`	`1455`	`*/`
`1450`		`- return atomic_compare_exchange_strong_explicit(`
`1451`		`- c, expected_i, new_i, memory_order_seq_cst, memory_order_acquire);`
	`1456`	`+ return __atomic_compare_exchange_n(`
	`1457`	`+ c, expected_i, new_i, 0 /* weak */, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);`
`1452`	`1458`	`}`
`1453`	`1459`
`1454`	`1460`	`int wolfSSL_Atomic_Ptr_CompareExchange(`
`1455`	`1461`	`void c, void expected_ptr, void *new_ptr)`
`1456`	`1462`	`{`
`1457`		`- /* use gcc-built-in __atomic_compare_exchange_n(), not`
`1458`		`- * atomic_compare_exchange_strong_explicit(), to sidestep _Atomic type`
`1459`		`- * requirements.`
`1460`		`- */`
`1461`	`1463`	`return __atomic_compare_exchange_n(`
`1462`		`- c, expected_ptr, new_ptr, 0 /* weak */, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);`
	`1464`	`+ c, expected_ptr, new_ptr, 0 /* weak */,`
	`1465`	`+ __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);`
`1463`	`1466`	`}`
`1464`	`1467`
`1465`		`-#endif /* __cplusplus */`
`1466`		`-`
`1467`		`-#elif defined(_MSC_VER)`
	`1468`	`+#elif defined(_MSC_VER) && !defined(WOLFSSL_NOT_WINDOWS_API)`
`1468`	`1469`
`1469`	`1470`	`void wolfSSL_Atomic_Int_Init(wolfSSL_Atomic_Int* c, int i)`
`1470`	`1471`	`{`
`@@ -1545,8 +1546,8 @@ unsigned int wolfSSL_Atomic_Uint_SubFetch(wolfSSL_Atomic_Uint* c,`
`1545`	`1546`	`int wolfSSL_Atomic_Uint_CompareExchange(`
`1546`	`1547`	`wolfSSL_Atomic_Uint* c, unsigned int *expected_i, unsigned int new_i)`
`1547`	`1548`	`{`
`1548`		`- long actual_i = InterlockedCompareExchange`
`1549`		`- ((wolfSSL_Atomic_Int )c, (long)new_i, (long)expected_i);`
	`1549`	`+ long actual_i = InterlockedCompareExchange(`
	`1550`	`+ (wolfSSL_Atomic_Int )c, (long)new_i, (long)expected_i);`
`1550`	`1551`	`if (actual_i == (long)*expected_i) {`
`1551`	`1552`	`return 1;`
`1552`	`1553`	`}`
`@@ -1560,23 +1561,23 @@ int wolfSSL_Atomic_Uint_CompareExchange(`
`1560`	`1561`	`void c, void expected_ptr, void *new_ptr)`
`1561`	`1562`	`{`
`1562`	`1563`	`#ifdef _WIN64`
`1563`		`- LONG64 actual_ptr = InterlockedCompareExchange64`
`1564`		`- ((LONG64 )c, (LONG64)new_i, (LONG64)expected_i);`
`1565`		`- if (actual_ptr == (LONG64)*expected_i) {`
	`1564`	`+ LONG64 actual_ptr = InterlockedCompareExchange64(`
	`1565`	`+ (LONG64 )c, (LONG64)new_ptr, (LONG64)expected_ptr);`
	`1566`	`+ if (actual_ptr == (LONG64)*expected_ptr) {`
`1566`	`1567`	`return 1;`
`1567`	`1568`	`}`
`1568`	`1569`	`else {`
`1569`		`- expected_i = (void )actual_ptr;`
	`1570`	`+ expected_ptr = (void )actual_ptr;`
`1570`	`1571`	`return 0;`
`1571`	`1572`	`}`
`1572`	`1573`	`#else /* !_WIN64 */`
`1573`		`- LONG actual_ptr = InterlockedCompareExchange`
`1574`		`- ((LONG )c, (LONG)new_i, (LONG)expected_i);`
`1575`		`- if (actual_ptr == (LONG)*expected_i) {`
	`1574`	`+ LONG actual_ptr = InterlockedCompareExchange(`
	`1575`	`+ (LONG )c, (LONG)new_ptr, (LONG)expected_ptr);`
	`1576`	`+ if (actual_ptr == (LONG)*expected_ptr) {`
`1576`	`1577`	`return 1;`
`1577`	`1578`	`}`
`1578`	`1579`	`else {`
`1579`		`- expected_i = (void )actual_ptr;`
	`1580`	`+ expected_ptr = (void )actual_ptr;`
`1580`	`1581`	`return 0;`
`1581`	`1582`	`}`
`1582`	`1583`	`#endif /* !_WIN64 */`