wolfcrypt/src/wc_port.c and wolfssl/wolfcrypt/wc_port.h: change precedence of atomic implementations, and don't use the stdatomic.h in C++ builds (not compatible);

douzzer · douzzer · commit 7916db78e816 · 2025-11-13T17:28:19.000-06:00
fix the name of the wolfSSL_Atomic_Ptr_CompareExchange() implementation in the _MSC_VER code path.
diff --git a/wolfcrypt/src/wc_port.c b/wolfcrypt/src/wc_port.c
@@ -1271,82 +1271,80 @@ char* wc_strdup_ex(const char *src, int memType) {
 }
 #endif
 
-#if defined(WOLFSSL_ATOMIC_OPS) && !defined(SINGLE_THREADED)
+#ifdef WOLFSSL_ATOMIC_OPS
 
 #if defined(WOLFSSL_USER_DEFINED_ATOMICS)
 
-#elif defined(HAVE_C___ATOMIC) && defined(WOLFSSL_HAVE_ATOMIC_H)
+#elif defined(SINGLE_THREADED)
+
+#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(
@@ -1358,90 +1356,91 @@ 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);
 }
 
-#elif defined(__GNUC__) && defined(__ATOMIC_RELAXED)
-/* direct calls using gcc-style compiler built-ins */
+#elif defined(HAVE_C___ATOMIC) && defined(WOLFSSL_HAVE_ATOMIC_H) && \
+        !defined(__cplusplus)
 
+/* 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(
@@ -1453,13 +1452,17 @@ 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);
@@ -1557,7 +1560,7 @@ int wolfSSL_Atomic_Uint_CompareExchange(
     }
 }
 
-int wolfSSL_Atomic_Uint_CompareExchange(
+int wolfSSL_Atomic_Ptr_CompareExchange(
     void ** c, void **expected_ptr, void *new_ptr)
 {
 #ifdef _WIN64
diff --git a/wolfssl/wolfcrypt/wc_port.h b/wolfssl/wolfcrypt/wc_port.h
@@ -494,15 +494,6 @@
         #define WOLFSSL_ATOMIC_LOAD(x) (x)
         #define WOLFSSL_ATOMIC_STORE(x, val) (x) = (val)
         #define WOLFSSL_ATOMIC_OPS
-    #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;
@@ -513,6 +504,16 @@
         #define WOLFSSL_ATOMIC_STORE(x, val) __atomic_store_n(&(x), \
                                                   val, __ATOMIC_RELEASE)
         #define WOLFSSL_ATOMIC_OPS
+    #elif defined(HAVE_C___ATOMIC) && defined(WOLFSSL_HAVE_ATOMIC_H) && \
+        !defined(__cplusplus)
+        /* 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(_MSC_VER) && !defined(WOLFSSL_NOT_WINDOWS_API)
         /* Use MSVC compiler intrinsics for atomic ops */
         #ifdef _WIN32_WCE

Original file line number	Diff line number	Diff line change
`@@ -1271,82 +1271,80 @@ char* wc_strdup_ex(const char *src, int memType) {`
`1271`	`1271`	`}`
`1272`	`1272`	`#endif`
`1273`	`1273`
`1274`		`-#if defined(WOLFSSL_ATOMIC_OPS) && !defined(SINGLE_THREADED)`
	`1274`	`+#ifdef WOLFSSL_ATOMIC_OPS`
`1275`	`1275`
`1276`	`1276`	`#if defined(WOLFSSL_USER_DEFINED_ATOMICS)`
`1277`	`1277`
`1278`		`-#elif defined(HAVE_C___ATOMIC) && defined(WOLFSSL_HAVE_ATOMIC_H)`
	`1278`	`+#elif defined(SINGLE_THREADED)`
	`1279`	`+`
	`1280`	`+#elif defined(__GNUC__) && defined(__ATOMIC_RELAXED)`
	`1281`	`+/* direct calls using gcc-style compiler built-ins */`
