GitLab

Marge Bot pushed to branch master at Glasgow Haskell Compiler / GHC

Commits:

7c52c4f9

by John Paul Adrian Glaubitz at 2026-02-10T13:52:43-05:00

rts: Switch prim to use modern atomic compiler builtins

The __sync_*() atomic compiler builtins have been deprecated in GCC
for a while now and also don't provide variants for 64-bit values
such as __sync_fetch_and_add_8().

Thus, replace them with the modern __atomic_*() compiler builtins and
while we're at it, also drop the helper macro CAS_NAND() which is now
no longer needed since we stopped using the __sync_*() compiler builtins
altogether.

Co-authored-by: Ilias Tsitsimpis <iliastsi@debian.org>

Fixes #26729

1 changed file:

rts/prim/atomic.c

Changes:

rts/prim/atomic.c


 
 StgWord hs_atomic_add8(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_add((volatile StgWord8 *) x, (StgWord8) val);
+  return __atomic_fetch_add((volatile StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST);
 }
 
 StgWord hs_atomic_add16(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_add((volatile StgWord16 *) x, (StgWord16) val);
+  return __atomic_fetch_add((volatile StgWord16 *) x, (StgWord16) val, __ATOMIC_SEQ_CST);
 }
 
 StgWord hs_atomic_add32(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_add((volatile StgWord32 *) x, (StgWord32) val);
+  return __atomic_fetch_add((volatile StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST);
 }
 
 StgWord64 hs_atomic_add64(StgWord x, StgWord64 val)
 {
-  return __sync_fetch_and_add((volatile StgWord64 *) x, val);
+  return __atomic_fetch_add((volatile StgWord64 *) x, val, __ATOMIC_SEQ_CST);
 }
 
 // FetchSubByteArrayOp_Int
 
 StgWord hs_atomic_sub8(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_sub((volatile StgWord8 *) x, (StgWord8) val);
+  return __atomic_fetch_sub((volatile StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST);
 }
 
 StgWord hs_atomic_sub16(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_sub((volatile StgWord16 *) x, (StgWord16) val);
+  return __atomic_fetch_sub((volatile StgWord16 *) x, (StgWord16) val, __ATOMIC_SEQ_CST);
 }
 
 StgWord hs_atomic_sub32(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_sub((volatile StgWord32 *) x, (StgWord32) val);
+  return __atomic_fetch_sub((volatile StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST);
 }
 
 StgWord64 hs_atomic_sub64(StgWord x, StgWord64 val)
 {
-  return __sync_fetch_and_sub((volatile StgWord64 *) x, val);
+  return __atomic_fetch_sub((volatile StgWord64 *) x, val, __ATOMIC_SEQ_CST);
 }
 
 // FetchAndByteArrayOp_Int
 
 StgWord hs_atomic_and8(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_and((volatile StgWord8 *) x, (StgWord8) val);
+  return __atomic_fetch_and((volatile StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST);
 }
 
 StgWord hs_atomic_and16(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_and((volatile StgWord16 *) x, (StgWord16) val);
+  return __atomic_fetch_and((volatile StgWord16 *) x, (StgWord16) val, __ATOMIC_SEQ_CST);
 }
 
 StgWord hs_atomic_and32(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_and((volatile StgWord32 *) x, (StgWord32) val);
+  return __atomic_fetch_and((volatile StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST);
 }
 
 StgWord64 hs_atomic_and64(StgWord x, StgWord64 val)
 {
-  return __sync_fetch_and_and((volatile StgWord64 *) x, val);
+  return __atomic_fetch_and((volatile StgWord64 *) x, val, __ATOMIC_SEQ_CST);
 }
 
-// FetchNandByteArrayOp_Int
-
-// Note [__sync_fetch_and_nand usage]
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The __sync_fetch_and_nand builtin is a bit of a disaster. It was introduced
-// in GCC long ago with silly semantics. Specifically:
-//
-//    *ptr = ~(tmp & value)
-//
-// Clang introduced the builtin with the same semantics.
-//
-// In GCC 4.4 the operation's semantics were rightly changed to,
-//
-//    *ptr = ~tmp & value
-//
-// and the -Wsync-nand warning was added warning users of the operation about
-// the change.
-//
-// Clang took this change as a reason to remove support for the
-// builtin in 2010. Then, in 2014 Clang re-added support with the new
-// semantics. However, the warning flag was given a different name
-// (-Wsync-fetch-and-nand-semantics-changed) for added fun.
-//
-// Consequently, we are left with a bit of a mess: GHC requires GCC >4.4
-// (enforced by the FP_GCC_VERSION autoconf check), so we thankfully don't need
-// to support the operation's older broken semantics. However, we need to take
-// care to explicitly disable -Wsync-nand wherever possible, lest the build
-// fails with -Werror.  Furthermore, we need to emulate the operation when
-// building with some Clang versions (shipped by some Mac OS X releases) which
-// lack support for the builtin.
-//
-// In the words of Bob Dylan: everything is broken.
-//
-// See also:
-//
-//  * https://bugs.llvm.org/show_bug.cgi?id=8842
-//  * https://gitlab.haskell.org/ghc/ghc/issues/9678
-//
-
-#define CAS_NAND(x, val)                                            \
-  {                                                                 \
-    __typeof__ (*(x)) tmp = *(x);                                   \
-    while (!__sync_bool_compare_and_swap(x, tmp, ~(tmp & (val)))) { \
-      tmp = *(x);                                                   \
-    }                                                               \
-    return tmp;                                                     \
-  }
-
-// N.B. __has_builtin is only provided by clang
-#if !defined(__has_builtin)
-#define __has_builtin(x) 0
-#endif
-
-#if defined(__clang__) && !__has_builtin(__sync_fetch_and_nand)
-#define USE_SYNC_FETCH_AND_NAND 0
-#else
-#define USE_SYNC_FETCH_AND_NAND 1
-#endif
-
-// Otherwise this fails with -Werror
-#pragma GCC diagnostic push
-#if defined(__clang__)
-#pragma GCC diagnostic ignored "-Wsync-fetch-and-nand-semantics-changed"
-#else
-#pragma GCC diagnostic ignored "-Wsync-nand"
-#endif
-
 StgWord hs_atomic_nand8(StgWord x, StgWord val)
 {
-#if USE_SYNC_FETCH_AND_NAND
-  return __sync_fetch_and_nand((volatile StgWord8 *) x, (StgWord8) val);
-#else
-  CAS_NAND((volatile StgWord8 *) x, (StgWord8) val)
-#endif
+  return __atomic_fetch_nand((volatile StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST);
 }
 
 StgWord hs_atomic_nand16(StgWord x, StgWord val)
 {
-#if USE_SYNC_FETCH_AND_NAND
-  return __sync_fetch_and_nand((volatile StgWord16 *) x, (StgWord16) val);
-#else
-  CAS_NAND((volatile StgWord16 *) x, (StgWord16) val);
-#endif
+  return __atomic_fetch_nand((volatile StgWord16 *) x, (StgWord16) val, __ATOMIC_SEQ_CST);
 }
 
 StgWord hs_atomic_nand32(StgWord x, StgWord val)
 {
-#if USE_SYNC_FETCH_AND_NAND
-  return __sync_fetch_and_nand((volatile StgWord32 *) x, (StgWord32) val);
-#else
-  CAS_NAND((volatile StgWord32 *) x, (StgWord32) val);
-#endif
+  return __atomic_fetch_nand((volatile StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST);
 }
 
 StgWord64 hs_atomic_nand64(StgWord x, StgWord64 val)
 {
-#if USE_SYNC_FETCH_AND_NAND
-  return __sync_fetch_and_nand((volatile StgWord64 *) x, val);
-#else
-  CAS_NAND((volatile StgWord64 *) x, val);
-#endif
+  return __atomic_fetch_nand((volatile StgWord64 *) x, val, __ATOMIC_SEQ_CST);
 }
 
 #pragma GCC diagnostic pop

 
 StgWord hs_atomic_or8(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_or((volatile StgWord8 *) x, (StgWord8) val);
+  return __atomic_fetch_or((volatile StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST);
 }
 
 StgWord hs_atomic_or16(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_or((volatile StgWord16 *) x, (StgWord16) val);
+  return __atomic_fetch_or((volatile StgWord16 *) x, (StgWord16) val, __ATOMIC_SEQ_CST);
 }
 
 StgWord hs_atomic_or32(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_or((volatile StgWord32 *) x, (StgWord32) val);
+  return __atomic_fetch_or((volatile StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST);
 }
 
 StgWord64 hs_atomic_or64(StgWord x, StgWord64 val)
 {
-  return __sync_fetch_and_or((volatile StgWord64 *) x, val);
+  return __atomic_fetch_or((volatile StgWord64 *) x, val, __ATOMIC_SEQ_CST);
 }
 
 // FetchXorByteArrayOp_Int
 
 StgWord hs_atomic_xor8(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_xor((volatile StgWord8 *) x, (StgWord8) val);
+  return __atomic_fetch_xor((volatile StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST);
 }
 
 StgWord hs_atomic_xor16(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_xor((volatile StgWord16 *) x, (StgWord16) val);
+  return __atomic_fetch_xor((volatile StgWord16 *) x, (StgWord16) val, __ATOMIC_SEQ_CST);
 }
 
 StgWord hs_atomic_xor32(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_xor((volatile StgWord32 *) x, (StgWord32) val);
+  return __atomic_fetch_xor((volatile StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST);
 }
 
 StgWord64 hs_atomic_xor64(StgWord x, StgWord64 val)
 {
-  return __sync_fetch_and_xor((volatile StgWord64 *) x, val);
+  return __atomic_fetch_xor((volatile StgWord64 *) x, val, __ATOMIC_SEQ_CST);
 }
 
 // CasByteArrayOp_Int

 // __ATOMIC_SEQ_CST: Full barrier in both directions (hoisting and sinking
 // of code) and synchronizes with acquire loads and release stores in
 // all threads.
-//
-// When we lack C11 atomics support we emulate these using the old GCC __sync
-// primitives which the GCC documentation claims "usually" implies a full
-// barrier.
 
 StgWord hs_atomicread8(StgWord x)
 {

...	...	@@ -14,169 +14,86 @@
14	14
15	15	StgWord hs_atomic_add8(StgWord x, StgWord val)
16	16	{
17		- return __sync_fetch_and_add((volatile StgWord8 *) x, (StgWord8) val);
	17	+ return __atomic_fetch_add((volatile StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST);
18	18	}
19	19
20	20	StgWord hs_atomic_add16(StgWord x, StgWord val)
21	21	{
22		- return __sync_fetch_and_add((volatile StgWord16 *) x, (StgWord16) val);
	22	+ return __atomic_fetch_add((volatile StgWord16 *) x, (StgWord16) val, __ATOMIC_SEQ_CST);
23	23	}
24	24
25	25	StgWord hs_atomic_add32(StgWord x, StgWord val)
26	26	{
27		- return __sync_fetch_and_add((volatile StgWord32 *) x, (StgWord32) val);
	27	+ return __atomic_fetch_add((volatile StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST);
28	28	}
29	29
30	30	StgWord64 hs_atomic_add64(StgWord x, StgWord64 val)
31	31	{
32		- return __sync_fetch_and_add((volatile StgWord64 *) x, val);
	32	+ return __atomic_fetch_add((volatile StgWord64 *) x, val, __ATOMIC_SEQ_CST);
33	33	}
34	34
35	35	// FetchSubByteArrayOp_Int
36	36
37	37	StgWord hs_atomic_sub8(StgWord x, StgWord val)
38	38	{
39		- return __sync_fetch_and_sub((volatile StgWord8 *) x, (StgWord8) val);
	39	+ return __atomic_fetch_sub((volatile StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST);
40	40	}
41	41
42	42	StgWord hs_atomic_sub16(StgWord x, StgWord val)
43	43	{
44		- return __sync_fetch_and_sub((volatile StgWord16 *) x, (StgWord16) val);
	44	+ return __atomic_fetch_sub((volatile StgWord16 *) x, (StgWord16) val, __ATOMIC_SEQ_CST);
45	45	}
46	46
47	47	StgWord hs_atomic_sub32(StgWord x, StgWord val)
48	48	{
49		- return __sync_fetch_and_sub((volatile StgWord32 *) x, (StgWord32) val);
	49	+ return __atomic_fetch_sub((volatile StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST);
50	50	}
51	51
52	52	StgWord64 hs_atomic_sub64(StgWord x, StgWord64 val)
53	53	{
54		- return __sync_fetch_and_sub((volatile StgWord64 *) x, val);
	54	+ return __atomic_fetch_sub((volatile StgWord64 *) x, val, __ATOMIC_SEQ_CST);
55	55	}
56	56
57	57	// FetchAndByteArrayOp_Int
58	58
59	59	StgWord hs_atomic_and8(StgWord x, StgWord val)
60	60	{
61		- return __sync_fetch_and_and((volatile StgWord8 *) x, (StgWord8) val);
	61	+ return __atomic_fetch_and((volatile StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST);
62	62	}
63	63
64	64	StgWord hs_atomic_and16(StgWord x, StgWord val)
65	65	{
66		- return __sync_fetch_and_and((volatile StgWord16 *) x, (StgWord16) val);
	66	+ return __atomic_fetch_and((volatile StgWord16 *) x, (StgWord16) val, __ATOMIC_SEQ_CST);
67	67	}
68	68
69	69	StgWord hs_atomic_and32(StgWord x, StgWord val)
70	70	{
71		- return __sync_fetch_and_and((volatile StgWord32 *) x, (StgWord32) val);
	71	+ return __atomic_fetch_and((volatile StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST);
72	72	}
73	73
74	74	StgWord64 hs_atomic_and64(StgWord x, StgWord64 val)
75	75	{
76		- return __sync_fetch_and_and((volatile StgWord64 *) x, val);
	76	+ return __atomic_fetch_and((volatile StgWord64 *) x, val, __ATOMIC_SEQ_CST);
77	77	}
78	78
79		-// FetchNandByteArrayOp_Int
80		-
81		-// Note [__sync_fetch_and_nand usage]
82		-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
83		-// The __sync_fetch_and_nand builtin is a bit of a disaster. It was introduced
84		-// in GCC long ago with silly semantics. Specifically:
85		-//
86		-// *ptr = ~(tmp & value)
87		-//
88		-// Clang introduced the builtin with the same semantics.
89		-//
90		-// In GCC 4.4 the operation's semantics were rightly changed to,
91		-//
92		-// *ptr = ~tmp & value
93		-//
94		-// and the -Wsync-nand warning was added warning users of the operation about
95		-// the change.
96		-//
97		-// Clang took this change as a reason to remove support for the
98		-// builtin in 2010. Then, in 2014 Clang re-added support with the new
99		-// semantics. However, the warning flag was given a different name
100		-// (-Wsync-fetch-and-nand-semantics-changed) for added fun.
101		-//
102		-// Consequently, we are left with a bit of a mess: GHC requires GCC >4.4
103		-// (enforced by the FP_GCC_VERSION autoconf check), so we thankfully don't need
104		-// to support the operation's older broken semantics. However, we need to take
105		-// care to explicitly disable -Wsync-nand wherever possible, lest the build
106		-// fails with -Werror. Furthermore, we need to emulate the operation when
107		-// building with some Clang versions (shipped by some Mac OS X releases) which
108		-// lack support for the builtin.
109		-//
110		-// In the words of Bob Dylan: everything is broken.
111		-//
112		-// See also:
113		-//
114		-// * https://bugs.llvm.org/show_bug.cgi?id=8842
115		-// * https://gitlab.haskell.org/ghc/ghc/issues/9678
116		-//
117		-
118		-#define CAS_NAND(x, val) \
119		- { \
120		- __typeof__ ((x)) tmp = (x); \
121		- while (!__sync_bool_compare_and_swap(x, tmp, ~(tmp & (val)))) { \
122		- tmp = *(x); \
123		- } \
124		- return tmp; \
125		- }
126		-
127		-// N.B. __has_builtin is only provided by clang
128		-#if !defined(__has_builtin)
129		-#define __has_builtin(x) 0
130		-#endif
131		-
132		-#if defined(__clang__) && !__has_builtin(__sync_fetch_and_nand)
133		-#define USE_SYNC_FETCH_AND_NAND 0
134		-#else
135		-#define USE_SYNC_FETCH_AND_NAND 1
136		-#endif
137		-
138		-// Otherwise this fails with -Werror
139		-#pragma GCC diagnostic push
140		-#if defined(__clang__)
141		-#pragma GCC diagnostic ignored "-Wsync-fetch-and-nand-semantics-changed"
142		-#else
143		-#pragma GCC diagnostic ignored "-Wsync-nand"
144		-#endif
145		-
146	79	StgWord hs_atomic_nand8(StgWord x, StgWord val)
147	80	{
148		-#if USE_SYNC_FETCH_AND_NAND
149		- return __sync_fetch_and_nand((volatile StgWord8 *) x, (StgWord8) val);
150		-#else
151		- CAS_NAND((volatile StgWord8 *) x, (StgWord8) val)
152		-#endif
	81	+ return __atomic_fetch_nand((volatile StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST);
153	82	}
154	83
155	84	StgWord hs_atomic_nand16(StgWord x, StgWord val)
156	85	{
157		-#if USE_SYNC_FETCH_AND_NAND
158		- return __sync_fetch_and_nand((volatile StgWord16 *) x, (StgWord16) val);
159		-#else
160		- CAS_NAND((volatile StgWord16 *) x, (StgWord16) val);
161		-#endif
	86	+ return __atomic_fetch_nand((volatile StgWord16 *) x, (StgWord16) val, __ATOMIC_SEQ_CST);
162	87	}
163	88
164	89	StgWord hs_atomic_nand32(StgWord x, StgWord val)
165	90	{
166		-#if USE_SYNC_FETCH_AND_NAND
167		- return __sync_fetch_and_nand((volatile StgWord32 *) x, (StgWord32) val);
168		-#else
169		- CAS_NAND((volatile StgWord32 *) x, (StgWord32) val);
170		-#endif
	91	+ return __atomic_fetch_nand((volatile StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST);
171	92	}
172	93
173	94	StgWord64 hs_atomic_nand64(StgWord x, StgWord64 val)
174	95	{
175		-#if USE_SYNC_FETCH_AND_NAND
176		- return __sync_fetch_and_nand((volatile StgWord64 *) x, val);
177		-#else
178		- CAS_NAND((volatile StgWord64 *) x, val);
179		-#endif
	96	+ return __atomic_fetch_nand((volatile StgWord64 *) x, val, __ATOMIC_SEQ_CST);
180	97	}
181	98
182	99	#pragma GCC diagnostic pop
...	...	@@ -185,44 +102,44 @@ StgWord64 hs_atomic_nand64(StgWord x, StgWord64 val)
185	102
186	103	StgWord hs_atomic_or8(StgWord x, StgWord val)
187	104	{
188		- return __sync_fetch_and_or((volatile StgWord8 *) x, (StgWord8) val);
	105	+ return __atomic_fetch_or((volatile StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST);
189	106	}
190	107
191	108	StgWord hs_atomic_or16(StgWord x, StgWord val)
192	109	{
193		- return __sync_fetch_and_or((volatile StgWord16 *) x, (StgWord16) val);
	110	+ return __atomic_fetch_or((volatile StgWord16 *) x, (StgWord16) val, __ATOMIC_SEQ_CST);
194	111	}
195	112
196	113	StgWord hs_atomic_or32(StgWord x, StgWord val)
197	114	{
198		- return __sync_fetch_and_or((volatile StgWord32 *) x, (StgWord32) val);
	115	+ return __atomic_fetch_or((volatile StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST);
199	116	}
200	117
201	118	StgWord64 hs_atomic_or64(StgWord x, StgWord64 val)
202	119	{
203		- return __sync_fetch_and_or((volatile StgWord64 *) x, val);
	120	+ return __atomic_fetch_or((volatile StgWord64 *) x, val, __ATOMIC_SEQ_CST);
204	121	}
205	122
206	123	// FetchXorByteArrayOp_Int
207	124
208	125	StgWord hs_atomic_xor8(StgWord x, StgWord val)
209	126	{
210		- return __sync_fetch_and_xor((volatile StgWord8 *) x, (StgWord8) val);
	127	+ return __atomic_fetch_xor((volatile StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST);
211	128	}
212	129
213	130	StgWord hs_atomic_xor16(StgWord x, StgWord val)
214	131	{
215		- return __sync_fetch_and_xor((volatile StgWord16 *) x, (StgWord16) val);
	132	+ return __atomic_fetch_xor((volatile StgWord16 *) x, (StgWord16) val, __ATOMIC_SEQ_CST);
216	133	}
217	134
218	135	StgWord hs_atomic_xor32(StgWord x, StgWord val)
219	136	{
220		- return __sync_fetch_and_xor((volatile StgWord32 *) x, (StgWord32) val);
	137	+ return __atomic_fetch_xor((volatile StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST);
221	138	}
222	139
223	140	StgWord64 hs_atomic_xor64(StgWord x, StgWord64 val)
224	141	{
225		- return __sync_fetch_and_xor((volatile StgWord64 *) x, val);
	142	+ return __atomic_fetch_xor((volatile StgWord64 *) x, val, __ATOMIC_SEQ_CST);
226	143	}
227	144
228	145	// CasByteArrayOp_Int
...	...	@@ -283,10 +200,6 @@ StgWord64 hs_xchg64(StgWord x, StgWord64 val)
283	200	// __ATOMIC_SEQ_CST: Full barrier in both directions (hoisting and sinking
284	201	// of code) and synchronizes with acquire loads and release stores in
285	202	// all threads.
286		-//
287		-// When we lack C11 atomics support we emulate these using the old GCC __sync
288		-// primitives which the GCC documentation claims "usually" implies a full
289		-// barrier.
290	203
291	204	StgWord hs_atomicread8(StgWord x)
292	205	{