| 1 | #include <stdbool.h>
|
|---|
| 2 | #include <stdint.h>
|
|---|
| 3 |
|
|---|
| 4 | void foo() {
|
|---|
| 5 | volatile _Bool * vpB = 0; _Bool vB = 0;
|
|---|
| 6 | volatile char * vpc = 0; char * rpc = 0; char vc = 0;
|
|---|
| 7 | volatile short * vps = 0; short * rps = 0; short vs = 0;
|
|---|
| 8 | volatile int * vpi = 0; int * rpi = 0; int vi = 0;
|
|---|
| 9 | volatile long int * vpl = 0; long int * rpl = 0; long int vl = 0;
|
|---|
| 10 | volatile long long int * vpll = 0; long long int * rpll = 0; long long int vll = 0;
|
|---|
| 11 | #if defined(__SIZEOF_INT128__)
|
|---|
| 12 | volatile __int128 * vplll = 0; __int128 * rplll = 0; __int128 vlll = 0;
|
|---|
| 13 | #endif
|
|---|
| 14 | struct type * volatile * vpp = 0; struct type ** rpp = 0; struct type * vp = 0;
|
|---|
| 15 |
|
|---|
| 16 | { char ret; ret = __sync_fetch_and_add(vpc, vc); }
|
|---|
| 17 | { short ret; ret = __sync_fetch_and_add(vps, vs); }
|
|---|
| 18 | { int ret; ret = __sync_fetch_and_add(vpi, vi); }
|
|---|
| 19 | { long int ret; ret = __sync_fetch_and_add(vpl, vl); }
|
|---|
| 20 | { long long int ret; ret = __sync_fetch_and_add(vpll, vll); }
|
|---|
| 21 | #if defined(__SIZEOF_INT128__)
|
|---|
| 22 | { __int128 ret; ret = __sync_fetch_and_add(vplll, vlll); }
|
|---|
| 23 | #endif
|
|---|
| 24 |
|
|---|
| 25 | { char ret; ret = __sync_fetch_and_sub(vpc, vc); }
|
|---|
| 26 | { short ret; ret = __sync_fetch_and_sub(vps, vs); }
|
|---|
| 27 | { int ret; ret = __sync_fetch_and_sub(vpi, vi); }
|
|---|
| 28 | { long int ret; ret = __sync_fetch_and_sub(vpl, vl); }
|
|---|
| 29 | { long long int ret; ret = __sync_fetch_and_sub(vpll, vll); }
|
|---|
| 30 | #if defined(__SIZEOF_INT128__)
|
|---|
| 31 | { __int128 ret; ret = __sync_fetch_and_sub(vplll, vlll); }
|
|---|
| 32 | #endif
|
|---|
| 33 |
|
|---|
| 34 | { char ret; ret = __sync_fetch_and_or(vpc, vc); }
|
|---|
| 35 | { short ret; ret = __sync_fetch_and_or(vps, vs); }
|
|---|
| 36 | { int ret; ret = __sync_fetch_and_or(vpi, vi); }
|
|---|
| 37 | { long int ret; ret = __sync_fetch_and_or(vpl, vl); }
|
|---|
| 38 | { long long int ret; ret = __sync_fetch_and_or(vpll, vll); }
|
|---|
| 39 | #if defined(__SIZEOF_INT128__)
|
|---|
| 40 | { __int128 ret; ret = __sync_fetch_and_or(vplll, vlll); }
|
|---|
| 41 | #endif
|
|---|
| 42 |
|
|---|
| 43 | { char ret; ret = __sync_fetch_and_and(vpc, vc); }
|
|---|
| 44 | { short ret; ret = __sync_fetch_and_and(vps, vs); }
|
|---|
| 45 | { int ret; ret = __sync_fetch_and_and(vpi, vi); }
|
|---|
| 46 | { long int ret; ret = __sync_fetch_and_and(vpl, vl); }
|
|---|
| 47 | { long long int ret; ret = __sync_fetch_and_and(vpll, vll); }
|
|---|
| 48 | #if defined(__SIZEOF_INT128__)
|
|---|
| 49 | { __int128 ret; ret = __sync_fetch_and_and(vplll, vlll); }
|
|---|
| 50 | #endif
|
|---|
| 51 |
|
|---|
| 52 | { char ret; ret = __sync_fetch_and_xor(vpc, vc); }
|
|---|
| 53 | { short ret; ret = __sync_fetch_and_xor(vps, vs); }
|
|---|
| 54 | { int ret; ret = __sync_fetch_and_xor(vpi, vi); }
|
|---|
| 55 | { long int ret; ret = __sync_fetch_and_xor(vpl, vl); }
|
|---|
| 56 | { long long int ret; ret = __sync_fetch_and_xor(vpll, vll); }
|
|---|
| 57 | #if defined(__SIZEOF_INT128__)
|
|---|
| 58 | { __int128 ret; ret = __sync_fetch_and_xor(vplll, vlll); }
|
|---|
| 59 | #endif
|
|---|
| 60 |
|
|---|
| 61 | { char ret; ret = __sync_fetch_and_nand(vpc, vc); }
|
|---|
| 62 | { short ret; ret = __sync_fetch_and_nand(vps, vs); }
|
|---|
| 63 | { int ret; ret = __sync_fetch_and_nand(vpi, vi); }
|
|---|
| 64 | { long int ret; ret = __sync_fetch_and_nand(vpl, vl); }
|
|---|
| 65 | { long long int ret; ret = __sync_fetch_and_nand(vpll, vll); }
|
|---|
| 66 | #if defined(__SIZEOF_INT128__)
|
|---|
| 67 | { __int128 ret; ret = __sync_fetch_and_nand(vplll, vlll); }
|
|---|
| 68 | { __int128 ret; ret = __sync_fetch_and_nand_16(vplll, vlll); }
|
|---|
| 69 | #endif
|
|---|
| 70 |
|
|---|
| 71 | { char ret; ret = __sync_add_and_fetch(vpc, vc); }
|
|---|
| 72 | { short ret; ret = __sync_add_and_fetch(vps, vs); }
|
|---|
| 73 | { int ret; ret = __sync_add_and_fetch(vpi, vi); }
|
|---|
| 74 | { long int ret; ret = __sync_add_and_fetch(vpl, vl); }
|
|---|
| 75 | { long long int ret; ret = __sync_add_and_fetch(vpll, vll); }
|
|---|
| 76 | #if defined(__SIZEOF_INT128__)
|
|---|
| 77 | { __int128 ret; ret = __sync_add_and_fetch(vplll, vlll); }
|
|---|
| 78 | #endif
|
|---|
| 79 |
|
|---|
| 80 | { char ret; ret = __sync_sub_and_fetch(vpc, vc); }
|
|---|
| 81 | { short ret; ret = __sync_sub_and_fetch(vps, vs); }
|
|---|
| 82 | { int ret; ret = __sync_sub_and_fetch(vpi, vi); }
|
|---|
| 83 | { long int ret; ret = __sync_sub_and_fetch(vpl, vl); }
|
|---|
| 84 | { long long int ret; ret = __sync_sub_and_fetch(vpll, vll); }
|
|---|
| 85 | #if defined(__SIZEOF_INT128__)
|
|---|
| 86 | { __int128 ret; ret = __sync_sub_and_fetch(vplll, vlll); }
|
|---|
| 87 | #endif
|
|---|
| 88 |
|
|---|
| 89 | { char ret; ret = __sync_or_and_fetch(vpc, vc); }
|
|---|
| 90 | { short ret; ret = __sync_or_and_fetch(vps, vs); }
|
|---|
| 91 | { int ret; ret = __sync_or_and_fetch(vpi, vi); }
|
|---|
| 92 | { long int ret; ret = __sync_or_and_fetch(vpl, vl); }
|
|---|
| 93 | { long long int ret; ret = __sync_or_and_fetch(vpll, vll); }
|
|---|
| 94 | #if defined(__SIZEOF_INT128__)
|
|---|
| 95 | { __int128 ret; ret = __sync_or_and_fetch(vplll, vlll); }
|
|---|
| 96 | #endif
|
|---|
| 97 |
|
|---|
| 98 | { char ret; ret = __sync_and_and_fetch(vpc, vc); }
|
|---|
| 99 | { short ret; ret = __sync_and_and_fetch(vps, vs); }
|
|---|
| 100 | { int ret; ret = __sync_and_and_fetch(vpi, vi); }
|
|---|
| 101 | { long int ret; ret = __sync_and_and_fetch(vpl, vl); }
|
|---|
| 102 | { long long int ret; ret = __sync_and_and_fetch(vpll, vll); }
|
|---|
| 103 | #if defined(__SIZEOF_INT128__)
|
|---|
| 104 | { __int128 ret; ret = __sync_and_and_fetch(vplll, vlll); }
|
|---|
| 105 | #endif
|
|---|
| 106 |
|
|---|
| 107 | { char ret; ret = __sync_xor_and_fetch(vpc, vc); }
|
|---|
| 108 | { short ret; ret = __sync_xor_and_fetch(vps, vs); }
|
|---|
| 109 | { int ret; ret = __sync_xor_and_fetch(vpi, vi); }
|
|---|
| 110 | { long int ret; ret = __sync_xor_and_fetch(vpl, vl); }
|
|---|
| 111 | { long long int ret; ret = __sync_xor_and_fetch(vpll, vll); }
|
|---|
| 112 | #if defined(__SIZEOF_INT128__)
|
|---|
| 113 | { __int128 ret; ret = __sync_xor_and_fetch(vplll, vlll); }
|
|---|
| 114 | #endif
|
|---|
| 115 |
|
|---|
| 116 | { char ret; ret = __sync_nand_and_fetch(vpc, vc); }
|
|---|
| 117 | { short ret; ret = __sync_nand_and_fetch(vps, vs); }
|
|---|
| 118 | { int ret; ret = __sync_nand_and_fetch(vpi, vi); }
|
|---|
| 119 | { long int ret; ret = __sync_nand_and_fetch(vpl, vl); }
|
|---|
| 120 | { long long int ret; ret = __sync_nand_and_fetch(vpll, vll); }
|
|---|
| 121 | #if defined(__SIZEOF_INT128__)
|
|---|
| 122 | { __int128 ret; ret = __sync_nand_and_fetch(vplll, vlll); }
|
|---|
| 123 | #endif
|
|---|
| 124 |
|
|---|
| 125 | { _Bool ret; ret = __sync_bool_compare_and_swap(vpc, vc, vc); }
|
|---|
| 126 | { _Bool ret; ret = __sync_bool_compare_and_swap(vps, vs, vs); }
|
|---|
| 127 | { _Bool ret; ret = __sync_bool_compare_and_swap(vpi, vi, vi); }
|
|---|
| 128 | { _Bool ret; ret = __sync_bool_compare_and_swap(vpl, vl, vl); }
|
|---|
| 129 | { _Bool ret; ret = __sync_bool_compare_and_swap(vpll, vll, vll); }
|
|---|
| 130 | #if defined(__SIZEOF_INT128__)
|
|---|
| 131 | { _Bool ret; ret = __sync_bool_compare_and_swap(vplll, vlll, vlll); }
|
|---|
| 132 | #endif
|
|---|
| 133 | { _Bool ret; ret = __sync_bool_compare_and_swap(vpp, vp, vp); }
|
|---|
| 134 |
|
|---|
| 135 | { char ret; ret = __sync_val_compare_and_swap(vpc, vc, vc); }
|
|---|
| 136 | { short ret; ret = __sync_val_compare_and_swap(vps, vs, vs); }
|
|---|
| 137 | { int ret; ret = __sync_val_compare_and_swap(vpi, vi, vi); }
|
|---|
| 138 | { long int ret; ret = __sync_val_compare_and_swap(vpl, vl, vl); }
|
|---|
| 139 | { long long int ret; ret = __sync_val_compare_and_swap(vpll, vll, vll); }
|
|---|
| 140 | #if defined(__SIZEOF_INT128__)
|
|---|
| 141 | { __int128 ret; ret = __sync_val_compare_and_swap(vplll, vlll, vlll); }
|
|---|
| 142 | #endif
|
|---|
| 143 | { struct type * ret; ret = __sync_val_compare_and_swap(vpp, vp, vp); }
|
|---|
| 144 |
|
|---|
| 145 |
|
|---|
| 146 | { char ret; ret = __sync_lock_test_and_set(vpc, vc); }
|
|---|
| 147 | { short ret; ret = __sync_lock_test_and_set(vps, vs); }
|
|---|
| 148 | { int ret; ret = __sync_lock_test_and_set(vpi, vi); }
|
|---|
| 149 | { long int ret; ret = __sync_lock_test_and_set(vpl, vl); }
|
|---|
| 150 | { long long int ret; ret = __sync_lock_test_and_set(vpll, vll); }
|
|---|
| 151 | #if defined(__SIZEOF_INT128__)
|
|---|
| 152 | { __int128 ret; ret = __sync_lock_test_and_set(vplll, vlll); }
|
|---|
| 153 | #endif
|
|---|
| 154 |
|
|---|
| 155 | { __sync_lock_release(vpc); }
|
|---|
| 156 | { __sync_lock_release(vps); }
|
|---|
| 157 | { __sync_lock_release(vpi); }
|
|---|
| 158 | { __sync_lock_release(vpl); }
|
|---|
| 159 | { __sync_lock_release(vpll); }
|
|---|
| 160 | #if defined(__SIZEOF_INT128__)
|
|---|
| 161 | { __sync_lock_release(vplll); }
|
|---|
| 162 | #endif
|
|---|
| 163 |
|
|---|
| 164 | { __sync_synchronize(); }
|
|---|
| 165 |
|
|---|
| 166 |
|
|---|
| 167 |
|
|---|
| 168 |
|
|---|
| 169 | { _Bool ret; ret = __atomic_test_and_set(vpB, vB); }
|
|---|
| 170 | { _Bool ret; ret = __atomic_test_and_set(vpc, vc); }
|
|---|
| 171 | { __atomic_clear(vpB, vB); }
|
|---|
| 172 | { __atomic_clear(vpc, vc); }
|
|---|
| 173 |
|
|---|
| 174 | { char ret; ret = __atomic_exchange_n(vpc, vc, __ATOMIC_SEQ_CST); }
|
|---|
| 175 | { char ret; __atomic_exchange(vpc, &vc, &ret, __ATOMIC_SEQ_CST); }
|
|---|
| 176 | { short ret; ret = __atomic_exchange_n(vps, vs, __ATOMIC_SEQ_CST); }
|
|---|
| 177 | { short ret; __atomic_exchange(vps, &vs, &ret, __ATOMIC_SEQ_CST); }
|
|---|
| 178 | { int ret; ret = __atomic_exchange_n(vpi, vi, __ATOMIC_SEQ_CST); }
|
|---|
| 179 | { int ret; __atomic_exchange(vpi, &vi, &ret, __ATOMIC_SEQ_CST); }
|
|---|
| 180 | { long int ret; ret = __atomic_exchange_n(vpl, vl, __ATOMIC_SEQ_CST); }
|
|---|
| 181 | { long int ret; __atomic_exchange(vpl, &vl, &ret, __ATOMIC_SEQ_CST); }
|
|---|
| 182 | { long long int ret; ret = __atomic_exchange_n(vpll, vll, __ATOMIC_SEQ_CST); }
|
|---|
| 183 | { long long int ret; __atomic_exchange(vpll, &vll, &ret, __ATOMIC_SEQ_CST); }
|
|---|
| 184 | #if defined(__SIZEOF_INT128__)
|
|---|
| 185 | { __int128 ret; ret = __atomic_exchange_n(vplll, vlll, __ATOMIC_SEQ_CST); }
|
|---|
| 186 | { __int128 ret; __atomic_exchange(vplll, &vlll, &ret, __ATOMIC_SEQ_CST); }
|
|---|
| 187 | #endif
|
|---|
| 188 | { struct type * ret; ret = __atomic_exchange_n(vpp, vp, __ATOMIC_SEQ_CST); }
|
|---|
| 189 | { struct type * ret; __atomic_exchange(vpp, &vp, &ret, __ATOMIC_SEQ_CST); }
|
|---|
| 190 |
|
|---|
| 191 | { char ret; ret = __atomic_load_n(vpc, __ATOMIC_SEQ_CST); }
|
|---|
| 192 | { char ret; __atomic_load(vpc, &ret, __ATOMIC_SEQ_CST); }
|
|---|
| 193 | { short ret; ret = __atomic_load_n(vps, __ATOMIC_SEQ_CST); }
|
|---|
| 194 | { short ret; __atomic_load(vps, &ret, __ATOMIC_SEQ_CST); }
|
|---|
| 195 | { int ret; ret = __atomic_load_n(vpi, __ATOMIC_SEQ_CST); }
|
|---|
| 196 | { int ret; __atomic_load(vpi, &ret, __ATOMIC_SEQ_CST); }
|
|---|
| 197 | { long int ret; ret = __atomic_load_n(vpl, __ATOMIC_SEQ_CST); }
|
|---|
| 198 | { long int ret; __atomic_load(vpl, &ret, __ATOMIC_SEQ_CST); }
|
|---|
| 199 | { long long int ret; ret = __atomic_load_n(vpll, __ATOMIC_SEQ_CST); }
|
|---|
| 200 | { long long int ret; __atomic_load(vpll, &ret, __ATOMIC_SEQ_CST); }
|
|---|
| 201 | #if defined(__SIZEOF_INT128__)
|
|---|
| 202 | { __int128 ret; ret = __atomic_load_n(vplll, __ATOMIC_SEQ_CST); }
|
|---|
| 203 | { __int128 ret; __atomic_load(vplll, &ret, __ATOMIC_SEQ_CST); }
|
|---|
| 204 | #endif
|
|---|
| 205 | { struct type * ret; ret = __atomic_load_n(vpp, __ATOMIC_SEQ_CST); }
|
|---|
| 206 | { struct type * ret; __atomic_load(vpp, &ret, __ATOMIC_SEQ_CST); }
|
|---|
| 207 |
|
|---|
| 208 | { _Bool ret; ret = __atomic_compare_exchange_n(vpc, rpc, vc, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
|
|---|
| 209 | { _Bool ret; ret = __atomic_compare_exchange(vpc, rpc, &vc, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
|
|---|
| 210 | { _Bool ret; ret = __atomic_compare_exchange_n(vps, rps, vs, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
|
|---|
| 211 | { _Bool ret; ret = __atomic_compare_exchange(vps, rps, &vs, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
|
|---|
| 212 | { _Bool ret; ret = __atomic_compare_exchange_n(vpi, rpi, vi, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
|
|---|
| 213 | { _Bool ret; ret = __atomic_compare_exchange(vpi, rpi, &vi, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
|
|---|
| 214 | { _Bool ret; ret = __atomic_compare_exchange_n(vpl, rpl, vl, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
|
|---|
| 215 | { _Bool ret; ret = __atomic_compare_exchange(vpl, rpl, &vl, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
|
|---|
| 216 | { _Bool ret; ret = __atomic_compare_exchange_n(vpll, rpll, vll, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
|
|---|
| 217 | { _Bool ret; ret = __atomic_compare_exchange(vpll, rpll, &vll, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
|
|---|
| 218 | #if defined(__SIZEOF_INT128__)
|
|---|
| 219 | { _Bool ret; ret = __atomic_compare_exchange_n(vplll, rplll, vlll, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
|
|---|
| 220 | { _Bool ret; ret = __atomic_compare_exchange(vplll, rplll, &vlll, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
|
|---|
| 221 | #endif
|
|---|
| 222 | { _Bool ret; ret = __atomic_compare_exchange_n(vpp, rpp, vp, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
|
|---|
| 223 | { _Bool ret; ret = __atomic_compare_exchange(vpp, rpp, &vp, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
|
|---|
| 224 |
|
|---|
| 225 | { __atomic_store_n(vpc, vc, __ATOMIC_SEQ_CST); }
|
|---|
| 226 | { __atomic_store(vpc, &vc, __ATOMIC_SEQ_CST); }
|
|---|
| 227 | { __atomic_store_n(vps, vs, __ATOMIC_SEQ_CST); }
|
|---|
| 228 | { __atomic_store(vps, &vs, __ATOMIC_SEQ_CST); }
|
|---|
| 229 | { __atomic_store_n(vpi, vi, __ATOMIC_SEQ_CST); }
|
|---|
| 230 | { __atomic_store(vpi, &vi, __ATOMIC_SEQ_CST); }
|
|---|
| 231 | { __atomic_store_n(vpl, vl, __ATOMIC_SEQ_CST); }
|
|---|
| 232 | { __atomic_store(vpl, &vl, __ATOMIC_SEQ_CST); }
|
|---|
| 233 | { __atomic_store_n(vpll, vll, __ATOMIC_SEQ_CST); }
|
|---|
| 234 | { __atomic_store(vpll, &vll, __ATOMIC_SEQ_CST); }
|
|---|
| 235 | #if defined(__SIZEOF_INT128__)
|
|---|
| 236 | { __atomic_store_n(vplll, vlll, __ATOMIC_SEQ_CST); }
|
|---|
| 237 | { __atomic_store(vplll, &vlll, __ATOMIC_SEQ_CST); }
|
|---|
| 238 | #endif
|
|---|
| 239 | { __atomic_store_n(vpp, vp, __ATOMIC_SEQ_CST); }
|
|---|
| 240 | { __atomic_store(vpp, &vp, __ATOMIC_SEQ_CST); }
|
|---|
| 241 |
|
|---|
| 242 | { char ret; ret = __atomic_add_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
|
|---|
| 243 | { short ret; ret = __atomic_add_fetch(vps, vs, __ATOMIC_SEQ_CST); }
|
|---|
| 244 | { int ret; ret = __atomic_add_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
|
|---|
| 245 | { long int ret; ret = __atomic_add_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
|
|---|
| 246 | { long long int ret; ret = __atomic_add_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
|
|---|
| 247 | #if defined(__SIZEOF_INT128__)
|
|---|
| 248 | { __int128 ret; ret = __atomic_add_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
|
|---|
| 249 | #endif
|
|---|
| 250 |
|
|---|
| 251 | { char ret; ret = __atomic_sub_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
|
|---|
| 252 | { short ret; ret = __atomic_sub_fetch(vps, vs, __ATOMIC_SEQ_CST); }
|
|---|
| 253 | { int ret; ret = __atomic_sub_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
|
|---|
| 254 | { long int ret; ret = __atomic_sub_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
|
|---|
| 255 | { long long int ret; ret = __atomic_sub_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
|
|---|
| 256 | #if defined(__SIZEOF_INT128__)
|
|---|
| 257 | { __int128 ret; ret = __atomic_sub_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
|
|---|
| 258 | #endif
|
|---|
| 259 |
|
|---|
| 260 | { char ret; ret = __atomic_and_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
|
|---|
| 261 | { short ret; ret = __atomic_and_fetch(vps, vs, __ATOMIC_SEQ_CST); }
|
|---|
| 262 | { int ret; ret = __atomic_and_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
|
|---|
| 263 | { long int ret; ret = __atomic_and_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
|
|---|
| 264 | { long long int ret; ret = __atomic_and_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
|
|---|
| 265 | #if defined(__SIZEOF_INT128__)
|
|---|
| 266 | { __int128 ret; ret = __atomic_and_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
|
|---|
| 267 | #endif
|
|---|
| 268 |
|
|---|
| 269 | { char ret; ret = __atomic_nand_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
|
|---|
| 270 | { short ret; ret = __atomic_nand_fetch(vps, vs, __ATOMIC_SEQ_CST); }
|
|---|
| 271 | { int ret; ret = __atomic_nand_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
|
|---|
| 272 | { long int ret; ret = __atomic_nand_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
|
|---|
| 273 | { long long int ret; ret = __atomic_nand_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
|
|---|
| 274 | #if defined(__SIZEOF_INT128__)
|
|---|
| 275 | { __int128 ret; ret = __atomic_nand_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
|
|---|
| 276 | #endif
|
|---|
| 277 |
|
|---|
| 278 | { char ret; ret = __atomic_xor_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
|
|---|
| 279 | { short ret; ret = __atomic_xor_fetch(vps, vs, __ATOMIC_SEQ_CST); }
|
|---|
| 280 | { int ret; ret = __atomic_xor_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
|
|---|
| 281 | { long int ret; ret = __atomic_xor_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
|
|---|
| 282 | { long long int ret; ret = __atomic_xor_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
|
|---|
| 283 | #if defined(__SIZEOF_INT128__)
|
|---|
| 284 | { __int128 ret; ret = __atomic_xor_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
|
|---|
| 285 | #endif
|
|---|
| 286 |
|
|---|
| 287 | { char ret; ret = __atomic_or_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
|
|---|
| 288 | { short ret; ret = __atomic_or_fetch(vps, vs, __ATOMIC_SEQ_CST); }
|
|---|
| 289 | { int ret; ret = __atomic_or_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
|
|---|
| 290 | { long int ret; ret = __atomic_or_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
|
|---|
| 291 | { long long int ret; ret = __atomic_or_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
|
|---|
| 292 | #if defined(__SIZEOF_INT128__)
|
|---|
| 293 | { __int128 ret; ret = __atomic_or_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
|
|---|
| 294 | #endif
|
|---|
| 295 |
|
|---|
| 296 | { char ret; ret = __atomic_fetch_add(vpc, vc, __ATOMIC_SEQ_CST); }
|
|---|
| 297 | { short ret; ret = __atomic_fetch_add(vps, vs, __ATOMIC_SEQ_CST); }
|
|---|
| 298 | { int ret; ret = __atomic_fetch_add(vpi, vi, __ATOMIC_SEQ_CST); }
|
|---|
| 299 | { long int ret; ret = __atomic_fetch_add(vpl, vl, __ATOMIC_SEQ_CST); }
|
|---|
| 300 | { long long int ret; ret = __atomic_fetch_add(vpll, vll, __ATOMIC_SEQ_CST); }
|
|---|
| 301 | #if defined(__SIZEOF_INT128__)
|
|---|
| 302 | { __int128 ret; ret = __atomic_fetch_add(vplll, vlll, __ATOMIC_SEQ_CST); }
|
|---|
| 303 | #endif
|
|---|
| 304 |
|
|---|
| 305 | { char ret; ret = __atomic_fetch_sub(vpc, vc, __ATOMIC_SEQ_CST); }
|
|---|
| 306 | { short ret; ret = __atomic_fetch_sub(vps, vs, __ATOMIC_SEQ_CST); }
|
|---|
| 307 | { int ret; ret = __atomic_fetch_sub(vpi, vi, __ATOMIC_SEQ_CST); }
|
|---|
| 308 | { long int ret; ret = __atomic_fetch_sub(vpl, vl, __ATOMIC_SEQ_CST); }
|
|---|
| 309 | { long long int ret; ret = __atomic_fetch_sub(vpll, vll, __ATOMIC_SEQ_CST); }
|
|---|
| 310 | #if defined(__SIZEOF_INT128__)
|
|---|
| 311 | { __int128 ret; ret = __atomic_fetch_sub(vplll, vlll, __ATOMIC_SEQ_CST); }
|
|---|
| 312 | #endif
|
|---|
| 313 |
|
|---|
| 314 | { char ret; ret = __atomic_fetch_and(vpc, vc, __ATOMIC_SEQ_CST); }
|
|---|
| 315 | { short ret; ret = __atomic_fetch_and(vps, vs, __ATOMIC_SEQ_CST); }
|
|---|
| 316 | { int ret; ret = __atomic_fetch_and(vpi, vi, __ATOMIC_SEQ_CST); }
|
|---|
| 317 | { long int ret; ret = __atomic_fetch_and(vpl, vl, __ATOMIC_SEQ_CST); }
|
|---|
| 318 | { long long int ret; ret = __atomic_fetch_and(vpll, vll, __ATOMIC_SEQ_CST); }
|
|---|
| 319 | #if defined(__SIZEOF_INT128__)
|
|---|
| 320 | { __int128 ret; ret = __atomic_fetch_and(vplll, vlll, __ATOMIC_SEQ_CST); }
|
|---|
| 321 | #endif
|
|---|
| 322 |
|
|---|
| 323 | { char ret; ret = __atomic_fetch_nand(vpc, vc, __ATOMIC_SEQ_CST); }
|
|---|
| 324 | { short ret; ret = __atomic_fetch_nand(vps, vs, __ATOMIC_SEQ_CST); }
|
|---|
| 325 | { int ret; ret = __atomic_fetch_nand(vpi, vi, __ATOMIC_SEQ_CST); }
|
|---|
| 326 | { long int ret; ret = __atomic_fetch_nand(vpl, vl, __ATOMIC_SEQ_CST); }
|
|---|
| 327 | { long long int ret; ret = __atomic_fetch_nand(vpll, vll, __ATOMIC_SEQ_CST); }
|
|---|
| 328 | #if defined(__SIZEOF_INT128__)
|
|---|
| 329 | { __int128 ret; ret = __atomic_fetch_nand(vplll, vlll, __ATOMIC_SEQ_CST); }
|
|---|
| 330 | #endif
|
|---|
| 331 |
|
|---|
| 332 | { char ret; ret = __atomic_fetch_xor(vpc, vc, __ATOMIC_SEQ_CST); }
|
|---|
| 333 | { short ret; ret = __atomic_fetch_xor(vps, vs, __ATOMIC_SEQ_CST); }
|
|---|
| 334 | { int ret; ret = __atomic_fetch_xor(vpi, vi, __ATOMIC_SEQ_CST); }
|
|---|
| 335 | { long int ret; ret = __atomic_fetch_xor(vpl, vl, __ATOMIC_SEQ_CST); }
|
|---|
| 336 | { long long int ret; ret = __atomic_fetch_xor(vpll, vll, __ATOMIC_SEQ_CST); }
|
|---|
| 337 | #if defined(__SIZEOF_INT128__)
|
|---|
| 338 | { __int128 ret; ret = __atomic_fetch_xor(vplll, vlll, __ATOMIC_SEQ_CST); }
|
|---|
| 339 | #endif
|
|---|
| 340 |
|
|---|
| 341 | { char ret; ret = __atomic_fetch_or(vpc, vc, __ATOMIC_SEQ_CST); }
|
|---|
| 342 | { short ret; ret = __atomic_fetch_or(vps, vs, __ATOMIC_SEQ_CST); }
|
|---|
| 343 | { int ret; ret = __atomic_fetch_or(vpi, vi, __ATOMIC_SEQ_CST); }
|
|---|
| 344 | { long int ret; ret = __atomic_fetch_or(vpl, vl, __ATOMIC_SEQ_CST); }
|
|---|
| 345 | { long long int ret; ret = __atomic_fetch_or(vpll, vll, __ATOMIC_SEQ_CST); }
|
|---|
| 346 | #if defined(__SIZEOF_INT128__)
|
|---|
| 347 | { __int128 ret; ret = __atomic_fetch_or(vplll, vlll, __ATOMIC_SEQ_CST); }
|
|---|
| 348 | #endif
|
|---|
| 349 |
|
|---|
| 350 | { _Bool ret; ret = __atomic_always_lock_free(sizeof(int), vpi); }
|
|---|
| 351 | { _Bool ret; ret = __atomic_is_lock_free(sizeof(int), vpi); }
|
|---|
| 352 | { __atomic_thread_fence(__ATOMIC_SEQ_CST); }
|
|---|
| 353 | { __atomic_signal_fence(__ATOMIC_SEQ_CST); }
|
|---|
| 354 | }
|
|---|
| 355 |
|
|---|
| 356 | int main() {
|
|---|
| 357 | return 0;
|
|---|
| 358 | }
|
|---|