`1279`	`1282`
`1280`		`-/* Default C Implementation */`
`1281`	`1283`	`void wolfSSL_Atomic_Int_Init(wolfSSL_Atomic_Int* c, int i)`
`1282`	`1284`	`{`
`1283`		`- atomic_init(c, i);`
	`1285`	`+ *c = i;`
`1284`	`1286`	`}`
`1285`	`1287`
`1286`	`1288`	`void wolfSSL_Atomic_Uint_Init(wolfSSL_Atomic_Uint* c, unsigned int i)`
`1287`	`1289`	`{`
`1288`		`- atomic_init(c, i);`
	`1290`	`+ *c = i;`
`1289`	`1291`	`}`
`1290`	`1292`
`1291`	`1293`	`int wolfSSL_Atomic_Int_FetchAdd(wolfSSL_Atomic_Int* c, int i)`
`1292`	`1294`	`{`
`1293`		`- return atomic_fetch_add_explicit(c, i, memory_order_relaxed);`
	`1295`	`+ return __atomic_fetch_add(c, i, __ATOMIC_RELAXED);`
`1294`	`1296`	`}`
`1295`	`1297`
`1296`	`1298`	`int wolfSSL_Atomic_Int_FetchSub(wolfSSL_Atomic_Int* c, int i)`
`1297`	`1299`	`{`
`1298`		`- return atomic_fetch_sub_explicit(c, i, memory_order_relaxed);`
	`1300`	`+ return __atomic_fetch_sub(c, i, __ATOMIC_RELAXED);`
`1299`	`1301`	`}`
`1300`	`1302`
`1301`	`1303`	`int wolfSSL_Atomic_Int_AddFetch(wolfSSL_Atomic_Int* c, int i)`
`1302`	`1304`	`{`
`1303`		`- int ret = atomic_fetch_add_explicit(c, i, memory_order_relaxed);`
`1304`		`- return ret + i;`
	`1305`	`+ return __atomic_add_fetch(c, i, __ATOMIC_RELAXED);`
`1305`	`1306`	`}`
`1306`	`1307`
`1307`	`1308`	`int wolfSSL_Atomic_Int_SubFetch(wolfSSL_Atomic_Int* c, int i)`
`1308`	`1309`	`{`
`1309`		`- int ret = atomic_fetch_sub_explicit(c, i, memory_order_relaxed);`
`1310`		`- return ret - i;`
	`1310`	`+ return __atomic_sub_fetch(c, i, __ATOMIC_RELAXED);`
`1311`	`1311`	`}`
`1312`	`1312`
`1313`		`-int wolfSSL_Atomic_Int_CompareExchange(`
`1314`		`- wolfSSL_Atomic_Int* c, int *expected_i, int new_i)`
	`1313`	`+int wolfSSL_Atomic_Int_CompareExchange(wolfSSL_Atomic_Int* c, int *expected_i,`
	`1314`	`+ int new_i)`
`1315`	`1315`	`{`
`1316`	`1316`	`/* For the success path, use full synchronization with barriers --`
`1317`	`1317`	`* "Sequentially-consistent ordering" -- so that all threads see the same`
`1318`	`1318`	`* "single total modification order of all atomic operations" -- but on`
`1319`	`1319`	`* failure we just need to be sure we acquire the value that changed out`
`1320`	`1320`	`* from under us.`
`1321`	`1321`	`*/`
`1322`		`- return atomic_compare_exchange_strong_explicit(`
`1323`		`- c, expected_i, new_i, memory_order_seq_cst, memory_order_acquire);`
	`1322`	`+ return __atomic_compare_exchange_n(c, expected_i, new_i, 0 /* weak */,`
	`1323`	`+ __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);`
