1 // RUN: %clang_cc1 %s -emit-llvm -o - -ffreestanding -triple=i686-apple-darwin9 | FileCheck %s
2 
3 // Also test serialization of atomic operations here, to avoid duplicating the
4 // test.
5 // RUN: %clang_cc1 %s -emit-pch -o %t -ffreestanding -triple=i686-apple-darwin9
6 // RUN: %clang_cc1 %s -include-pch %t -ffreestanding -triple=i686-apple-darwin9 -emit-llvm -o - | FileCheck %s
7 #ifndef ALREADY_INCLUDED
8 #define ALREADY_INCLUDED
9 
10 #include <stdatomic.h>
11 
12 // Basic IRGen tests for __c11_atomic_* and GNU __atomic_*
13 
14 int fi1(_Atomic(int) *i) {
15   // CHECK-LABEL: @fi1
16   // CHECK: load atomic i32* {{.*}} seq_cst
17   return __c11_atomic_load(i, memory_order_seq_cst);
18 }
19 
20 int fi1a(int *i) {
21   // CHECK-LABEL: @fi1a
22   // CHECK: load atomic i32* {{.*}} seq_cst
23   int v;
24   __atomic_load(i, &v, memory_order_seq_cst);
25   return v;
26 }
27 
28 int fi1b(int *i) {
29   // CHECK-LABEL: @fi1b
30   // CHECK: load atomic i32* {{.*}} seq_cst
31   return __atomic_load_n(i, memory_order_seq_cst);
32 }
33 
34 int fi1c(atomic_int *i) {
35   // CHECK-LABEL: @fi1c
36   // CHECK: load atomic i32* {{.*}} seq_cst
37   return atomic_load(i);
38 }
39 
40 void fi2(_Atomic(int) *i) {
41   // CHECK-LABEL: @fi2
42   // CHECK: store atomic i32 {{.*}} seq_cst
43   __c11_atomic_store(i, 1, memory_order_seq_cst);
44 }
45 
46 void fi2a(int *i) {
47   // CHECK-LABEL: @fi2a
48   // CHECK: store atomic i32 {{.*}} seq_cst
49   int v = 1;
50   __atomic_store(i, &v, memory_order_seq_cst);
51 }
52 
53 void fi2b(int *i) {
54   // CHECK-LABEL: @fi2b
55   // CHECK: store atomic i32 {{.*}} seq_cst
56   __atomic_store_n(i, 1, memory_order_seq_cst);
57 }
58 
59 void fi2c(atomic_int *i) {
60   // CHECK-LABEL: @fi2c
61   // CHECK: store atomic i32 {{.*}} seq_cst
62   atomic_store(i, 1);
63 }
64 
65 int fi3(_Atomic(int) *i) {
66   // CHECK-LABEL: @fi3
67   // CHECK: atomicrmw and
68   // CHECK-NOT: and
69   return __c11_atomic_fetch_and(i, 1, memory_order_seq_cst);
70 }
71 
72 int fi3a(int *i) {
73   // CHECK-LABEL: @fi3a
74   // CHECK: atomicrmw xor
75   // CHECK-NOT: xor
76   return __atomic_fetch_xor(i, 1, memory_order_seq_cst);
77 }
78 
79 int fi3b(int *i) {
80   // CHECK-LABEL: @fi3b
81   // CHECK: atomicrmw add
82   // CHECK: add
83   return __atomic_add_fetch(i, 1, memory_order_seq_cst);
84 }
85 
86 int fi3c(int *i) {
87   // CHECK-LABEL: @fi3c
88   // CHECK: atomicrmw nand
89   // CHECK-NOT: and
90   return __atomic_fetch_nand(i, 1, memory_order_seq_cst);
91 }
92 
93 int fi3d(int *i) {
94   // CHECK-LABEL: @fi3d
95   // CHECK: atomicrmw nand
96   // CHECK: and
97   // CHECK: xor
98   return __atomic_nand_fetch(i, 1, memory_order_seq_cst);
99 }
100 
101 int fi3e(atomic_int *i) {
102   // CHECK-LABEL: @fi3e
103   // CHECK: atomicrmw or
104   // CHECK-NOT: {{ or }}
105   return atomic_fetch_or(i, 1);
106 }
107 
108 _Bool fi4(_Atomic(int) *i) {
109   // CHECK-LABEL: @fi4(
110   // CHECK: [[PAIR:%[.0-9A-Z_a-z]+]] = cmpxchg i32* [[PTR:%[.0-9A-Z_a-z]+]], i32 [[EXPECTED:%[.0-9A-Z_a-z]+]], i32 [[DESIRED:%[.0-9A-Z_a-z]+]]
111   // CHECK: [[OLD:%[.0-9A-Z_a-z]+]] = extractvalue { i32, i1 } [[PAIR]], 0
112   // CHECK: [[CMP:%[.0-9A-Z_a-z]+]] = extractvalue { i32, i1 } [[PAIR]], 1
113   // CHECK: br i1 [[CMP]], label %[[STORE_EXPECTED:[.0-9A-Z_a-z]+]], label %[[CONTINUE:[.0-9A-Z_a-z]+]]
114   // CHECK: store i32 [[OLD]]
115   int cmp = 0;
116   return __c11_atomic_compare_exchange_strong(i, &cmp, 1, memory_order_acquire, memory_order_acquire);
117 }
118 
119 _Bool fi4a(int *i) {
120   // CHECK-LABEL: @fi4a
121   // CHECK: [[PAIR:%[.0-9A-Z_a-z]+]] = cmpxchg i32* [[PTR:%[.0-9A-Z_a-z]+]], i32 [[EXPECTED:%[.0-9A-Z_a-z]+]], i32 [[DESIRED:%[.0-9A-Z_a-z]+]]
122   // CHECK: [[OLD:%[.0-9A-Z_a-z]+]] = extractvalue { i32, i1 } [[PAIR]], 0
123   // CHECK: [[CMP:%[.0-9A-Z_a-z]+]] = extractvalue { i32, i1 } [[PAIR]], 1
124   // CHECK: br i1 [[CMP]], label %[[STORE_EXPECTED:[.0-9A-Z_a-z]+]], label %[[CONTINUE:[.0-9A-Z_a-z]+]]
125   // CHECK: store i32 [[OLD]]
126   int cmp = 0;
127   int desired = 1;
128   return __atomic_compare_exchange(i, &cmp, &desired, 0, memory_order_acquire, memory_order_acquire);
129 }
130 
131 _Bool fi4b(int *i) {
132   // CHECK-LABEL: @fi4b(
133   // CHECK: [[PAIR:%[.0-9A-Z_a-z]+]] = cmpxchg weak i32* [[PTR:%[.0-9A-Z_a-z]+]], i32 [[EXPECTED:%[.0-9A-Z_a-z]+]], i32 [[DESIRED:%[.0-9A-Z_a-z]+]]
134   // CHECK: [[OLD:%[.0-9A-Z_a-z]+]] = extractvalue { i32, i1 } [[PAIR]], 0
135   // CHECK: [[CMP:%[.0-9A-Z_a-z]+]] = extractvalue { i32, i1 } [[PAIR]], 1
136   // CHECK: br i1 [[CMP]], label %[[STORE_EXPECTED:[.0-9A-Z_a-z]+]], label %[[CONTINUE:[.0-9A-Z_a-z]+]]
137   // CHECK: store i32 [[OLD]]
138   int cmp = 0;
139   return __atomic_compare_exchange_n(i, &cmp, 1, 1, memory_order_acquire, memory_order_acquire);
140 }
141 
142 _Bool fi4c(atomic_int *i) {
143   // CHECK-LABEL: @fi4c
144   // CHECK: cmpxchg i32*
145   int cmp = 0;
146   return atomic_compare_exchange_strong(i, &cmp, 1);
147 }
148 
149 float ff1(_Atomic(float) *d) {
150   // CHECK-LABEL: @ff1
151   // CHECK: load atomic i32* {{.*}} monotonic
152   return __c11_atomic_load(d, memory_order_relaxed);
153 }
154 
155 void ff2(_Atomic(float) *d) {
156   // CHECK-LABEL: @ff2
157   // CHECK: store atomic i32 {{.*}} release
158   __c11_atomic_store(d, 1, memory_order_release);
159 }
160 
161 float ff3(_Atomic(float) *d) {
162   return __c11_atomic_exchange(d, 2, memory_order_seq_cst);
163 }
164 
165 struct S {
166   double x;
167 };
168 
169 struct S fd1(struct S *a) {
170   // CHECK-LABEL: @fd1
171   // CHECK: [[RETVAL:%.*]] = alloca %struct.S, align 4
172   // CHECK: [[RET:%.*]]    = alloca %struct.S, align 4
173   // CHECK: [[CALL:%.*]]   = call i64 @__atomic_load_8(
174   // CHECK: [[CAST:%.*]]   = bitcast %struct.S* [[RET]] to i64*
175   // CHECK: store i64 [[CALL]], i64* [[CAST]], align 4
176   struct S ret;
177   __atomic_load(a, &ret, memory_order_seq_cst);
178   return ret;
179 }
180 
181 void fd2(struct S *a, struct S *b) {
182   // CHECK-LABEL: @fd2
183   // CHECK:      [[A_ADDR:%.*]] = alloca %struct.S*, align 4
184   // CHECK-NEXT: [[B_ADDR:%.*]] = alloca %struct.S*, align 4
185   // CHECK-NEXT: store %struct.S* %a, %struct.S** [[A_ADDR]], align 4
186   // CHECK-NEXT: store %struct.S* %b, %struct.S** [[B_ADDR]], align 4
187   // CHECK-NEXT: [[LOAD_A_PTR:%.*]] = load %struct.S** [[A_ADDR]], align 4
188   // CHECK-NEXT: [[LOAD_B_PTR:%.*]] = load %struct.S** [[B_ADDR]], align 4
189   // CHECK-NEXT: [[COERCED_A:%.*]] = bitcast %struct.S* [[LOAD_A_PTR]] to i8*
190   // CHECK-NEXT: [[COERCED_B:%.*]] = bitcast %struct.S* [[LOAD_B_PTR]] to i64*
191   // CHECK-NEXT: [[LOAD_B:%.*]] = load i64* [[COERCED_B]], align 4
192   // CHECK-NEXT: call void @__atomic_store_8(i8* [[COERCED_A]], i64 [[LOAD_B]],
193   // CHECK-NEXT: ret void
194   __atomic_store(a, b, memory_order_seq_cst);
195 }
196 
197 void fd3(struct S *a, struct S *b, struct S *c) {
198   // CHECK-LABEL: @fd3
199   // CHECK:      [[A_ADDR:%.*]] = alloca %struct.S*, align 4
200   // CHECK-NEXT: [[B_ADDR:%.*]] = alloca %struct.S*, align 4
201   // CHECK-NEXT: [[C_ADDR:%.*]] = alloca %struct.S*, align 4
202   // CHECK-NEXT: store %struct.S* %a, %struct.S** [[A_ADDR]], align 4
203   // CHECK-NEXT: store %struct.S* %b, %struct.S** [[B_ADDR]], align 4
204   // CHECK-NEXT: store %struct.S* %c, %struct.S** [[C_ADDR]], align 4
205   // CHECK-NEXT: [[LOAD_A_PTR:%.*]] = load %struct.S** [[A_ADDR]], align 4
206   // CHECK-NEXT: [[LOAD_B_PTR:%.*]] = load %struct.S** [[B_ADDR]], align 4
207   // CHECK-NEXT: [[LOAD_C_PTR:%.*]] = load %struct.S** [[C_ADDR]], align 4
208   // CHECK-NEXT: [[COERCED_A:%.*]] = bitcast %struct.S* [[LOAD_A_PTR]] to i8*
209   // CHECK-NEXT: [[COERCED_B:%.*]] = bitcast %struct.S* [[LOAD_B_PTR]] to i64*
210   // CHECK-NEXT: [[LOAD_B:%.*]] = load i64* [[COERCED_B]], align 4
211   // CHECK-NEXT: [[CALL:%.*]] = call i64 @__atomic_exchange_8(i8* [[COERCED_A]], i64 [[LOAD_B]],
212   // CHECK-NEXT: [[COERCED_C:%.*]] = bitcast %struct.S* [[LOAD_C_PTR]] to i64*
213   // CHECK-NEXT: store i64 [[CALL]], i64* [[COERCED_C]], align 4
214 
215   __atomic_exchange(a, b, c, memory_order_seq_cst);
216 }
217 
218 _Bool fd4(struct S *a, struct S *b, struct S *c) {
219   // CHECK-LABEL: @fd4
220   // CHECK:      [[A_ADDR:%.*]] = alloca %struct.S*, align 4
221   // CHECK-NEXT: [[B_ADDR:%.*]] = alloca %struct.S*, align 4
222   // CHECK-NEXT: [[C_ADDR:%.*]] = alloca %struct.S*, align 4
223   // CHECK:      store %struct.S* %a, %struct.S** [[A_ADDR]], align 4
224   // CHECK-NEXT: store %struct.S* %b, %struct.S** [[B_ADDR]], align 4
225   // CHECK-NEXT: store %struct.S* %c, %struct.S** [[C_ADDR]], align 4
226   // CHECK-NEXT: [[LOAD_A_PTR:%.*]] = load %struct.S** [[A_ADDR]], align 4
227   // CHECK-NEXT: [[LOAD_B_PTR:%.*]] = load %struct.S** [[B_ADDR]], align 4
228   // CHECK-NEXT: [[LOAD_C_PTR:%.*]] = load %struct.S** [[C_ADDR]], align 4
229   // CHECK-NEXT: [[COERCED_A:%.*]] = bitcast %struct.S* [[LOAD_A_PTR]] to i8*
230   // CHECK-NEXT: [[COERCED_B:%.*]] = bitcast %struct.S* [[LOAD_B_PTR]] to i8*
231   // CHECK-NEXT: [[COERCED_C:%.*]] = bitcast %struct.S* [[LOAD_C_PTR]] to i64*
232   // CHECK-NEXT: [[LOAD_C:%.*]] = load i64* [[COERCED_C]], align 4
233   // CHECK-NEXT: [[CALL:%.*]] = call zeroext i1 @__atomic_compare_exchange_8(i8* [[COERCED_A]], i8* [[COERCED_B]], i64 [[LOAD_C]]
234   // CHECK-NEXT: ret i1 [[CALL]]
235   return __atomic_compare_exchange(a, b, c, 1, 5, 5);
236 }
237 
238 int* fp1(_Atomic(int*) *p) {
239   // CHECK-LABEL: @fp1
240   // CHECK: load atomic i32* {{.*}} seq_cst
241   return __c11_atomic_load(p, memory_order_seq_cst);
242 }
243 
244 int* fp2(_Atomic(int*) *p) {
245   // CHECK-LABEL: @fp2
246   // CHECK: store i32 4
247   // CHECK: atomicrmw add {{.*}} monotonic
248   return __c11_atomic_fetch_add(p, 1, memory_order_relaxed);
249 }
250 
251 int *fp2a(int **p) {
252   // CHECK-LABEL: @fp2a
253   // CHECK: store i32 4
254   // CHECK: atomicrmw sub {{.*}} monotonic
255   // Note, the GNU builtins do not multiply by sizeof(T)!
256   return __atomic_fetch_sub(p, 4, memory_order_relaxed);
257 }
258 
259 _Complex float fc(_Atomic(_Complex float) *c) {
260   // CHECK-LABEL: @fc
261   // CHECK: atomicrmw xchg i64*
262   return __c11_atomic_exchange(c, 2, memory_order_seq_cst);
263 }
264 
265 typedef struct X { int x; } X;
266 X fs(_Atomic(X) *c) {
267   // CHECK-LABEL: @fs
268   // CHECK: atomicrmw xchg i32*
269   return __c11_atomic_exchange(c, (X){2}, memory_order_seq_cst);
270 }
271 
272 X fsa(X *c, X *d) {
273   // CHECK-LABEL: @fsa
274   // CHECK: atomicrmw xchg i32*
275   X ret;
276   __atomic_exchange(c, d, &ret, memory_order_seq_cst);
277   return ret;
278 }
279 
280 _Bool fsb(_Bool *c) {
281   // CHECK-LABEL: @fsb
282   // CHECK: atomicrmw xchg i8*
283   return __atomic_exchange_n(c, 1, memory_order_seq_cst);
284 }
285 
286 char flag1;
287 volatile char flag2;
288 void test_and_set() {
289   // CHECK: atomicrmw xchg i8* @flag1, i8 1 seq_cst
290   __atomic_test_and_set(&flag1, memory_order_seq_cst);
291   // CHECK: atomicrmw volatile xchg i8* @flag2, i8 1 acquire
292   __atomic_test_and_set(&flag2, memory_order_acquire);
293   // CHECK: store atomic volatile i8 0, i8* @flag2 release
294   __atomic_clear(&flag2, memory_order_release);
295   // CHECK: store atomic i8 0, i8* @flag1 seq_cst
296   __atomic_clear(&flag1, memory_order_seq_cst);
297 }
298 
299 struct Sixteen {
300   char c[16];
301 } sixteen;
302 struct Seventeen {
303   char c[17];
304 } seventeen;
305 
306 int lock_free(struct Incomplete *incomplete) {
307   // CHECK-LABEL: @lock_free
308 
309   // CHECK: call i32 @__atomic_is_lock_free(i32 3, i8* null)
310   __c11_atomic_is_lock_free(3);
311 
312   // CHECK: call i32 @__atomic_is_lock_free(i32 16, i8* {{.*}}@sixteen{{.*}})
313   __atomic_is_lock_free(16, &sixteen);
314 
315   // CHECK: call i32 @__atomic_is_lock_free(i32 17, i8* {{.*}}@seventeen{{.*}})
316   __atomic_is_lock_free(17, &seventeen);
317 
318   // CHECK: call i32 @__atomic_is_lock_free(i32 4, {{.*}})
319   __atomic_is_lock_free(4, incomplete);
320 
321   char cs[20];
322   // CHECK: call i32 @__atomic_is_lock_free(i32 4, {{.*}})
323   __atomic_is_lock_free(4, cs+1);
324 
325   // CHECK-NOT: call
326   __atomic_always_lock_free(3, 0);
327   __atomic_always_lock_free(16, 0);
328   __atomic_always_lock_free(17, 0);
329   __atomic_always_lock_free(16, &sixteen);
330   __atomic_always_lock_free(17, &seventeen);
331 
332   int n;
333   __atomic_is_lock_free(4, &n);
334 
335   // CHECK: ret i32 1
336   return __c11_atomic_is_lock_free(sizeof(_Atomic(int)));
337 }
338 
339 // Tests for atomic operations on big values.  These should call the functions
340 // defined here:
341 // http://gcc.gnu.org/wiki/Atomic/GCCMM/LIbrary#The_Library_interface
342 
343 struct foo {
344   int big[128];
345 };
346 struct bar {
347   char c[3];
348 };
349 
350 struct bar smallThing, thing1, thing2;
351 struct foo bigThing;
352 _Atomic(struct foo) bigAtomic;
353 
354 void structAtomicStore() {
355   // CHECK-LABEL: @structAtomicStore
356   struct foo f = {0};
357   struct bar b = {0};
358   __atomic_store(&smallThing, &b, 5);
359   // CHECK: call void @__atomic_store(i32 3, i8* {{.*}} @smallThing
360 
361   __atomic_store(&bigThing, &f, 5);
362   // CHECK: call void @__atomic_store(i32 512, i8* {{.*}} @bigThing
363 }
364 void structAtomicLoad() {
365   // CHECK-LABEL: @structAtomicLoad
366   struct bar b;
367   __atomic_load(&smallThing, &b, 5);
368   // CHECK: call void @__atomic_load(i32 3, i8* {{.*}} @smallThing
369 
370   struct foo f = {0};
371   __atomic_load(&bigThing, &f, 5);
372   // CHECK: call void @__atomic_load(i32 512, i8* {{.*}} @bigThing
373 }
374 struct foo structAtomicExchange() {
375   // CHECK-LABEL: @structAtomicExchange
376   struct foo f = {0};
377   struct foo old;
378   __atomic_exchange(&f, &bigThing, &old, 5);
379   // CHECK: call void @__atomic_exchange(i32 512, {{.*}}, i8* bitcast ({{.*}} @bigThing to i8*),
380 
381   return __c11_atomic_exchange(&bigAtomic, f, 5);
382   // CHECK: call void @__atomic_exchange(i32 512, i8* bitcast ({{.*}} @bigAtomic to i8*),
383 }
384 int structAtomicCmpExchange() {
385   // CHECK-LABEL: @structAtomicCmpExchange
386   _Bool x = __atomic_compare_exchange(&smallThing, &thing1, &thing2, 1, 5, 5);
387   // CHECK: call zeroext i1 @__atomic_compare_exchange(i32 3, {{.*}} @smallThing{{.*}} @thing1{{.*}} @thing2
388 
389   struct foo f = {0};
390   struct foo g = {0};
391   g.big[12] = 12;
392   return x & __c11_atomic_compare_exchange_strong(&bigAtomic, &f, g, 5, 5);
393   // CHECK: call zeroext i1 @__atomic_compare_exchange(i32 512, i8* bitcast ({{.*}} @bigAtomic to i8*),
394 }
395 
396 // Check that no atomic operations are used in any initialisation of _Atomic
397 // types.
398 _Atomic(int) atomic_init_i = 42;
399 
400 // CHECK-LABEL: @atomic_init_foo
401 void atomic_init_foo()
402 {
403   // CHECK-NOT: }
404   // CHECK-NOT: atomic
405   // CHECK: store
406   _Atomic(int) j = 12;
407 
408   // CHECK-NOT: }
409   // CHECK-NOT: atomic
410   // CHECK: store
411   __c11_atomic_init(&j, 42);
412 
413   // CHECK-NOT: atomic
414   // CHECK: }
415 }
416 
417 // CHECK-LABEL: @failureOrder
418 void failureOrder(_Atomic(int) *ptr, int *ptr2) {
419   __c11_atomic_compare_exchange_strong(ptr, ptr2, 43, memory_order_acquire, memory_order_relaxed);
420   // CHECK: cmpxchg i32* {{%[0-9A-Za-z._]+}}, i32 {{%[0-9A-Za-z._]+}}, i32 {{%[0-9A-Za-z_.]+}} acquire monotonic
421 
422   __c11_atomic_compare_exchange_weak(ptr, ptr2, 43, memory_order_seq_cst, memory_order_acquire);
423   // CHECK: cmpxchg weak i32* {{%[0-9A-Za-z._]+}}, i32 {{%[0-9A-Za-z._]+}}, i32 {{%[0-9A-Za-z_.]+}} seq_cst acquire
424 
425   // Unknown ordering: conservatively pick strongest valid option (for now!).
426   __atomic_compare_exchange(ptr2, ptr2, ptr2, 0, memory_order_acq_rel, *ptr2);
427   // CHECK: cmpxchg i32* {{%[0-9A-Za-z._]+}}, i32 {{%[0-9A-Za-z._]+}}, i32 {{%[0-9A-Za-z_.]+}} acq_rel acquire
428 
429   // Undefined behaviour: don't really care what that last ordering is so leave
430   // it out:
431   __atomic_compare_exchange_n(ptr2, ptr2, 43, 1, memory_order_seq_cst, 42);
432   // CHECK: cmpxchg weak i32* {{%[0-9A-Za-z._]+}}, i32 {{%[0-9A-Za-z._]+}}, i32 {{%[0-9A-Za-z_.]+}} seq_cst
433 }
434 
435 // CHECK-LABEL: @generalFailureOrder
436 void generalFailureOrder(_Atomic(int) *ptr, int *ptr2, int success, int fail) {
437   __c11_atomic_compare_exchange_strong(ptr, ptr2, 42, success, fail);
438   // CHECK: switch i32 {{.*}}, label %[[MONOTONIC:[0-9a-zA-Z._]+]] [
439   // CHECK-NEXT: i32 1, label %[[ACQUIRE:[0-9a-zA-Z._]+]]
440   // CHECK-NEXT: i32 2, label %[[ACQUIRE]]
441   // CHECK-NEXT: i32 3, label %[[RELEASE:[0-9a-zA-Z._]+]]
442   // CHECK-NEXT: i32 4, label %[[ACQREL:[0-9a-zA-Z._]+]]
443   // CHECK-NEXT: i32 5, label %[[SEQCST:[0-9a-zA-Z._]+]]
444 
445   // CHECK: [[MONOTONIC]]
446   // CHECK: switch {{.*}}, label %[[MONOTONIC_MONOTONIC:[0-9a-zA-Z._]+]] [
447   // CHECK-NEXT: ]
448 
449   // CHECK: [[ACQUIRE]]
450   // CHECK: switch {{.*}}, label %[[ACQUIRE_MONOTONIC:[0-9a-zA-Z._]+]] [
451   // CHECK-NEXT: i32 1, label %[[ACQUIRE_ACQUIRE:[0-9a-zA-Z._]+]]
452   // CHECK-NEXT: i32 2, label %[[ACQUIRE_ACQUIRE:[0-9a-zA-Z._]+]]
453   // CHECK-NEXT: ]
454 
455   // CHECK: [[RELEASE]]
456   // CHECK: switch {{.*}}, label %[[RELEASE_MONOTONIC:[0-9a-zA-Z._]+]] [
457   // CHECK-NEXT: ]
458 
459   // CHECK: [[ACQREL]]
460   // CHECK: switch {{.*}}, label %[[ACQREL_MONOTONIC:[0-9a-zA-Z._]+]] [
461   // CHECK-NEXT: i32 1, label %[[ACQREL_ACQUIRE:[0-9a-zA-Z._]+]]
462   // CHECK-NEXT: i32 2, label %[[ACQREL_ACQUIRE:[0-9a-zA-Z._]+]]
463   // CHECK-NEXT: ]
464 
465   // CHECK: [[SEQCST]]
466   // CHECK: switch {{.*}}, label %[[SEQCST_MONOTONIC:[0-9a-zA-Z._]+]] [
467   // CHECK-NEXT: i32 1, label %[[SEQCST_ACQUIRE:[0-9a-zA-Z._]+]]
468   // CHECK-NEXT: i32 2, label %[[SEQCST_ACQUIRE:[0-9a-zA-Z._]+]]
469   // CHECK-NEXT: i32 5, label %[[SEQCST_SEQCST:[0-9a-zA-Z._]+]]
470   // CHECK-NEXT: ]
471 
472   // CHECK: [[MONOTONIC_MONOTONIC]]
473   // CHECK: cmpxchg {{.*}} monotonic monotonic
474   // CHECK: br
475 
476   // CHECK: [[ACQUIRE_MONOTONIC]]
477   // CHECK: cmpxchg {{.*}} acquire monotonic
478   // CHECK: br
479 
480   // CHECK: [[ACQUIRE_ACQUIRE]]
481   // CHECK: cmpxchg {{.*}} acquire acquire
482   // CHECK: br
483 
484   // CHECK: [[ACQREL_MONOTONIC]]
485   // CHECK: cmpxchg {{.*}} acq_rel monotonic
486   // CHECK: br
487 
488   // CHECK: [[ACQREL_ACQUIRE]]
489   // CHECK: cmpxchg {{.*}} acq_rel acquire
490   // CHECK: br
491 
492   // CHECK: [[SEQCST_MONOTONIC]]
493   // CHECK: cmpxchg {{.*}} seq_cst monotonic
494   // CHECK: br
495 
496   // CHECK: [[SEQCST_ACQUIRE]]
497   // CHECK: cmpxchg {{.*}} seq_cst acquire
498   // CHECK: br
499 
500   // CHECK: [[SEQCST_SEQCST]]
501   // CHECK: cmpxchg {{.*}} seq_cst seq_cst
502   // CHECK: br
503 }
504 
505 void generalWeakness(int *ptr, int *ptr2, _Bool weak) {
506   __atomic_compare_exchange_n(ptr, ptr2, 42, weak, memory_order_seq_cst, memory_order_seq_cst);
507   // CHECK: switch i1 {{.*}}, label %[[WEAK:[0-9a-zA-Z._]+]] [
508   // CHECK-NEXT: i1 false, label %[[STRONG:[0-9a-zA-Z._]+]]
509 
510   // CHECK: [[STRONG]]
511   // CHECK-NOT: br
512   // CHECK: cmpxchg {{.*}} seq_cst seq_cst
513   // CHECK: br
514 
515   // CHECK: [[WEAK]]
516   // CHECK-NOT: br
517   // CHECK: cmpxchg weak {{.*}} seq_cst seq_cst
518   // CHECK: br
519 }
520 
521 // Having checked the flow in the previous two cases, we'll trust clang to
522 // combine them sanely.
523 void EMIT_ALL_THE_THINGS(int *ptr, int *ptr2, int new, _Bool weak, int success, int fail) {
524   __atomic_compare_exchange(ptr, ptr2, &new, weak, success, fail);
525 
526   // CHECK: = cmpxchg {{.*}} monotonic monotonic
527   // CHECK: = cmpxchg weak {{.*}} monotonic monotonic
528   // CHECK: = cmpxchg {{.*}} acquire monotonic
529   // CHECK: = cmpxchg {{.*}} acquire acquire
530   // CHECK: = cmpxchg weak {{.*}} acquire monotonic
531   // CHECK: = cmpxchg weak {{.*}} acquire acquire
532   // CHECK: = cmpxchg {{.*}} release monotonic
533   // CHECK: = cmpxchg weak {{.*}} release monotonic
534   // CHECK: = cmpxchg {{.*}} acq_rel monotonic
535   // CHECK: = cmpxchg {{.*}} acq_rel acquire
536   // CHECK: = cmpxchg weak {{.*}} acq_rel monotonic
537   // CHECK: = cmpxchg weak {{.*}} acq_rel acquire
538   // CHECK: = cmpxchg {{.*}} seq_cst monotonic
539   // CHECK: = cmpxchg {{.*}} seq_cst acquire
540   // CHECK: = cmpxchg {{.*}} seq_cst seq_cst
541   // CHECK: = cmpxchg weak {{.*}} seq_cst monotonic
542   // CHECK: = cmpxchg weak {{.*}} seq_cst acquire
543   // CHECK: = cmpxchg weak {{.*}} seq_cst seq_cst
544 }
545 
546 #endif
547