1 /* { dg-do compile { target { powerpc*-*-* && lp64 } } } */
2 /* { dg-skip-if "" { powerpc*-*-darwin* } } */
3 /* { dg-require-effective-target powerpc_vsx_ok } */
4 /* { dg-options "-mdejagnu-cpu=power7 -O2" } */
5 /* { dg-final { scan-assembler-not "lbarx" } } */
6 /* { dg-final { scan-assembler-not "lharx" } } */
7 /* { dg-final { scan-assembler-times "lwarx" 18 } } */
8 /* { dg-final { scan-assembler-times "ldarx" 6 } } */
9 /* { dg-final { scan-assembler-not "lqarx" } } */
10 /* { dg-final { scan-assembler-not "stbcx" } } */
11 /* { dg-final { scan-assembler-not "sthcx" } } */
12 /* { dg-final { scan-assembler-times "stwcx" 18 } } */
13 /* { dg-final { scan-assembler-times "stdcx" 6 } } */
14 /* { dg-final { scan-assembler-not "stqcx" } } */
15 /* { dg-final { scan-assembler-times "bl __atomic" 6 } } */
16 /* As since PR59448 GCC promotes consume to acquire, the expected isync count
17 is 16 rather than 12. */
18 /* { dg-final { scan-assembler-times "isync" 16 } } */
19 /* { dg-final { scan-assembler-times "lwsync" 8 } } */
20 /* { dg-final { scan-assembler-not "mtvsrd" } } */
21 /* { dg-final { scan-assembler-not "mtvsrwa" } } */
22 /* { dg-final { scan-assembler-not "mtvsrwz" } } */
23 /* { dg-final { scan-assembler-not "mfvsrd" } } */
24 /* { dg-final { scan-assembler-not "mfvsrwz" } } */
25
26 /* Test for the byte atomic operations on power8 using lbarx/stbcx. */
27 char
28 char_fetch_add_relaxed (char *ptr, int value)
29 {
30 return __atomic_fetch_add (ptr, value, __ATOMIC_RELAXED);
31 }
32
33 char
34 char_fetch_sub_consume (char *ptr, int value)
35 {
36 return __atomic_fetch_sub (ptr, value, __ATOMIC_CONSUME);
37 }
38
39 char
40 char_fetch_and_acquire (char *ptr, int value)
41 {
42 return __atomic_fetch_and (ptr, value, __ATOMIC_ACQUIRE);
43 }
44
45 char
46 char_fetch_ior_release (char *ptr, int value)
47 {
48 return __atomic_fetch_or (ptr, value, __ATOMIC_RELEASE);
49 }
50
51 char
52 char_fetch_xor_acq_rel (char *ptr, int value)
53 {
54 return __atomic_fetch_xor (ptr, value, __ATOMIC_ACQ_REL);
55 }
56
57 char
58 char_fetch_nand_seq_cst (char *ptr, int value)
59 {
60 return __atomic_fetch_nand (ptr, value, __ATOMIC_SEQ_CST);
61 }
62
63 /* Test for the half word atomic operations on power8 using lharx/sthcx. */
64 short
65 short_fetch_add_relaxed (short *ptr, int value)
66 {
67 return __atomic_fetch_add (ptr, value, __ATOMIC_RELAXED);
68 }
69
70 short
71 short_fetch_sub_consume (short *ptr, int value)
72 {
73 return __atomic_fetch_sub (ptr, value, __ATOMIC_CONSUME);
74 }
75
76 short
77 short_fetch_and_acquire (short *ptr, int value)
78 {
79 return __atomic_fetch_and (ptr, value, __ATOMIC_ACQUIRE);
80 }
81
82 short
83 short_fetch_ior_release (short *ptr, int value)
84 {
85 return __atomic_fetch_or (ptr, value, __ATOMIC_RELEASE);
86 }
87
88 short
89 short_fetch_xor_acq_rel (short *ptr, int value)
90 {
91 return __atomic_fetch_xor (ptr, value, __ATOMIC_ACQ_REL);
92 }
93
94 short
95 short_fetch_nand_seq_cst (short *ptr, int value)
96 {
97 return __atomic_fetch_nand (ptr, value, __ATOMIC_SEQ_CST);
98 }
99
100 /* Test for the word atomic operations on power8 using lwarx/stwcx. */
101 int
102 int_fetch_add_relaxed (int *ptr, int value)
103 {
104 return __atomic_fetch_add (ptr, value, __ATOMIC_RELAXED);
105 }
106
107 int
108 int_fetch_sub_consume (int *ptr, int value)
109 {
110 return __atomic_fetch_sub (ptr, value, __ATOMIC_CONSUME);
111 }
112
113 int
114 int_fetch_and_acquire (int *ptr, int value)
115 {
116 return __atomic_fetch_and (ptr, value, __ATOMIC_ACQUIRE);
117 }
118
119 int
120 int_fetch_ior_release (int *ptr, int value)
121 {
122 return __atomic_fetch_or (ptr, value, __ATOMIC_RELEASE);
123 }
124
125 int
126 int_fetch_xor_acq_rel (int *ptr, int value)
127 {
128 return __atomic_fetch_xor (ptr, value, __ATOMIC_ACQ_REL);
129 }
130
131 int
132 int_fetch_nand_seq_cst (int *ptr, int value)
133 {
134 return __atomic_fetch_nand (ptr, value, __ATOMIC_SEQ_CST);
135 }
136
137 /* Test for the double word atomic operations on power8 using ldarx/stdcx. */
138 long
139 long_fetch_add_relaxed (long *ptr, long value)
140 {
141 return __atomic_fetch_add (ptr, value, __ATOMIC_RELAXED);
142 }
143
144 long
145 long_fetch_sub_consume (long *ptr, long value)
146 {
147 return __atomic_fetch_sub (ptr, value, __ATOMIC_CONSUME);
148 }
149
150 long
151 long_fetch_and_acquire (long *ptr, long value)
152 {
153 return __atomic_fetch_and (ptr, value, __ATOMIC_ACQUIRE);
154 }
155
156 long
157 long_fetch_ior_release (long *ptr, long value)
158 {
159 return __atomic_fetch_or (ptr, value, __ATOMIC_RELEASE);
160 }
161
162 long
163 long_fetch_xor_acq_rel (long *ptr, long value)
164 {
165 return __atomic_fetch_xor (ptr, value, __ATOMIC_ACQ_REL);
166 }
167
168 long
169 long_fetch_nand_seq_cst (long *ptr, long value)
170 {
171 return __atomic_fetch_nand (ptr, value, __ATOMIC_SEQ_CST);
172 }
173
174 /* Test for the quad word atomic operations on power8 using ldarx/stdcx. */
175 __int128_t
176 quad_fetch_add_relaxed (__int128_t *ptr, __int128_t value)
177 {
178 return __atomic_fetch_add (ptr, value, __ATOMIC_RELAXED);
179 }
180
181 __int128_t
182 quad_fetch_sub_consume (__int128_t *ptr, __int128_t value)
183 {
184 return __atomic_fetch_sub (ptr, value, __ATOMIC_CONSUME);
185 }
186
187 __int128_t
188 quad_fetch_and_acquire (__int128_t *ptr, __int128_t value)
189 {
190 return __atomic_fetch_and (ptr, value, __ATOMIC_ACQUIRE);
191 }
192
193 __int128_t
194 quad_fetch_ior_release (__int128_t *ptr, __int128_t value)
195 {
196 return __atomic_fetch_or (ptr, value, __ATOMIC_RELEASE);
197 }
198
199 __int128_t
200 quad_fetch_xor_acq_rel (__int128_t *ptr, __int128_t value)
201 {
202 return __atomic_fetch_xor (ptr, value, __ATOMIC_ACQ_REL);
203 }
204
205 __int128_t
206 quad_fetch_nand_seq_cst (__int128_t *ptr, __int128_t value)
207 {
208 return __atomic_fetch_nand (ptr, value, __ATOMIC_SEQ_CST);
209 }