`1324`	`1324`	`}`
`1325`	`1325`
`1326`	`1326`	`unsigned int wolfSSL_Atomic_Uint_FetchAdd(wolfSSL_Atomic_Uint* c,`
`1327`	`1327`	`unsigned int i)`
`1328`	`1328`	`{`
`1329`		`- return atomic_fetch_add_explicit(c, i, memory_order_relaxed);`
	`1329`	`+ return __atomic_fetch_add(c, i, __ATOMIC_RELAXED);`
`1330`	`1330`	`}`
`1331`	`1331`
`1332`	`1332`	`unsigned int wolfSSL_Atomic_Uint_FetchSub(wolfSSL_Atomic_Uint* c,`
`1333`	`1333`	`unsigned int i)`
`1334`	`1334`	`{`
`1335`		`- return atomic_fetch_sub_explicit(c, i, memory_order_relaxed);`
	`1335`	`+ return __atomic_fetch_sub(c, i, __ATOMIC_RELAXED);`
`1336`	`1336`	`}`
`1337`	`1337`
`1338`	`1338`	`unsigned int wolfSSL_Atomic_Uint_AddFetch(wolfSSL_Atomic_Uint* c,`
`1339`	`1339`	`unsigned int i)`
`1340`	`1340`	`{`
`1341`		`- unsigned int ret = atomic_fetch_add_explicit(c, i, memory_order_relaxed);`
`1342`		`- return ret + i;`
	`1341`	`+ return __atomic_add_fetch(c, i, __ATOMIC_RELAXED);`
`1343`	`1342`	`}`
`1344`	`1343`
`1345`	`1344`	`unsigned int wolfSSL_Atomic_Uint_SubFetch(wolfSSL_Atomic_Uint* c,`
`1346`	`1345`	`unsigned int i)`
`1347`	`1346`	`{`
`1348`		`- unsigned int ret = atomic_fetch_sub_explicit(c, i, memory_order_relaxed);`
`1349`		`- return ret - i;`
	`1347`	`+ return __atomic_sub_fetch(c, i, __ATOMIC_RELAXED);`
`1350`	`1348`	`}`
`1351`	`1349`
`1352`	`1350`	`int wolfSSL_Atomic_Uint_CompareExchange(`
`@@ -1358,90 +1356,91 @@ int wolfSSL_Atomic_Uint_CompareExchange(`
`1358`	`1356`	`* failure we just need to be sure we acquire the value that changed out`
`1359`	`1357`	`* from under us.`
`1360`	`1358`	`*/`
`1361`		`- return atomic_compare_exchange_strong_explicit(`
`1362`		`- c, expected_i, new_i, memory_order_seq_cst, memory_order_acquire);`
	`1359`	`+ return __atomic_compare_exchange_n(`
	`1360`	`+ c, expected_i, new_i, 0 /* weak */, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);`
