Merge pull request #9432 from douzzer/20251114-atomic-default-c

philljj · web-flow · commit 50c5028c5a3c · 2025-11-14T10:34:24.000-05:00
20251114-atomic-default-c
diff --git a/wolfcrypt/src/wc_port.c b/wolfcrypt/src/wc_port.c
@@ -1277,74 +1277,79 @@ char* wc_strdup_ex(const char *src, int memType) {
 
 #elif defined(SINGLE_THREADED)
 
-#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(
@@ -1356,91 +1361,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);
 }
 
-#elif defined(HAVE_C___ATOMIC) && defined(WOLFSSL_HAVE_ATOMIC_H) && \
-        !defined(__cplusplus)
+#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(
@@ -1452,17 +1456,13 @@ 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);
diff --git a/wolfssl/wolfcrypt/wc_port.h b/wolfssl/wolfcrypt/wc_port.h
@@ -494,16 +494,6 @@
         #define WOLFSSL_ATOMIC_LOAD(x) (x)
         #define WOLFSSL_ATOMIC_STORE(x, val) (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(HAVE_C___ATOMIC) && defined(WOLFSSL_HAVE_ATOMIC_H) && \
         !defined(__cplusplus)
         /* Default C Implementation */
@@ -514,6 +504,16 @@
         #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

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