`1363`	`1361`	`}`
`1364`	`1362`
`1365`	`1363`	`int wolfSSL_Atomic_Ptr_CompareExchange(`
`1366`	`1364`	`void c, void expected_ptr, void *new_ptr)`
`1367`	`1365`	`{`
`1368`		`- /* use gcc-built-in __atomic_compare_exchange_n(), not`
`1369`		`- * atomic_compare_exchange_strong_explicit(), to sidestep _Atomic type`
`1370`		`- * requirements.`
`1371`		`- */`
`1372`	`1366`	`return __atomic_compare_exchange_n(`
`1373`	`1367`	`c, expected_ptr, new_ptr, 0 /* weak */,`
`1374`	`1368`	`__ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);`
`1375`	`1369`	`}`
`1376`	`1370`
`1377`		`-#elif defined(__GNUC__) && defined(__ATOMIC_RELAXED)`
`1378`		`-/* direct calls using gcc-style compiler built-ins */`
	`1371`	`+#elif defined(HAVE_C___ATOMIC) && defined(WOLFSSL_HAVE_ATOMIC_H) && \`
	`1372`	`+ !defined(__cplusplus)`
`1379`	`1373`
	`1374`	`+/* Default C Implementation */`
`1380`	`1375`	`void wolfSSL_Atomic_Int_Init(wolfSSL_Atomic_Int* c, int i)`
`1381`	`1376`	`{`
`1382`		`- *c = i;`
	`1377`	`+ atomic_init(c, i);`
`1383`	`1378`	`}`
`1384`	`1379`
`1385`	`1380`	`void wolfSSL_Atomic_Uint_Init(wolfSSL_Atomic_Uint* c, unsigned int i)`
`1386`	`1381`	`{`
`1387`		`- *c = i;`
	`1382`	`+ atomic_init(c, i);`
`1388`	`1383`	`}`
`1389`	`1384`
`1390`	`1385`	`int wolfSSL_Atomic_Int_FetchAdd(wolfSSL_Atomic_Int* c, int i)`
`1391`	`1386`	`{`
`1392`		`- return __atomic_fetch_add(c, i, __ATOMIC_RELAXED);`
	`1387`	`+ return atomic_fetch_add_explicit(c, i, memory_order_relaxed);`
`1393`	`1388`	`}`
`1394`	`1389`
`1395`	`1390`	`int wolfSSL_Atomic_Int_FetchSub(wolfSSL_Atomic_Int* c, int i)`
`1396`	`1391`	`{`
`1397`		`- return __atomic_fetch_sub(c, i, __ATOMIC_RELAXED);`
	`1392`	`+ return atomic_fetch_sub_explicit(c, i, memory_order_relaxed);`
`1398`	`1393`	`}`
`1399`	`1394`
`1400`	`1395`	`int wolfSSL_Atomic_Int_AddFetch(wolfSSL_Atomic_Int* c, int i)`
`1401`	`1396`	`{`
`1402`		`- return __atomic_add_fetch(c, i, __ATOMIC_RELAXED);`
	`1397`	`+ int ret = atomic_fetch_add_explicit(c, i, memory_order_relaxed);`
	`1398`	`+ return ret + i;`
`1403`	`1399`	`}`
`1404`	`1400`
`1405`	`1401`	`int wolfSSL_Atomic_Int_SubFetch(wolfSSL_Atomic_Int* c, int i)`
`1406`	`1402`	`{`
`1407`		`- return __atomic_sub_fetch(c, i, __ATOMIC_RELAXED);`
	`1403`	`+ int ret = atomic_fetch_sub_explicit(c, i, memory_order_relaxed);`
	`1404`	`+ return ret - i;`
`1408`	`1405`	`}`
`1409`	`1406`
`1410`		`-int wolfSSL_Atomic_Int_CompareExchange(wolfSSL_Atomic_Int* c, int *expected_i,`
`1411`		`- int new_i)`
	`1407`	`+int wolfSSL_Atomic_Int_CompareExchange(`
	`1408`	`+ wolfSSL_Atomic_Int* c, int *expected_i, int new_i)`
`1412`	`1409`	`{`
`1413`	`1410`	`/* For the success path, use full synchronization with barriers --`
`1414`	`1411`	`* "Sequentially-consistent ordering" -- so that all threads see the same`
`1415`	`1412`	`* "single total modification order of all atomic operations" -- but on`
`1416`	`1413`	`* failure we just need to be sure we acquire the value that changed out`
`1417`	`1414`	`* from under us.`
`1418`	`1415`	`*/`
`1419`		`- return __atomic_compare_exchange_n(c, expected_i, new_i, 0 /* weak */,`
`1420`		`- __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);`
	`1416`	`+ return atomic_compare_exchange_strong_explicit(`
	`1417`	`+ c, expected_i, new_i, memory_order_seq_cst, memory_order_acquire);`
`1421`	`1418`	`}`
`1422`	`1419`
`1423`	`1420`	`unsigned int wolfSSL_Atomic_Uint_FetchAdd(wolfSSL_Atomic_Uint* c,`
`1424`	`1421`	`unsigned int i)`
`1425`	`1422`	`{`
`1426`		`- return __atomic_fetch_add(c, i, __ATOMIC_RELAXED);`
	`1423`	`+ return atomic_fetch_add_explicit(c, i, memory_order_relaxed);`
`1427`	`1424`	`}`
`1428`	`1425`
`1429`	`1426`	`unsigned int wolfSSL_Atomic_Uint_FetchSub(wolfSSL_Atomic_Uint* c,`
`1430`	`1427`	`unsigned int i)`
`1431`	`1428`	`{`
`1432`		`- return __atomic_fetch_sub(c, i, __ATOMIC_RELAXED);`
	`1429`	`+ return atomic_fetch_sub_explicit(c, i, memory_order_relaxed);`
`1433`	`1430`	`}`
`1434`	`1431`
`1435`	`1432`	`unsigned int wolfSSL_Atomic_Uint_AddFetch(wolfSSL_Atomic_Uint* c,`
`1436`	`1433`	`unsigned int i)`
`1437`	`1434`	`{`
`1438`		`- return __atomic_add_fetch(c, i, __ATOMIC_RELAXED);`
	`1435`	`+ unsigned int ret = atomic_fetch_add_explicit(c, i, memory_order_relaxed);`
	`1436`	`+ return ret + i;`
`1439`	`1437`	`}`
`1440`	`1438`
`1441`	`1439`	`unsigned int wolfSSL_Atomic_Uint_SubFetch(wolfSSL_Atomic_Uint* c,`
`1442`	`1440`	`unsigned int i)`
`1443`	`1441`	`{`
`1444`		`- return __atomic_sub_fetch(c, i, __ATOMIC_RELAXED);`
	`1442`	`+ unsigned int ret = atomic_fetch_sub_explicit(c, i, memory_order_relaxed);`
	`1443`	`+ return ret - i;`
`1445`	`1444`	`}`
`1446`	`1445`
`1447`	`1446`	`int wolfSSL_Atomic_Uint_CompareExchange(`
`@@ -1453,13 +1452,17 @@ int wolfSSL_Atomic_Uint_CompareExchange(`
`1453`	`1452`	`* failure we just need to be sure we acquire the value that changed out`
`1454`	`1453`	`* from under us.`
`1455`	`1454`	`*/`
`1456`		`- return __atomic_compare_exchange_n(`
`1457`		`- c, expected_i, new_i, 0 /* weak */, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);`
	`1455`	`+ return atomic_compare_exchange_strong_explicit(`
	`1456`	`+ c, expected_i, new_i, memory_order_seq_cst, memory_order_acquire);`
`1458`	`1457`	`}`
`1459`	`1458`
`1460`	`1459`	`int wolfSSL_Atomic_Ptr_CompareExchange(`
`1461`	`1460`	`void c, void expected_ptr, void *new_ptr)`
`1462`	`1461`	`{`
	`1462`	`+ /* use gcc-built-in __atomic_compare_exchange_n(), not`
	`1463`	`+ * atomic_compare_exchange_strong_explicit(), to sidestep _Atomic type`
	`1464`	`+ * requirements.`
	`1465`	`+ */`
`1463`	`1466`	`return __atomic_compare_exchange_n(`
`1464`	`1467`	`c, expected_ptr, new_ptr, 0 /* weak */,`
`1465`	`1468`	`__ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);`
`@@ -1557,7 +1560,7 @@ int wolfSSL_Atomic_Uint_CompareExchange(`
`1557`	`1560`	`}`
`1558`	`1561`	`}`
`1559`	`1562`
`1560`		`-int wolfSSL_Atomic_Uint_CompareExchange(`
	`1563`	`+int wolfSSL_Atomic_Ptr_CompareExchange(`
`1561`	`1564`	`void c, void expected_ptr, void *new_ptr)`
`1562`	`1565`	`{`
`1563`	`1566`	`#ifdef _WIN64`