~clint-fewbar/ubuntu/precise/erlang/merge-15b

« back to all changes in this revision

Viewing changes to erts/include/internal/ethr_atomics.h

  • Committer: Package Import Robot
  • Author(s): Sergei Golovan
  • Date: 2011-12-15 19:20:10 UTC
  • mfrom: (1.1.18) (3.5.15 sid)
  • mto: (3.5.16 sid)
  • mto: This revision was merged to the branch mainline in revision 33.
  • Revision ID: package-import@ubuntu.com-20111215192010-jnxcfe3tbrpp0big
Tags: 1:15.b-dfsg-1
* New upstream release.
* Upload to experimental because this release breaks external drivers
  API along with ABI, so several applications are to be fixed.
* Removed SSL patch because the old SSL implementation is removed from
  the upstream distribution.
* Removed never used patch which added native code to erlang beam files.
* Removed the erlang-docbuilder binary package because the docbuilder
  application was dropped by upstream.
* Documented dropping ${erlang-docbuilder:Depends} substvar in
  erlang-depends(1) manpage.
* Made erlang-base and erlang-base-hipe provide virtual package
  erlang-abi-15.b (the number means the first erlang version, which
  provides current ABI).

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*
 
2
 * --------------- DO NOT EDIT THIS FILE! ---------------
 
3
 * This file was automatically generated by the
 
4
 * $ERL_TOP/erts/lib_src/utils/make_atomics_api script.
 
5
 * If you need to make changes, edit the script and
 
6
 * regenerate this file.
 
7
 * --------------- DO NOT EDIT THIS FILE! ---------------
 
8
 */
 
9
 
 
10
/*
 
11
 * %CopyrightBegin%
 
12
 *
 
13
 * Copyright Ericsson AB 2011. All Rights Reserved.
 
14
 *
 
15
 * The contents of this file are subject to the Erlang Public License,
 
16
 * Version 1.1, (the "License"); you may not use this file except in
 
17
 * compliance with the License. You should have received a copy of the
 
18
 * Erlang Public License along with this software. If not, it can be
 
19
 * retrieved online at http://www.erlang.org/.
 
20
 *
 
21
 * Software distributed under the License is distributed on an "AS IS"
 
22
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 
23
 * the License for the specific language governing rights and limitations
 
24
 * under the License.
 
25
 *
 
26
 * %CopyrightEnd%
 
27
 */
 
28
 
 
29
/*
 
30
 * Description: The ethread atomics API
 
31
 * Author: Rickard Green
 
32
 */
 
33
 
 
34
/*
 
35
 * This file maps native atomic implementations to ethread
 
36
 * API atomics. If no native atomic implementation
 
37
 * is available, a less efficient fallback is used instead.
 
38
 * The API consists of 32-bit size, word size (pointer size),
 
39
 * and double word size atomics.
 
40
 *
 
41
 * The following atomic operations are implemented for
 
42
 * 32-bit size, and word size atomics:
 
43
 * - cmpxchg
 
44
 * - xchg
 
45
 * - set
 
46
 * - init
 
47
 * - add_read
 
48
 * - read
 
49
 * - inc_read
 
50
 * - dec_read
 
51
 * - add
 
52
 * - inc
 
53
 * - dec
 
54
 * - read_band
 
55
 * - read_bor
 
56
 *
 
57
 * The following atomic operations are implemented for
 
58
 * double word size atomics:
 
59
 * - cmpxchg
 
60
 * - set
 
61
 * - read
 
62
 * - init
 
63
 *
 
64
 * Appart from a function implementing the atomic operation
 
65
 * with unspecified memory barrier semantics, there are
 
66
 * functions implementing each operation with the following
 
67
 * memory barrier semantics:
 
68
 * - rb (read barrier)
 
69
 * - wb (write barrier)
 
70
 * - acqb (acquire barrier)
 
71
 * - relb (release barrier)
 
72
 * - mb (full memory barrier)
 
73
 *
 
74
 * We implement all of these operation/barrier
 
75
 * combinations, regardless of whether they are useful
 
76
 * or not (some of them are useless).
 
77
 *
 
78
 * Double word size atomic functions are on the followning
 
79
 * form:
 
80
 *   ethr_dw_atomic_<OP>[_<BARRIER>]
 
81
 *
 
82
 * Word size atomic functions are on the followning
 
83
 * form:
 
84
 *   ethr_atomic_<OP>[_<BARRIER>]
 
85
 *
 
86
 * 32-bit size atomic functions are on the followning
 
87
 * form:
 
88
 *   ethr_atomic32_<OP>[_<BARRIER>]
 
89
 *
 
90
 * Apart from the operation/barrier functions
 
91
 * described above also 'addr' functions are implemented
 
92
 * which return the actual memory address used of the
 
93
 * atomic variable. The 'addr' functions have no barrier
 
94
 * versions.
 
95
 *
 
96
 * The native atomic implementation does not need to
 
97
 * implement all operation/barrier combinations.
 
98
 * Functions that have no native implementation will be
 
99
 * constructed from existing native functionality. These
 
100
 * functions will perform the wanted operation and will
 
101
 * produce sufficient memory barriers, but may
 
102
 * in some cases be less efficient than pure native
 
103
 * versions.
 
104
 *
 
105
 * When we create ethread API operation/barrier functions by
 
106
 * adding barriers before and after native operations it is
 
107
 * assumed that:
 
108
 * - A native read operation begins, and ends with a load.
 
109
 * - A native set operation begins, and ends with a store.
 
110
 * - An init operation begins with either a load, or a store,
 
111
 *   and ends with either a load, or a store.
 
112
 * - All other operations begins with a load, and ends with
 
113
 *   either a load, or a store.
 
114
 *
 
115
 * This is the minimum functionality that a native
 
116
 * implementation needs to provide:
 
117
 *
 
118
 * - Functions that need to be implemented:
 
119
 *
 
120
 *   - ethr_native_[dw_|su_dw_]atomic[BITS]_addr
 
121
 *   - ethr_native_[dw_|su_dw_]atomic[BITS]_cmpxchg[_<BARRIER>]
 
122
 *     (at least one cmpxchg of optional barrier)
 
123
 *
 
124
 * - Macros that needs to be defined:
 
125
 *
 
126
 *   A macro informing about the presence of the native
 
127
 *   implementation:
 
128
 *
 
129
 *   - ETHR_HAVE_NATIVE_[DW_|SU_DW_]ATOMIC[BITS]
 
130
 *
 
131
 *   A macro naming (a string constant) the implementation:
 
132
 *
 
133
 *   - ETHR_NATIVE_[DW_]ATOMIC[BITS]_IMPL
 
134
 *
 
135
 *   Each implemented native atomic function has to
 
136
 *   be accompanied by a defined macro on the following
 
137
 *   form informing about its presence:
 
138
 *
 
139
 *   - ETHR_HAVE_ETHR_NATIVE_[DW_|SU_DW_]ATOMIC[BITS]_<OP>[_<BARRIER>]
 
140
 *
 
141
 *   A (sparc-v9 style) membar macro:
 
142
 *
 
143
 *   - ETHR_MEMBAR(B)
 
144
 *
 
145
 *     Which takes a combination of the following macros
 
146
 *     or:ed (using |) together:
 
147
 *
 
148
 *     - ETHR_LoadLoad
 
149
 *     - ETHR_LoadStore
 
150
 *     - ETHR_StoreLoad
 
151
 *     - ETHR_StoreStore
 
152
 *
 
153
 */
 
154
 
 
155
#ifndef ETHR_ATOMICS_H__
 
156
#define ETHR_ATOMICS_H__
 
157
 
 
158
#undef ETHR_AMC_FALLBACK__
 
159
#undef ETHR_AMC_NO_ATMCS__
 
160
#undef ETHR_AMC_ATMC_T__
 
161
#undef ETHR_AMC_ATMC_FUNC__
 
162
 
 
163
/* -- 32-bit atomics -- */
 
164
 
 
165
#undef ETHR_NAINT32_T__
 
166
#undef ETHR_NATMC32_FUNC__
 
167
#undef ETHR_NATMC32_ADDR_FUNC__
 
168
#undef ETHR_NATMC32_BITS__
 
169
#if defined(ETHR_HAVE_NATIVE_ATOMIC32)
 
170
#    define ETHR_NEED_NATMC32_ADDR
 
171
#  define ETHR_NATMC32_ADDR_FUNC__ ethr_native_atomic32_addr
 
172
typedef ethr_native_atomic32_t ethr_atomic32_t;
 
173
#  define ETHR_NAINT32_T__ ethr_sint32_t
 
174
#  define ETHR_NATMC32_FUNC__(X) ethr_native_atomic32_ ## X
 
175
#  define ETHR_NATMC32_BITS__ 32
 
176
#elif defined(ETHR_HAVE_NATIVE_ATOMIC64)
 
177
#  define ETHR_NEED_NATMC64_ADDR
 
178
#ifdef ETHR_BIGENDIAN
 
179
#  define ETHR_NATMC32_ADDR_FUNC__(VAR) \
 
180
  (((ethr_sint32_t *) ethr_native_atomic64_addr((VAR))) + 1)
 
181
#else
 
182
#  define ETHR_NATMC32_ADDR_FUNC__(VAR) \
 
183
  ((ethr_sint32_t *) ethr_native_atomic64_addr((VAR)))
 
184
#endif
 
185
typedef ethr_native_atomic64_t ethr_atomic32_t;
 
186
#  define ETHR_NAINT32_T__ ethr_sint64_t
 
187
#  define ETHR_NATMC32_FUNC__(X) ethr_native_atomic64_ ## X
 
188
#  define ETHR_NATMC32_BITS__ 64
 
189
#else
 
190
/*
 
191
 * No native atomics usable for 32-bits atomics :(
 
192
 * Use fallback...
 
193
 */
 
194
typedef ethr_sint32_t ethr_atomic32_t;
 
195
#endif
 
196
 
 
197
#undef ETHR_ATMC32_INLINE__
 
198
#ifdef ETHR_NATMC32_BITS__
 
199
#  ifdef ETHR_TRY_INLINE_FUNCS
 
200
#    define ETHR_ATMC32_INLINE__
 
201
#  endif
 
202
#  define ETHR_HAVE_32BIT_NATIVE_ATOMIC_OPS
 
203
#endif
 
204
 
 
205
#if !defined(ETHR_ATMC32_INLINE__) || defined(ETHR_ATOMIC_IMPL__)
 
206
#  define ETHR_NEED_ATMC32_PROTOTYPES__
 
207
#endif
 
208
 
 
209
#ifndef ETHR_INLINE_ATMC32_FUNC_NAME_
 
210
#  define ETHR_INLINE_ATMC32_FUNC_NAME_(X) X
 
211
#endif
 
212
 
 
213
#undef ETHR_ATMC32_FUNC__
 
214
#define ETHR_ATMC32_FUNC__(X) ETHR_INLINE_ATMC32_FUNC_NAME_(ethr_atomic32_ ## X)
 
215
 
 
216
 
 
217
/* -- Word size atomics -- */
 
218
 
 
219
#undef ETHR_NEED_NATMC32_ADDR
 
220
#undef ETHR_NEED_NATMC64_ADDR
 
221
 
 
222
#undef ETHR_NAINT_T__
 
223
#undef ETHR_NATMC_FUNC__
 
224
#undef ETHR_NATMC_ADDR_FUNC__
 
225
#undef ETHR_NATMC_BITS__
 
226
#if ETHR_SIZEOF_PTR == 8 && defined(ETHR_HAVE_NATIVE_ATOMIC64)
 
227
#  ifndef ETHR_NEED_NATMC64_ADDR
 
228
#    define ETHR_NEED_NATMC64_ADDR
 
229
#  endif
 
230
#  define ETHR_NATMC_ADDR_FUNC__ ethr_native_atomic64_addr
 
231
typedef ethr_native_atomic64_t ethr_atomic_t;
 
232
#  define ETHR_NAINT_T__ ethr_sint64_t
 
233
#  define ETHR_NATMC_FUNC__(X) ethr_native_atomic64_ ## X
 
234
#  define ETHR_NATMC_BITS__ 64
 
235
#elif ETHR_SIZEOF_PTR == 4 && defined(ETHR_HAVE_NATIVE_ATOMIC32)
 
236
#  ifndef ETHR_NEED_NATMC64_ADDR
 
237
#    define ETHR_NEED_NATMC32_ADDR
 
238
#  endif
 
239
#  define ETHR_NATMC_ADDR_FUNC__ ethr_native_atomic32_addr
 
240
typedef ethr_native_atomic32_t ethr_atomic_t;
 
241
#  define ETHR_NAINT_T__ ethr_sint32_t
 
242
#  define ETHR_NATMC_FUNC__(X) ethr_native_atomic32_ ## X
 
243
#  define ETHR_NATMC_BITS__ 32
 
244
#elif ETHR_SIZEOF_PTR == 4 && defined(ETHR_HAVE_NATIVE_ATOMIC64)
 
245
#  ifndef ETHR_NEED_NATMC64_ADDR
 
246
#    define ETHR_NEED_NATMC64_ADDR
 
247
#  endif
 
248
#ifdef ETHR_BIGENDIAN
 
249
#  define ETHR_NATMC_ADDR_FUNC__(VAR) \
 
250
  (((ethr_sint32_t *) ethr_native_atomic64_addr((VAR))) + 1)
 
251
#else
 
252
#  define ETHR_NATMC_ADDR_FUNC__(VAR) \
 
253
  ((ethr_sint32_t *) ethr_native_atomic64_addr((VAR)))
 
254
#endif
 
255
typedef ethr_native_atomic64_t ethr_atomic_t;
 
256
#  define ETHR_NATMC_T__ ethr_native_atomic64_t
 
257
#  define ETHR_NAINT_T__ ethr_sint64_t
 
258
#  define ETHR_NATMC_FUNC__(X) ethr_native_atomic64_ ## X
 
259
#  define ETHR_NATMC_BITS__ 64
 
260
#else
 
261
/*
 
262
 * No native atomics usable for pointer size atomics :(
 
263
 * Use fallback...
 
264
 */
 
265
 
 
266
#  if defined(ETHR_HAVE_32BIT_NATIVE_ATOMIC_OPS)
 
267
#    define ETHR_AMC_FALLBACK__
 
268
#    define ETHR_AMC_NO_ATMCS__ 2
 
269
#    define ETHR_AMC_SINT_T__ ethr_sint32_t
 
270
#    define ETHR_AMC_ATMC_T__ ethr_atomic32_t
 
271
#    define ETHR_AMC_ATMC_FUNC__(X) ETHR_INLINE_ATMC32_FUNC_NAME_(ethr_atomic32_ ## X)
 
272
typedef struct {
 
273
    ETHR_AMC_ATMC_T__ atomic[ETHR_AMC_NO_ATMCS__];
 
274
} ethr_amc_t;
 
275
typedef struct {
 
276
    ethr_amc_t amc;
 
277
    ethr_sint_t sint;
 
278
} ethr_atomic_t;
 
279
#  else /* locked fallback */
 
280
typedef ethr_sint_t ethr_atomic_t;
 
281
#  endif
 
282
#endif
 
283
 
 
284
#undef ETHR_ATMC_INLINE__
 
285
#ifdef ETHR_NATMC_BITS__
 
286
#  ifdef ETHR_TRY_INLINE_FUNCS
 
287
#    define ETHR_ATMC_INLINE__
 
288
#  endif
 
289
#  define ETHR_HAVE_WORD_SZ_NATIVE_ATOMIC_OPS
 
290
#endif
 
291
 
 
292
#if !defined(ETHR_ATMC_INLINE__) || defined(ETHR_ATOMIC_IMPL__)
 
293
#  define ETHR_NEED_ATMC_PROTOTYPES__
 
294
#endif
 
295
 
 
296
#ifndef ETHR_INLINE_ATMC_FUNC_NAME_
 
297
#  define ETHR_INLINE_ATMC_FUNC_NAME_(X) X
 
298
#endif
 
299
 
 
300
#undef ETHR_ATMC_FUNC__
 
301
#define ETHR_ATMC_FUNC__(X) ETHR_INLINE_ATMC_FUNC_NAME_(ethr_atomic_ ## X)
 
302
 
 
303
/* -- Double word atomics -- */
 
304
 
 
305
#undef ETHR_SU_DW_NAINT_T__
 
306
#undef ETHR_SU_DW_NATMC_FUNC__
 
307
#undef ETHR_SU_DW_NATMC_ADDR_FUNC__
 
308
#undef ETHR_DW_NATMC_FUNC__
 
309
#undef ETHR_DW_NATMC_ADDR_FUNC__
 
310
#undef ETHR_DW_NATMC_BITS__
 
311
#if defined(ETHR_HAVE_NATIVE_DW_ATOMIC) || defined(ETHR_HAVE_NATIVE_SU_DW_ATOMIC)
 
312
#  define ETHR_NEED_DW_NATMC_ADDR
 
313
#  define ETHR_DW_NATMC_ADDR_FUNC__ ethr_native_dw_atomic_addr
 
314
#  define ETHR_NATIVE_DW_ATOMIC_T__ ethr_native_dw_atomic_t
 
315
#  define ETHR_DW_NATMC_FUNC__(X) ethr_native_dw_atomic_ ## X
 
316
#  define ETHR_SU_DW_NATMC_FUNC__(X) ethr_native_su_dw_atomic_ ## X
 
317
#  if ETHR_SIZEOF_PTR == 8
 
318
#    define ETHR_DW_NATMC_BITS__ 128
 
319
#  elif ETHR_SIZEOF_PTR == 4
 
320
#    define ETHR_DW_NATMC_BITS__ 64
 
321
#  else
 
322
#    error "Word size not supported"
 
323
#  endif
 
324
#  ifdef ETHR_NATIVE_SU_DW_SINT_T
 
325
#    define ETHR_SU_DW_NAINT_T__ ETHR_NATIVE_SU_DW_SINT_T
 
326
#  endif
 
327
#elif ETHR_SIZEOF_PTR == 4 && defined(ETHR_HAVE_NATIVE_ATOMIC64)
 
328
#  define ETHR_HAVE_NATIVE_SU_DW_ATOMIC
 
329
#  ifndef ETHR_NEED_NATMC64_ADDR
 
330
#    define ETHR_NEED_NATMC64_ADDR
 
331
#  endif
 
332
#  define ETHR_DW_NATMC_ADDR_FUNC__(VAR) \
 
333
  ((ethr_dw_sint_t *) ethr_native_atomic64_addr((VAR)))
 
334
#  define ETHR_NATIVE_DW_ATOMIC_T__ ethr_native_atomic64_t
 
335
#  define ETHR_SU_DW_NAINT_T__ ethr_sint64_t
 
336
#  define ETHR_SU_DW_NATMC_FUNC__(X) ethr_native_atomic64_ ## X
 
337
#  define ETHR_DW_NATMC_BITS__ 64
 
338
#endif
 
339
 
 
340
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
341
#define ETHR_DW_ATOMIC_FUNC__(X) ethr_dw_atomic_ ## X ## _fallback__
 
342
#else
 
343
#define ETHR_DW_ATOMIC_FUNC__(X) ethr_dw_atomic_ ## X
 
344
#endif
 
345
 
 
346
#if !defined(ETHR_DW_NATMC_BITS__) || defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
347
#  define ETHR_NEED_DW_FALLBACK__
 
348
#endif
 
349
 
 
350
#if defined(ETHR_NEED_DW_FALLBACK__)
 
351
/*
 
352
 * No native atomics usable for double word atomics :(
 
353
 * Use fallback...
 
354
 */
 
355
 
 
356
#  ifndef ETHR_AMC_FALLBACK__
 
357
#    if ETHR_SIZEOF_PTR == 8 && defined(ETHR_HAVE_WORD_SZ_NATIVE_ATOMIC_OPS)
 
358
#      define ETHR_AMC_FALLBACK__
 
359
#      define ETHR_AMC_NO_ATMCS__ 1
 
360
#      define ETHR_AMC_SINT_T__ ethr_sint_t
 
361
#      define ETHR_AMC_ATMC_T__ ethr_atomic_t
 
362
#      define ETHR_AMC_ATMC_FUNC__(X) ETHR_INLINE_ATMC_FUNC_NAME_(ethr_atomic_ ## X)
 
363
#    elif defined(ETHR_HAVE_32BIT_NATIVE_ATOMIC_OPS)
 
364
#      define ETHR_AMC_FALLBACK__
 
365
#      define ETHR_AMC_NO_ATMCS__ 2
 
366
#      define ETHR_AMC_SINT_T__ ethr_sint32_t
 
367
#      define ETHR_AMC_ATMC_T__ ethr_atomic32_t
 
368
#      define ETHR_AMC_ATMC_FUNC__(X) ETHR_INLINE_ATMC32_FUNC_NAME_(ethr_atomic32_ ## X)
 
369
#    endif
 
370
#    ifdef ETHR_AMC_FALLBACK__
 
371
typedef struct {
 
372
    ETHR_AMC_ATMC_T__ atomic[ETHR_AMC_NO_ATMCS__];
 
373
} ethr_amc_t;
 
374
#    endif
 
375
#  endif
 
376
 
 
377
typedef struct {
 
378
#ifdef ETHR_AMC_FALLBACK__
 
379
    ethr_amc_t amc;
 
380
#endif
 
381
    ethr_sint_t sint[2];
 
382
} ethr_dw_atomic_fallback_t;
 
383
 
 
384
#endif
 
385
 
 
386
typedef union {
 
387
#ifdef ETHR_NATIVE_DW_ATOMIC_T__
 
388
    ETHR_NATIVE_DW_ATOMIC_T__ native;
 
389
#endif
 
390
#ifdef ETHR_NEED_DW_FALLBACK__
 
391
    ethr_dw_atomic_fallback_t fallback;
 
392
#endif
 
393
    ethr_sint_t sint[2];
 
394
} ethr_dw_atomic_t;
 
395
 
 
396
typedef union {
 
397
#ifdef ETHR_SU_DW_NAINT_T__
 
398
    ETHR_SU_DW_NAINT_T__ dw_sint;
 
399
#endif
 
400
    ethr_sint_t sint[2];
 
401
} ethr_dw_sint_t;
 
402
 
 
403
#ifdef ETHR_BIGENDIAN
 
404
#  define ETHR_DW_SINT_LOW_WORD 1
 
405
#  define ETHR_DW_SINT_HIGH_WORD 0
 
406
#else
 
407
#  define ETHR_DW_SINT_LOW_WORD 0
 
408
#  define ETHR_DW_SINT_HIGH_WORD 1
 
409
#endif
 
410
 
 
411
#undef ETHR_DW_ATMC_INLINE__
 
412
#ifdef ETHR_DW_NATMC_BITS__
 
413
#  ifdef ETHR_TRY_INLINE_FUNCS
 
414
#    define ETHR_ATMC32_INLINE__
 
415
#  endif
 
416
#  define ETHR_HAVE_DOUBLE_WORD_SZ_NATIVE_ATOMIC_OPS
 
417
#endif
 
418
 
 
419
#if !defined(ETHR_DW_ATMC_INLINE__) || defined(ETHR_ATOMIC_IMPL__)
 
420
#  define ETHR_NEED_DW_ATMC_PROTOTYPES__
 
421
#endif
 
422
 
 
423
#ifndef ETHR_INLINE_DW_ATMC_FUNC_NAME_
 
424
#  define ETHR_INLINE_DW_ATMC_FUNC_NAME_(X) X
 
425
#endif
 
426
 
 
427
#undef ETHR_DW_ATMC_FUNC__
 
428
#define ETHR_DW_ATMC_FUNC__(X) ETHR_INLINE_DW_ATMC_FUNC_NAME_(ethr_dw_atomic_ ## X)
 
429
 
 
430
#if defined(ETHR_NEED_DW_ATMC_PROTOTYPES__)
 
431
int ethr_have_native_dw_atomic(void);
 
432
#endif
 
433
#if defined(ETHR_DW_ATMC_INLINE__) || defined(ETHR_ATOMIC_IMPL__)
 
434
static ETHR_INLINE int
 
435
ETHR_INLINE_DW_ATMC_FUNC_NAME_(ethr_have_native_dw_atomic)(void)
 
436
{
 
437
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
438
    return ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__;
 
439
#elif defined(ETHR_DW_NATMC_BITS__)
 
440
    return 1;
 
441
#else
 
442
    return 0;
 
443
#endif
 
444
}
 
445
#endif
 
446
 
 
447
/* -- Misc -- */
 
448
 
 
449
#if defined(ETHR_TRY_INLINE_FUNCS) || defined(ETHR_ATOMIC_IMPL__)
 
450
/*
 
451
 * Unusual values are used by read() fallbacks implemented via cmpxchg().
 
452
 * We want to use an unusual value in hope that it is more efficient
 
453
 * not to match the value in memory.
 
454
 *
 
455
 * - Negative integer values are probably more unusual.
 
456
 * - Very large absolute integer values are probably more unusual.
 
457
 * - Odd pointers are probably more unusual (only char pointers can be odd).
 
458
 */
 
459
#  define ETHR_UNUSUAL_SINT32_VAL__ ((ethr_sint32_t) 0x81818181)
 
460
#  if ETHR_SIZEOF_PTR == 4
 
461
#    define ETHR_UNUSUAL_SINT_VAL__ ((ethr_sint_t) ETHR_UNUSUAL_SINT32_VAL__)
 
462
#  elif ETHR_SIZEOF_PTR == 8
 
463
#    define ETHR_UNUSUAL_SINT_VAL__ ((ethr_sint_t) 0x8181818181818181L)
 
464
#  else
 
465
#    error "Word size not supported"
 
466
#  endif
 
467
#  if defined(ETHR_NEED_DW_NATMC_ADDR) && !defined(ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_ADDR)
 
468
#    error "No ethr_native_dw_atomic_addr() available"
 
469
#  endif
 
470
#  if defined(ETHR_NEED_NATMC32_ADDR) && !defined(ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADDR)
 
471
#    error "No ethr_native_atomic32_addr() available"
 
472
#  endif
 
473
#  if defined(ETHR_NEED_NATMC64_ADDR) && !defined(ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADDR)
 
474
#    error "No ethr_native_atomic64_addr() available"
 
475
#  endif
 
476
#endif
 
477
 
 
478
#if defined(__GNUC__)
 
479
#  ifndef ETHR_COMPILER_BARRIER
 
480
#    define ETHR_COMPILER_BARRIER __asm__ __volatile__("" : : : "memory")
 
481
#  endif
 
482
#elif defined(ETHR_WIN32_THREADS)
 
483
#  ifndef ETHR_COMPILER_BARRIER
 
484
#    include <intrin.h>
 
485
#    pragma intrinsic(_ReadWriteBarrier)
 
486
#    define ETHR_COMPILER_BARRIER _ReadWriteBarrier()
 
487
#  endif
 
488
#endif
 
489
 
 
490
void ethr_compiler_barrier_fallback(void);
 
491
#ifndef ETHR_COMPILER_BARRIER
 
492
#  define ETHR_COMPILER_BARRIER ethr_compiler_barrier_fallback()
 
493
#endif
 
494
 
 
495
int ethr_init_atomics(void);
 
496
 
 
497
/* info */
 
498
char **ethr_native_atomic32_ops(void);
 
499
char **ethr_native_atomic64_ops(void);
 
500
char **ethr_native_dw_atomic_ops(void);
 
501
char **ethr_native_su_dw_atomic_ops(void);
 
502
 
 
503
#if !defined(ETHR_DW_NATMC_BITS__) && !defined(ETHR_NATMC_BITS__) && !defined(ETHR_NATMC32_BITS__)
 
504
/*
 
505
 * ETHR_*MEMORY_BARRIER orders between locked and atomic accesses only,
 
506
 * i.e. when no native atomic implementation exist and only our lock
 
507
 * based atomic fallback is used, a noop is sufficient.
 
508
 */
 
509
#  undef ETHR_MEMORY_BARRIER
 
510
#  undef ETHR_WRITE_MEMORY_BARRIER
 
511
#  undef ETHR_READ_MEMORY_BARRIER
 
512
#  undef ETHR_READ_DEPEND_MEMORY_BARRIER
 
513
#  undef ETHR_MEMBAR
 
514
#  define ETHR_MEMBAR(B) do { } while (0)
 
515
#endif
 
516
 
 
517
#ifndef ETHR_MEMBAR
 
518
#  error "No ETHR_MEMBAR defined"
 
519
#endif
 
520
 
 
521
#define ETHR_MEMORY_BARRIER ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore)
 
522
#define ETHR_WRITE_MEMORY_BARRIER ETHR_MEMBAR(ETHR_StoreStore)
 
523
#define ETHR_READ_MEMORY_BARRIER ETHR_MEMBAR(ETHR_LoadLoad)
 
524
#ifdef ETHR_READ_DEPEND_MEMORY_BARRIER
 
525
#  undef ETHR_ORDERED_READ_DEPEND
 
526
#else
 
527
#  define ETHR_READ_DEPEND_MEMORY_BARRIER ETHR_COMPILER_BARRIER
 
528
#  define ETHR_ORDERED_READ_DEPEND
 
529
#endif
 
530
 
 
531
 
 
532
/* ---------- Double word size atomic implementation ---------- */
 
533
 
 
534
 
 
535
#ifdef ETHR_NEED_DW_ATMC_PROTOTYPES__
 
536
ethr_sint_t *ethr_dw_atomic_addr(ethr_dw_atomic_t *var);
 
537
int ethr_dw_atomic_cmpxchg(ethr_dw_atomic_t *var, ethr_dw_sint_t *val, ethr_dw_sint_t *old_val);
 
538
int ethr_dw_atomic_cmpxchg_rb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val, ethr_dw_sint_t *old_val);
 
539
int ethr_dw_atomic_cmpxchg_wb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val, ethr_dw_sint_t *old_val);
 
540
int ethr_dw_atomic_cmpxchg_acqb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val, ethr_dw_sint_t *old_val);
 
541
int ethr_dw_atomic_cmpxchg_relb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val, ethr_dw_sint_t *old_val);
 
542
int ethr_dw_atomic_cmpxchg_mb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val, ethr_dw_sint_t *old_val);
 
543
void ethr_dw_atomic_set(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
544
void ethr_dw_atomic_set_rb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
545
void ethr_dw_atomic_set_wb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
546
void ethr_dw_atomic_set_acqb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
547
void ethr_dw_atomic_set_relb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
548
void ethr_dw_atomic_set_mb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
549
void ethr_dw_atomic_read(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
550
void ethr_dw_atomic_read_rb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
551
void ethr_dw_atomic_read_wb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
552
void ethr_dw_atomic_read_acqb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
553
void ethr_dw_atomic_read_relb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
554
void ethr_dw_atomic_read_mb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
555
void ethr_dw_atomic_init(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
556
void ethr_dw_atomic_init_rb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
557
void ethr_dw_atomic_init_wb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
558
void ethr_dw_atomic_init_acqb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
559
void ethr_dw_atomic_init_relb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
560
void ethr_dw_atomic_init_mb(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
561
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
562
ethr_sint_t *ETHR_DW_ATOMIC_FUNC__(addr)(ethr_dw_atomic_t *var);
 
563
int ETHR_DW_ATOMIC_FUNC__(cmpxchg)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val, ethr_dw_sint_t *old_val);
 
564
int ETHR_DW_ATOMIC_FUNC__(cmpxchg_rb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val, ethr_dw_sint_t *old_val);
 
565
int ETHR_DW_ATOMIC_FUNC__(cmpxchg_wb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val, ethr_dw_sint_t *old_val);
 
566
int ETHR_DW_ATOMIC_FUNC__(cmpxchg_acqb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val, ethr_dw_sint_t *old_val);
 
567
int ETHR_DW_ATOMIC_FUNC__(cmpxchg_relb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val, ethr_dw_sint_t *old_val);
 
568
int ETHR_DW_ATOMIC_FUNC__(cmpxchg_mb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val, ethr_dw_sint_t *old_val);
 
569
void ETHR_DW_ATOMIC_FUNC__(set)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
570
void ETHR_DW_ATOMIC_FUNC__(set_rb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
571
void ETHR_DW_ATOMIC_FUNC__(set_wb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
572
void ETHR_DW_ATOMIC_FUNC__(set_acqb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
573
void ETHR_DW_ATOMIC_FUNC__(set_relb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
574
void ETHR_DW_ATOMIC_FUNC__(set_mb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
575
void ETHR_DW_ATOMIC_FUNC__(read)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
576
void ETHR_DW_ATOMIC_FUNC__(read_rb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
577
void ETHR_DW_ATOMIC_FUNC__(read_wb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
578
void ETHR_DW_ATOMIC_FUNC__(read_acqb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
579
void ETHR_DW_ATOMIC_FUNC__(read_relb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
580
void ETHR_DW_ATOMIC_FUNC__(read_mb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
581
void ETHR_DW_ATOMIC_FUNC__(init)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
582
void ETHR_DW_ATOMIC_FUNC__(init_rb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
583
void ETHR_DW_ATOMIC_FUNC__(init_wb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
584
void ETHR_DW_ATOMIC_FUNC__(init_acqb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
585
void ETHR_DW_ATOMIC_FUNC__(init_relb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
586
void ETHR_DW_ATOMIC_FUNC__(init_mb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val);
 
587
#endif
 
588
#endif /* ETHR_NEED_DW_ATMC_PROTOTYPES__ */
 
589
 
 
590
#if (defined(ETHR_HAVE_DOUBLE_WORD_SZ_NATIVE_ATOMIC_OPS) \
 
591
     && (defined(ETHR_DW_ATMC_INLINE__) || defined(ETHR_ATOMIC_IMPL__)))
 
592
 
 
593
#if !defined(ETHR_DW_NATMC_BITS__)
 
594
#  error "Missing native atomic implementation"
 
595
#elif defined(ETHR_HAVE_NATIVE_DW_ATOMIC)  || defined(ETHR_HAVE_NATIVE_SU_DW_ATOMIC)
 
596
#  undef ETHR_HAVE_SU_DW_NATMC_CMPXCHG
 
597
#  undef ETHR_HAVE_DW_NATMC_CMPXCHG
 
598
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_CMPXCHG
 
599
#    define ETHR_HAVE_DW_NATMC_CMPXCHG 1
 
600
#  endif
 
601
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_CMPXCHG
 
602
#    define ETHR_HAVE_SU_DW_NATMC_CMPXCHG 1
 
603
#  endif
 
604
#  undef ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RB
 
605
#  undef ETHR_HAVE_DW_NATMC_CMPXCHG_RB
 
606
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_CMPXCHG_RB
 
607
#    define ETHR_HAVE_DW_NATMC_CMPXCHG_RB 1
 
608
#  endif
 
609
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_CMPXCHG_RB
 
610
#    define ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RB 1
 
611
#  endif
 
612
#  undef ETHR_HAVE_SU_DW_NATMC_CMPXCHG_WB
 
613
#  undef ETHR_HAVE_DW_NATMC_CMPXCHG_WB
 
614
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_CMPXCHG_WB
 
615
#    define ETHR_HAVE_DW_NATMC_CMPXCHG_WB 1
 
616
#  endif
 
617
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_CMPXCHG_WB
 
618
#    define ETHR_HAVE_SU_DW_NATMC_CMPXCHG_WB 1
 
619
#  endif
 
620
#  undef ETHR_HAVE_SU_DW_NATMC_CMPXCHG_ACQB
 
621
#  undef ETHR_HAVE_DW_NATMC_CMPXCHG_ACQB
 
622
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_CMPXCHG_ACQB
 
623
#    define ETHR_HAVE_DW_NATMC_CMPXCHG_ACQB 1
 
624
#  endif
 
625
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_CMPXCHG_ACQB
 
626
#    define ETHR_HAVE_SU_DW_NATMC_CMPXCHG_ACQB 1
 
627
#  endif
 
628
#  undef ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RELB
 
629
#  undef ETHR_HAVE_DW_NATMC_CMPXCHG_RELB
 
630
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_CMPXCHG_RELB
 
631
#    define ETHR_HAVE_DW_NATMC_CMPXCHG_RELB 1
 
632
#  endif
 
633
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_CMPXCHG_RELB
 
634
#    define ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RELB 1
 
635
#  endif
 
636
#  undef ETHR_HAVE_SU_DW_NATMC_CMPXCHG_MB
 
637
#  undef ETHR_HAVE_DW_NATMC_CMPXCHG_MB
 
638
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_CMPXCHG_MB
 
639
#    define ETHR_HAVE_DW_NATMC_CMPXCHG_MB 1
 
640
#  endif
 
641
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_CMPXCHG_MB
 
642
#    define ETHR_HAVE_SU_DW_NATMC_CMPXCHG_MB 1
 
643
#  endif
 
644
#  undef ETHR_HAVE_SU_DW_NATMC_SET
 
645
#  undef ETHR_HAVE_DW_NATMC_SET
 
646
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_SET
 
647
#    define ETHR_HAVE_DW_NATMC_SET 1
 
648
#  endif
 
649
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_SET
 
650
#    define ETHR_HAVE_SU_DW_NATMC_SET 1
 
651
#  endif
 
652
#  undef ETHR_HAVE_SU_DW_NATMC_SET_RB
 
653
#  undef ETHR_HAVE_DW_NATMC_SET_RB
 
654
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_SET_RB
 
655
#    define ETHR_HAVE_DW_NATMC_SET_RB 1
 
656
#  endif
 
657
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_SET_RB
 
658
#    define ETHR_HAVE_SU_DW_NATMC_SET_RB 1
 
659
#  endif
 
660
#  undef ETHR_HAVE_SU_DW_NATMC_SET_WB
 
661
#  undef ETHR_HAVE_DW_NATMC_SET_WB
 
662
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_SET_WB
 
663
#    define ETHR_HAVE_DW_NATMC_SET_WB 1
 
664
#  endif
 
665
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_SET_WB
 
666
#    define ETHR_HAVE_SU_DW_NATMC_SET_WB 1
 
667
#  endif
 
668
#  undef ETHR_HAVE_SU_DW_NATMC_SET_ACQB
 
669
#  undef ETHR_HAVE_DW_NATMC_SET_ACQB
 
670
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_SET_ACQB
 
671
#    define ETHR_HAVE_DW_NATMC_SET_ACQB 1
 
672
#  endif
 
673
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_SET_ACQB
 
674
#    define ETHR_HAVE_SU_DW_NATMC_SET_ACQB 1
 
675
#  endif
 
676
#  undef ETHR_HAVE_SU_DW_NATMC_SET_RELB
 
677
#  undef ETHR_HAVE_DW_NATMC_SET_RELB
 
678
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_SET_RELB
 
679
#    define ETHR_HAVE_DW_NATMC_SET_RELB 1
 
680
#  endif
 
681
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_SET_RELB
 
682
#    define ETHR_HAVE_SU_DW_NATMC_SET_RELB 1
 
683
#  endif
 
684
#  undef ETHR_HAVE_SU_DW_NATMC_SET_MB
 
685
#  undef ETHR_HAVE_DW_NATMC_SET_MB
 
686
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_SET_MB
 
687
#    define ETHR_HAVE_DW_NATMC_SET_MB 1
 
688
#  endif
 
689
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_SET_MB
 
690
#    define ETHR_HAVE_SU_DW_NATMC_SET_MB 1
 
691
#  endif
 
692
#  undef ETHR_HAVE_SU_DW_NATMC_READ
 
693
#  undef ETHR_HAVE_DW_NATMC_READ
 
694
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_READ
 
695
#    define ETHR_HAVE_DW_NATMC_READ 1
 
696
#  endif
 
697
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_READ
 
698
#    define ETHR_HAVE_SU_DW_NATMC_READ 1
 
699
#  endif
 
700
#  undef ETHR_HAVE_SU_DW_NATMC_READ_RB
 
701
#  undef ETHR_HAVE_DW_NATMC_READ_RB
 
702
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_READ_RB
 
703
#    define ETHR_HAVE_DW_NATMC_READ_RB 1
 
704
#  endif
 
705
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_READ_RB
 
706
#    define ETHR_HAVE_SU_DW_NATMC_READ_RB 1
 
707
#  endif
 
708
#  undef ETHR_HAVE_SU_DW_NATMC_READ_WB
 
709
#  undef ETHR_HAVE_DW_NATMC_READ_WB
 
710
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_READ_WB
 
711
#    define ETHR_HAVE_DW_NATMC_READ_WB 1
 
712
#  endif
 
713
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_READ_WB
 
714
#    define ETHR_HAVE_SU_DW_NATMC_READ_WB 1
 
715
#  endif
 
716
#  undef ETHR_HAVE_SU_DW_NATMC_READ_ACQB
 
717
#  undef ETHR_HAVE_DW_NATMC_READ_ACQB
 
718
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_READ_ACQB
 
719
#    define ETHR_HAVE_DW_NATMC_READ_ACQB 1
 
720
#  endif
 
721
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_READ_ACQB
 
722
#    define ETHR_HAVE_SU_DW_NATMC_READ_ACQB 1
 
723
#  endif
 
724
#  undef ETHR_HAVE_SU_DW_NATMC_READ_RELB
 
725
#  undef ETHR_HAVE_DW_NATMC_READ_RELB
 
726
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_READ_RELB
 
727
#    define ETHR_HAVE_DW_NATMC_READ_RELB 1
 
728
#  endif
 
729
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_READ_RELB
 
730
#    define ETHR_HAVE_SU_DW_NATMC_READ_RELB 1
 
731
#  endif
 
732
#  undef ETHR_HAVE_SU_DW_NATMC_READ_MB
 
733
#  undef ETHR_HAVE_DW_NATMC_READ_MB
 
734
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_READ_MB
 
735
#    define ETHR_HAVE_DW_NATMC_READ_MB 1
 
736
#  endif
 
737
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_READ_MB
 
738
#    define ETHR_HAVE_SU_DW_NATMC_READ_MB 1
 
739
#  endif
 
740
#  undef ETHR_HAVE_SU_DW_NATMC_INIT
 
741
#  undef ETHR_HAVE_DW_NATMC_INIT
 
742
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_INIT
 
743
#    define ETHR_HAVE_DW_NATMC_INIT 1
 
744
#  endif
 
745
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_INIT
 
746
#    define ETHR_HAVE_SU_DW_NATMC_INIT 1
 
747
#  endif
 
748
#  undef ETHR_HAVE_SU_DW_NATMC_INIT_RB
 
749
#  undef ETHR_HAVE_DW_NATMC_INIT_RB
 
750
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_INIT_RB
 
751
#    define ETHR_HAVE_DW_NATMC_INIT_RB 1
 
752
#  endif
 
753
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_INIT_RB
 
754
#    define ETHR_HAVE_SU_DW_NATMC_INIT_RB 1
 
755
#  endif
 
756
#  undef ETHR_HAVE_SU_DW_NATMC_INIT_WB
 
757
#  undef ETHR_HAVE_DW_NATMC_INIT_WB
 
758
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_INIT_WB
 
759
#    define ETHR_HAVE_DW_NATMC_INIT_WB 1
 
760
#  endif
 
761
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_INIT_WB
 
762
#    define ETHR_HAVE_SU_DW_NATMC_INIT_WB 1
 
763
#  endif
 
764
#  undef ETHR_HAVE_SU_DW_NATMC_INIT_ACQB
 
765
#  undef ETHR_HAVE_DW_NATMC_INIT_ACQB
 
766
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_INIT_ACQB
 
767
#    define ETHR_HAVE_DW_NATMC_INIT_ACQB 1
 
768
#  endif
 
769
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_INIT_ACQB
 
770
#    define ETHR_HAVE_SU_DW_NATMC_INIT_ACQB 1
 
771
#  endif
 
772
#  undef ETHR_HAVE_SU_DW_NATMC_INIT_RELB
 
773
#  undef ETHR_HAVE_DW_NATMC_INIT_RELB
 
774
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_INIT_RELB
 
775
#    define ETHR_HAVE_DW_NATMC_INIT_RELB 1
 
776
#  endif
 
777
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_INIT_RELB
 
778
#    define ETHR_HAVE_SU_DW_NATMC_INIT_RELB 1
 
779
#  endif
 
780
#  undef ETHR_HAVE_SU_DW_NATMC_INIT_MB
 
781
#  undef ETHR_HAVE_DW_NATMC_INIT_MB
 
782
#  ifdef ETHR_HAVE_ETHR_NATIVE_DW_ATOMIC_INIT_MB
 
783
#    define ETHR_HAVE_DW_NATMC_INIT_MB 1
 
784
#  endif
 
785
#  ifdef ETHR_HAVE_ETHR_NATIVE_SU_DW_ATOMIC_INIT_MB
 
786
#    define ETHR_HAVE_SU_DW_NATMC_INIT_MB 1
 
787
#  endif
 
788
#elif ETHR_DW_NATMC_BITS__ == 64
 
789
#  undef ETHR_HAVE_DW_NATMC_CMPXCHG
 
790
#  undef ETHR_HAVE_SU_DW_NATMC_CMPXCHG
 
791
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_CMPXCHG
 
792
#    define ETHR_HAVE_SU_DW_NATMC_CMPXCHG 1
 
793
#  endif
 
794
#  undef ETHR_HAVE_DW_NATMC_CMPXCHG_RB
 
795
#  undef ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RB
 
796
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_CMPXCHG_RB
 
797
#    define ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RB 1
 
798
#  endif
 
799
#  undef ETHR_HAVE_DW_NATMC_CMPXCHG_WB
 
800
#  undef ETHR_HAVE_SU_DW_NATMC_CMPXCHG_WB
 
801
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_CMPXCHG_WB
 
802
#    define ETHR_HAVE_SU_DW_NATMC_CMPXCHG_WB 1
 
803
#  endif
 
804
#  undef ETHR_HAVE_DW_NATMC_CMPXCHG_ACQB
 
805
#  undef ETHR_HAVE_SU_DW_NATMC_CMPXCHG_ACQB
 
806
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_CMPXCHG_ACQB
 
807
#    define ETHR_HAVE_SU_DW_NATMC_CMPXCHG_ACQB 1
 
808
#  endif
 
809
#  undef ETHR_HAVE_DW_NATMC_CMPXCHG_RELB
 
810
#  undef ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RELB
 
811
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_CMPXCHG_RELB
 
812
#    define ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RELB 1
 
813
#  endif
 
814
#  undef ETHR_HAVE_DW_NATMC_CMPXCHG_MB
 
815
#  undef ETHR_HAVE_SU_DW_NATMC_CMPXCHG_MB
 
816
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_CMPXCHG_MB
 
817
#    define ETHR_HAVE_SU_DW_NATMC_CMPXCHG_MB 1
 
818
#  endif
 
819
#  undef ETHR_HAVE_DW_NATMC_SET
 
820
#  undef ETHR_HAVE_SU_DW_NATMC_SET
 
821
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_SET
 
822
#    define ETHR_HAVE_SU_DW_NATMC_SET 1
 
823
#  endif
 
824
#  undef ETHR_HAVE_DW_NATMC_SET_RB
 
825
#  undef ETHR_HAVE_SU_DW_NATMC_SET_RB
 
826
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_SET_RB
 
827
#    define ETHR_HAVE_SU_DW_NATMC_SET_RB 1
 
828
#  endif
 
829
#  undef ETHR_HAVE_DW_NATMC_SET_WB
 
830
#  undef ETHR_HAVE_SU_DW_NATMC_SET_WB
 
831
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_SET_WB
 
832
#    define ETHR_HAVE_SU_DW_NATMC_SET_WB 1
 
833
#  endif
 
834
#  undef ETHR_HAVE_DW_NATMC_SET_ACQB
 
835
#  undef ETHR_HAVE_SU_DW_NATMC_SET_ACQB
 
836
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_SET_ACQB
 
837
#    define ETHR_HAVE_SU_DW_NATMC_SET_ACQB 1
 
838
#  endif
 
839
#  undef ETHR_HAVE_DW_NATMC_SET_RELB
 
840
#  undef ETHR_HAVE_SU_DW_NATMC_SET_RELB
 
841
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_SET_RELB
 
842
#    define ETHR_HAVE_SU_DW_NATMC_SET_RELB 1
 
843
#  endif
 
844
#  undef ETHR_HAVE_DW_NATMC_SET_MB
 
845
#  undef ETHR_HAVE_SU_DW_NATMC_SET_MB
 
846
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_SET_MB
 
847
#    define ETHR_HAVE_SU_DW_NATMC_SET_MB 1
 
848
#  endif
 
849
#  undef ETHR_HAVE_DW_NATMC_READ
 
850
#  undef ETHR_HAVE_SU_DW_NATMC_READ
 
851
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_READ
 
852
#    define ETHR_HAVE_SU_DW_NATMC_READ 1
 
853
#  endif
 
854
#  undef ETHR_HAVE_DW_NATMC_READ_RB
 
855
#  undef ETHR_HAVE_SU_DW_NATMC_READ_RB
 
856
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_READ_RB
 
857
#    define ETHR_HAVE_SU_DW_NATMC_READ_RB 1
 
858
#  endif
 
859
#  undef ETHR_HAVE_DW_NATMC_READ_WB
 
860
#  undef ETHR_HAVE_SU_DW_NATMC_READ_WB
 
861
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_READ_WB
 
862
#    define ETHR_HAVE_SU_DW_NATMC_READ_WB 1
 
863
#  endif
 
864
#  undef ETHR_HAVE_DW_NATMC_READ_ACQB
 
865
#  undef ETHR_HAVE_SU_DW_NATMC_READ_ACQB
 
866
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_READ_ACQB
 
867
#    define ETHR_HAVE_SU_DW_NATMC_READ_ACQB 1
 
868
#  endif
 
869
#  undef ETHR_HAVE_DW_NATMC_READ_RELB
 
870
#  undef ETHR_HAVE_SU_DW_NATMC_READ_RELB
 
871
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_READ_RELB
 
872
#    define ETHR_HAVE_SU_DW_NATMC_READ_RELB 1
 
873
#  endif
 
874
#  undef ETHR_HAVE_DW_NATMC_READ_MB
 
875
#  undef ETHR_HAVE_SU_DW_NATMC_READ_MB
 
876
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_READ_MB
 
877
#    define ETHR_HAVE_SU_DW_NATMC_READ_MB 1
 
878
#  endif
 
879
#  undef ETHR_HAVE_DW_NATMC_INIT
 
880
#  undef ETHR_HAVE_SU_DW_NATMC_INIT
 
881
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INIT
 
882
#    define ETHR_HAVE_SU_DW_NATMC_INIT 1
 
883
#  endif
 
884
#  undef ETHR_HAVE_DW_NATMC_INIT_RB
 
885
#  undef ETHR_HAVE_SU_DW_NATMC_INIT_RB
 
886
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INIT_RB
 
887
#    define ETHR_HAVE_SU_DW_NATMC_INIT_RB 1
 
888
#  endif
 
889
#  undef ETHR_HAVE_DW_NATMC_INIT_WB
 
890
#  undef ETHR_HAVE_SU_DW_NATMC_INIT_WB
 
891
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INIT_WB
 
892
#    define ETHR_HAVE_SU_DW_NATMC_INIT_WB 1
 
893
#  endif
 
894
#  undef ETHR_HAVE_DW_NATMC_INIT_ACQB
 
895
#  undef ETHR_HAVE_SU_DW_NATMC_INIT_ACQB
 
896
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INIT_ACQB
 
897
#    define ETHR_HAVE_SU_DW_NATMC_INIT_ACQB 1
 
898
#  endif
 
899
#  undef ETHR_HAVE_DW_NATMC_INIT_RELB
 
900
#  undef ETHR_HAVE_SU_DW_NATMC_INIT_RELB
 
901
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INIT_RELB
 
902
#    define ETHR_HAVE_SU_DW_NATMC_INIT_RELB 1
 
903
#  endif
 
904
#  undef ETHR_HAVE_DW_NATMC_INIT_MB
 
905
#  undef ETHR_HAVE_SU_DW_NATMC_INIT_MB
 
906
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INIT_MB
 
907
#    define ETHR_HAVE_SU_DW_NATMC_INIT_MB 1
 
908
#  endif
 
909
#else
 
910
#  error "Invalid native atomic size"
 
911
#endif
 
912
 
 
913
 
 
914
#if defined(ETHR_HAVE_NATIVE_DW_ATOMIC)
 
915
 
 
916
#if (!defined(ETHR_HAVE_DW_NATMC_CMPXCHG) \
 
917
     && !defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RB) \
 
918
     && !defined(ETHR_HAVE_DW_NATMC_CMPXCHG_WB) \
 
919
     && !defined(ETHR_HAVE_DW_NATMC_CMPXCHG_ACQB) \
 
920
     && !defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RELB) \
 
921
     && !defined(ETHR_HAVE_DW_NATMC_CMPXCHG_MB))
 
922
#  error "No native cmpxchg() op available"
 
923
#endif
 
924
 
 
925
 
 
926
/*
 
927
 * Read op used together with cmpxchg() fallback when no native op present.
 
928
 */
 
929
#if defined(ETHR_HAVE_DW_NATMC_READ)
 
930
#define ETHR_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR, VAL) \
 
931
  ETHR_DW_NATMC_FUNC__(read)(VAR, VAL)
 
932
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ)
 
933
#define ETHR_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR, VAL) \
 
934
  VAL.dw_sint = ETHR_SU_DW_NATMC_FUNC__(read)(VAR)
 
935
#elif defined(ETHR_HAVE_DW_NATMC_READ_RB)
 
936
#define ETHR_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR, VAL) \
 
937
  ETHR_DW_NATMC_FUNC__(read_rb)(VAR, VAL)
 
938
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_RB)
 
939
#define ETHR_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR, VAL) \
 
940
  VAL.dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_rb)(VAR)
 
941
#elif defined(ETHR_HAVE_DW_NATMC_READ_WB)
 
942
#define ETHR_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR, VAL) \
 
943
  ETHR_DW_NATMC_FUNC__(read_wb)(VAR, VAL)
 
944
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_WB)
 
945
#define ETHR_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR, VAL) \
 
946
  VAL.dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_wb)(VAR)
 
947
#elif defined(ETHR_HAVE_DW_NATMC_READ_ACQB)
 
948
#define ETHR_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR, VAL) \
 
949
  ETHR_DW_NATMC_FUNC__(read_acqb)(VAR, VAL)
 
950
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_ACQB)
 
951
#define ETHR_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR, VAL) \
 
952
  VAL.dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_acqb)(VAR)
 
953
#elif defined(ETHR_HAVE_DW_NATMC_READ_RELB)
 
954
#define ETHR_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR, VAL) \
 
955
  ETHR_DW_NATMC_FUNC__(read_relb)(VAR, VAL)
 
956
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_RELB)
 
957
#define ETHR_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR, VAL) \
 
958
  VAL.dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_relb)(VAR)
 
959
#elif defined(ETHR_HAVE_DW_NATMC_READ_MB)
 
960
#define ETHR_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR, VAL) \
 
961
  ETHR_DW_NATMC_FUNC__(read_mb)(VAR, VAL)
 
962
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_MB)
 
963
#define ETHR_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR, VAL) \
 
964
  VAL.dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_mb)(VAR)
 
965
#else
 
966
/*
 
967
 * We have no native read() op; guess zero and then use the
 
968
 * the atomics actual value returned from cmpxchg().
 
969
 */
 
970
#define ETHR_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR, VAL) \
 
971
do { \
 
972
  VAL.sint[0] = (ethr_sint_t) 0; \
 
973
  VAL.sint[1] = (ethr_sint_t) 0; \
 
974
} while (0)
 
975
#endif
 
976
 
 
977
/*
 
978
 * Native cmpxchg() fallback used when no native op present.
 
979
 */
 
980
#define ETHR_DW_NATMC_CMPXCHG_FALLBACK__(CMPXCHG, VAR, AVAL, OPS) \
 
981
do { \
 
982
    int res__; \
 
983
    ethr_dw_sint_t AVAL, exp_act__; \
 
984
    ETHR_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR, exp_act__); \
 
985
    do { \
 
986
        AVAL.sint[0] = exp_act__.sint[0]; \
 
987
        AVAL.sint[1] = exp_act__.sint[1]; \
 
988
        { OPS; } \
 
989
        res__ = CMPXCHG(VAR, AVAL.sint, exp_act__.sint); \
 
990
    } while (__builtin_expect(res__ == 0, 0)); \
 
991
} while (0)
 
992
 
 
993
 
 
994
#elif defined(ETHR_HAVE_NATIVE_SU_DW_ATOMIC)
 
995
 
 
996
#if (!defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG) \
 
997
     && !defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RB) \
 
998
     && !defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_WB) \
 
999
     && !defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_ACQB) \
 
1000
     && !defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RELB) \
 
1001
     && !defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_MB))
 
1002
#  error "No native cmpxchg() op available"
 
1003
#endif
 
1004
 
 
1005
 
 
1006
/*
 
1007
 * Read op used together with cmpxchg() fallback when no native op present.
 
1008
 */
 
1009
#if defined(ETHR_HAVE_SU_DW_NATMC_READ)
 
1010
#define ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR) \
 
1011
  ETHR_SU_DW_NATMC_FUNC__(read)(VAR)
 
1012
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_RB)
 
1013
#define ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR) \
 
1014
  ETHR_SU_DW_NATMC_FUNC__(read_rb)(VAR)
 
1015
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_WB)
 
1016
#define ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR) \
 
1017
  ETHR_SU_DW_NATMC_FUNC__(read_wb)(VAR)
 
1018
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_ACQB)
 
1019
#define ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR) \
 
1020
  ETHR_SU_DW_NATMC_FUNC__(read_acqb)(VAR)
 
1021
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_RELB)
 
1022
#define ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR) \
 
1023
  ETHR_SU_DW_NATMC_FUNC__(read_relb)(VAR)
 
1024
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_MB)
 
1025
#define ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR) \
 
1026
  ETHR_SU_DW_NATMC_FUNC__(read_mb)(VAR)
 
1027
#else
 
1028
/*
 
1029
 * We have no native read() op; guess zero and then use the
 
1030
 * the atomics actual value returned from cmpxchg().
 
1031
 */
 
1032
#define ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR) \
 
1033
  ((ETHR_SU_DW_NAINT_T__) 0)
 
1034
#endif
 
1035
 
 
1036
/*
 
1037
 * Native cmpxchg() fallback used when no native op present.
 
1038
 */
 
1039
#define ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(CMPXCHG, VAR, AVAL, OPS) \
 
1040
do { \
 
1041
    ETHR_SU_DW_NAINT_T__ AVAL; \
 
1042
    ETHR_SU_DW_NAINT_T__ new__, act__, exp__; \
 
1043
    act__ = ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK_READ__(VAR); \
 
1044
    do { \
 
1045
        exp__ = act__; \
 
1046
        AVAL = (ETHR_SU_DW_NAINT_T__) act__; \
 
1047
        { OPS; } \
 
1048
        new__ = (ETHR_SU_DW_NAINT_T__) AVAL; \
 
1049
        act__ = CMPXCHG(VAR, new__, exp__); \
 
1050
    } while (__builtin_expect(act__ != exp__, 0)); \
 
1051
} while (0)
 
1052
 
 
1053
 
 
1054
#else
 
1055
#  error "?!?"
 
1056
#endif
 
1057
 
 
1058
 
 
1059
 
 
1060
/* --- addr() --- */
 
1061
 
 
1062
static ETHR_INLINE ethr_sint_t *ETHR_DW_ATMC_FUNC__(addr)(ethr_dw_atomic_t *var)
 
1063
{
 
1064
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1065
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
1066
#endif
 
1067
 
 
1068
    return (ethr_sint_t *) ETHR_DW_NATMC_ADDR_FUNC__((&var->native));
 
1069
 
 
1070
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1071
    } else { return ETHR_DW_ATOMIC_FUNC__(addr)(var); }
 
1072
#endif
 
1073
 
 
1074
}
 
1075
 
 
1076
 
 
1077
/* --- cmpxchg() --- */
 
1078
 
 
1079
 
 
1080
static ETHR_INLINE int ETHR_DW_ATMC_FUNC__(cmpxchg)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val, ethr_dw_sint_t *old_val)
 
1081
{
 
1082
    int res;
 
1083
 
 
1084
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1085
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
1086
#endif
 
1087
 
 
1088
#if defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG)
 
1089
    ETHR_SU_DW_NAINT_T__ act;
 
1090
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg)(&var->native, val->dw_sint, old_val->dw_sint);
 
1091
    res = (act == old_val->dw_sint);
 
1092
    old_val->dw_sint = act;
 
1093
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RB)
 
1094
    ETHR_SU_DW_NAINT_T__ act;
 
1095
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_rb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1096
    res = (act == old_val->dw_sint);
 
1097
    old_val->dw_sint = act;
 
1098
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_WB)
 
1099
    ETHR_SU_DW_NAINT_T__ act;
 
1100
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_wb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1101
    res = (act == old_val->dw_sint);
 
1102
    old_val->dw_sint = act;
 
1103
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_ACQB)
 
1104
    ETHR_SU_DW_NAINT_T__ act;
 
1105
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_acqb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1106
    res = (act == old_val->dw_sint);
 
1107
    old_val->dw_sint = act;
 
1108
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RELB)
 
1109
    ETHR_SU_DW_NAINT_T__ act;
 
1110
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_relb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1111
    res = (act == old_val->dw_sint);
 
1112
    old_val->dw_sint = act;
 
1113
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_MB)
 
1114
    ETHR_SU_DW_NAINT_T__ act;
 
1115
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_mb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1116
    res = (act == old_val->dw_sint);
 
1117
    old_val->dw_sint = act;
 
1118
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG)
 
1119
    res = ETHR_DW_NATMC_FUNC__(cmpxchg)(&var->native, val->sint, old_val->sint);
 
1120
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RB)
 
1121
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_rb)(&var->native, val->sint, old_val->sint);
 
1122
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_WB)
 
1123
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_wb)(&var->native, val->sint, old_val->sint);
 
1124
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_ACQB)
 
1125
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_acqb)(&var->native, val->sint, old_val->sint);
 
1126
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RELB)
 
1127
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_relb)(&var->native, val->sint, old_val->sint);
 
1128
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_MB)
 
1129
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_mb)(&var->native, val->sint, old_val->sint);
 
1130
#else
 
1131
#error "Missing implementation of ethr_dw_atomic_cmpxchg()!"
 
1132
#endif
 
1133
 
 
1134
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1135
    } else { res = ETHR_DW_ATOMIC_FUNC__(cmpxchg)(var, val, old_val); }
 
1136
#endif
 
1137
 
 
1138
    return res;
 
1139
}
 
1140
 
 
1141
static ETHR_INLINE int ETHR_DW_ATMC_FUNC__(cmpxchg_rb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val, ethr_dw_sint_t *old_val)
 
1142
{
 
1143
    int res;
 
1144
 
 
1145
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1146
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
1147
#endif
 
1148
 
 
1149
#if defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RB)
 
1150
    ETHR_SU_DW_NAINT_T__ act;
 
1151
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_rb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1152
    res = (act == old_val->dw_sint);
 
1153
    old_val->dw_sint = act;
 
1154
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG)
 
1155
    ETHR_SU_DW_NAINT_T__ act;
 
1156
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg)(&var->native, val->dw_sint, old_val->dw_sint);
 
1157
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1158
    res = (act == old_val->dw_sint);
 
1159
    old_val->dw_sint = act;
 
1160
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_MB)
 
1161
    ETHR_SU_DW_NAINT_T__ act;
 
1162
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_mb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1163
    res = (act == old_val->dw_sint);
 
1164
    old_val->dw_sint = act;
 
1165
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_WB)
 
1166
    ETHR_SU_DW_NAINT_T__ act;
 
1167
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_wb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1168
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1169
    res = (act == old_val->dw_sint);
 
1170
    old_val->dw_sint = act;
 
1171
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_ACQB)
 
1172
    ETHR_SU_DW_NAINT_T__ act;
 
1173
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_acqb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1174
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1175
    res = (act == old_val->dw_sint);
 
1176
    old_val->dw_sint = act;
 
1177
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RELB)
 
1178
    ETHR_SU_DW_NAINT_T__ act;
 
1179
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_relb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1180
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1181
    res = (act == old_val->dw_sint);
 
1182
    old_val->dw_sint = act;
 
1183
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RB)
 
1184
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_rb)(&var->native, val->sint, old_val->sint);
 
1185
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG)
 
1186
    res = ETHR_DW_NATMC_FUNC__(cmpxchg)(&var->native, val->sint, old_val->sint);
 
1187
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1188
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_MB)
 
1189
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_mb)(&var->native, val->sint, old_val->sint);
 
1190
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_WB)
 
1191
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_wb)(&var->native, val->sint, old_val->sint);
 
1192
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1193
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_ACQB)
 
1194
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_acqb)(&var->native, val->sint, old_val->sint);
 
1195
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1196
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RELB)
 
1197
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_relb)(&var->native, val->sint, old_val->sint);
 
1198
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1199
#else
 
1200
#error "Missing implementation of ethr_dw_atomic_cmpxchg_rb()!"
 
1201
#endif
 
1202
 
 
1203
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1204
    } else { res = ETHR_DW_ATOMIC_FUNC__(cmpxchg_rb)(var, val, old_val); }
 
1205
#endif
 
1206
 
 
1207
    return res;
 
1208
}
 
1209
 
 
1210
static ETHR_INLINE int ETHR_DW_ATMC_FUNC__(cmpxchg_wb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val, ethr_dw_sint_t *old_val)
 
1211
{
 
1212
    int res;
 
1213
 
 
1214
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1215
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
1216
#endif
 
1217
 
 
1218
#if defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_WB)
 
1219
    ETHR_SU_DW_NAINT_T__ act;
 
1220
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_wb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1221
    res = (act == old_val->dw_sint);
 
1222
    old_val->dw_sint = act;
 
1223
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG)
 
1224
    ETHR_SU_DW_NAINT_T__ act;
 
1225
    ETHR_MEMBAR(ETHR_StoreStore);
 
1226
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg)(&var->native, val->dw_sint, old_val->dw_sint);
 
1227
    res = (act == old_val->dw_sint);
 
1228
    old_val->dw_sint = act;
 
1229
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_MB)
 
1230
    ETHR_SU_DW_NAINT_T__ act;
 
1231
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_mb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1232
    res = (act == old_val->dw_sint);
 
1233
    old_val->dw_sint = act;
 
1234
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RB)
 
1235
    ETHR_SU_DW_NAINT_T__ act;
 
1236
    ETHR_MEMBAR(ETHR_StoreStore);
 
1237
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_rb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1238
    res = (act == old_val->dw_sint);
 
1239
    old_val->dw_sint = act;
 
1240
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_ACQB)
 
1241
    ETHR_SU_DW_NAINT_T__ act;
 
1242
    ETHR_MEMBAR(ETHR_StoreStore);
 
1243
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_acqb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1244
    res = (act == old_val->dw_sint);
 
1245
    old_val->dw_sint = act;
 
1246
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RELB)
 
1247
    ETHR_SU_DW_NAINT_T__ act;
 
1248
    ETHR_MEMBAR(ETHR_StoreStore);
 
1249
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_relb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1250
    res = (act == old_val->dw_sint);
 
1251
    old_val->dw_sint = act;
 
1252
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_WB)
 
1253
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_wb)(&var->native, val->sint, old_val->sint);
 
1254
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG)
 
1255
    ETHR_MEMBAR(ETHR_StoreStore);
 
1256
    res = ETHR_DW_NATMC_FUNC__(cmpxchg)(&var->native, val->sint, old_val->sint);
 
1257
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_MB)
 
1258
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_mb)(&var->native, val->sint, old_val->sint);
 
1259
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RB)
 
1260
    ETHR_MEMBAR(ETHR_StoreStore);
 
1261
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_rb)(&var->native, val->sint, old_val->sint);
 
1262
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_ACQB)
 
1263
    ETHR_MEMBAR(ETHR_StoreStore);
 
1264
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_acqb)(&var->native, val->sint, old_val->sint);
 
1265
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RELB)
 
1266
    ETHR_MEMBAR(ETHR_StoreStore);
 
1267
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_relb)(&var->native, val->sint, old_val->sint);
 
1268
#else
 
1269
#error "Missing implementation of ethr_dw_atomic_cmpxchg_wb()!"
 
1270
#endif
 
1271
 
 
1272
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1273
    } else { res = ETHR_DW_ATOMIC_FUNC__(cmpxchg_wb)(var, val, old_val); }
 
1274
#endif
 
1275
 
 
1276
    return res;
 
1277
}
 
1278
 
 
1279
static ETHR_INLINE int ETHR_DW_ATMC_FUNC__(cmpxchg_acqb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val, ethr_dw_sint_t *old_val)
 
1280
{
 
1281
    int res;
 
1282
 
 
1283
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1284
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
1285
#endif
 
1286
 
 
1287
#if defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_ACQB)
 
1288
    ETHR_SU_DW_NAINT_T__ act;
 
1289
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_acqb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1290
    res = (act == old_val->dw_sint);
 
1291
    old_val->dw_sint = act;
 
1292
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RB)
 
1293
    ETHR_SU_DW_NAINT_T__ act;
 
1294
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_rb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1295
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1296
    res = (act == old_val->dw_sint);
 
1297
    old_val->dw_sint = act;
 
1298
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG)
 
1299
    ETHR_SU_DW_NAINT_T__ act;
 
1300
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg)(&var->native, val->dw_sint, old_val->dw_sint);
 
1301
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1302
    res = (act == old_val->dw_sint);
 
1303
    old_val->dw_sint = act;
 
1304
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_MB)
 
1305
    ETHR_SU_DW_NAINT_T__ act;
 
1306
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_mb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1307
    res = (act == old_val->dw_sint);
 
1308
    old_val->dw_sint = act;
 
1309
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_WB)
 
1310
    ETHR_SU_DW_NAINT_T__ act;
 
1311
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_wb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1312
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1313
    res = (act == old_val->dw_sint);
 
1314
    old_val->dw_sint = act;
 
1315
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RELB)
 
1316
    ETHR_SU_DW_NAINT_T__ act;
 
1317
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_relb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1318
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1319
    res = (act == old_val->dw_sint);
 
1320
    old_val->dw_sint = act;
 
1321
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_ACQB)
 
1322
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_acqb)(&var->native, val->sint, old_val->sint);
 
1323
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RB)
 
1324
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_rb)(&var->native, val->sint, old_val->sint);
 
1325
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1326
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG)
 
1327
    res = ETHR_DW_NATMC_FUNC__(cmpxchg)(&var->native, val->sint, old_val->sint);
 
1328
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1329
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_MB)
 
1330
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_mb)(&var->native, val->sint, old_val->sint);
 
1331
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_WB)
 
1332
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_wb)(&var->native, val->sint, old_val->sint);
 
1333
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1334
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RELB)
 
1335
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_relb)(&var->native, val->sint, old_val->sint);
 
1336
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1337
#else
 
1338
#error "Missing implementation of ethr_dw_atomic_cmpxchg_acqb()!"
 
1339
#endif
 
1340
 
 
1341
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1342
    } else { res = ETHR_DW_ATOMIC_FUNC__(cmpxchg_acqb)(var, val, old_val); }
 
1343
#endif
 
1344
 
 
1345
    return res;
 
1346
}
 
1347
 
 
1348
static ETHR_INLINE int ETHR_DW_ATMC_FUNC__(cmpxchg_relb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val, ethr_dw_sint_t *old_val)
 
1349
{
 
1350
    int res;
 
1351
 
 
1352
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1353
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
1354
#endif
 
1355
 
 
1356
#if defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RELB)
 
1357
    ETHR_SU_DW_NAINT_T__ act;
 
1358
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_relb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1359
    res = (act == old_val->dw_sint);
 
1360
    old_val->dw_sint = act;
 
1361
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_WB)
 
1362
    ETHR_SU_DW_NAINT_T__ act;
 
1363
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1364
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_wb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1365
    res = (act == old_val->dw_sint);
 
1366
    old_val->dw_sint = act;
 
1367
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG)
 
1368
    ETHR_SU_DW_NAINT_T__ act;
 
1369
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1370
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg)(&var->native, val->dw_sint, old_val->dw_sint);
 
1371
    res = (act == old_val->dw_sint);
 
1372
    old_val->dw_sint = act;
 
1373
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_MB)
 
1374
    ETHR_SU_DW_NAINT_T__ act;
 
1375
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_mb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1376
    res = (act == old_val->dw_sint);
 
1377
    old_val->dw_sint = act;
 
1378
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RB)
 
1379
    ETHR_SU_DW_NAINT_T__ act;
 
1380
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1381
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_rb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1382
    res = (act == old_val->dw_sint);
 
1383
    old_val->dw_sint = act;
 
1384
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_ACQB)
 
1385
    ETHR_SU_DW_NAINT_T__ act;
 
1386
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1387
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_acqb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1388
    res = (act == old_val->dw_sint);
 
1389
    old_val->dw_sint = act;
 
1390
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RELB)
 
1391
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_relb)(&var->native, val->sint, old_val->sint);
 
1392
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_WB)
 
1393
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1394
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_wb)(&var->native, val->sint, old_val->sint);
 
1395
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG)
 
1396
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1397
    res = ETHR_DW_NATMC_FUNC__(cmpxchg)(&var->native, val->sint, old_val->sint);
 
1398
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_MB)
 
1399
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_mb)(&var->native, val->sint, old_val->sint);
 
1400
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RB)
 
1401
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1402
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_rb)(&var->native, val->sint, old_val->sint);
 
1403
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_ACQB)
 
1404
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1405
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_acqb)(&var->native, val->sint, old_val->sint);
 
1406
#else
 
1407
#error "Missing implementation of ethr_dw_atomic_cmpxchg_relb()!"
 
1408
#endif
 
1409
 
 
1410
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1411
    } else { res = ETHR_DW_ATOMIC_FUNC__(cmpxchg_relb)(var, val, old_val); }
 
1412
#endif
 
1413
 
 
1414
    return res;
 
1415
}
 
1416
 
 
1417
static ETHR_INLINE int ETHR_DW_ATMC_FUNC__(cmpxchg_mb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val, ethr_dw_sint_t *old_val)
 
1418
{
 
1419
    int res;
 
1420
 
 
1421
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1422
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
1423
#endif
 
1424
 
 
1425
#if defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_MB)
 
1426
    ETHR_SU_DW_NAINT_T__ act;
 
1427
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_mb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1428
    res = (act == old_val->dw_sint);
 
1429
    old_val->dw_sint = act;
 
1430
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RELB)
 
1431
    ETHR_SU_DW_NAINT_T__ act;
 
1432
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_relb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1433
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1434
    res = (act == old_val->dw_sint);
 
1435
    old_val->dw_sint = act;
 
1436
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_ACQB)
 
1437
    ETHR_SU_DW_NAINT_T__ act;
 
1438
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1439
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_acqb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1440
    res = (act == old_val->dw_sint);
 
1441
    old_val->dw_sint = act;
 
1442
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_WB)
 
1443
    ETHR_SU_DW_NAINT_T__ act;
 
1444
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1445
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_wb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1446
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1447
    res = (act == old_val->dw_sint);
 
1448
    old_val->dw_sint = act;
 
1449
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RB)
 
1450
    ETHR_SU_DW_NAINT_T__ act;
 
1451
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1452
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg_rb)(&var->native, val->dw_sint, old_val->dw_sint);
 
1453
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1454
    res = (act == old_val->dw_sint);
 
1455
    old_val->dw_sint = act;
 
1456
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG)
 
1457
    ETHR_SU_DW_NAINT_T__ act;
 
1458
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1459
    act = ETHR_SU_DW_NATMC_FUNC__(cmpxchg)(&var->native, val->dw_sint, old_val->dw_sint);
 
1460
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1461
    res = (act == old_val->dw_sint);
 
1462
    old_val->dw_sint = act;
 
1463
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_MB)
 
1464
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_mb)(&var->native, val->sint, old_val->sint);
 
1465
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RELB)
 
1466
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_relb)(&var->native, val->sint, old_val->sint);
 
1467
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1468
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_ACQB)
 
1469
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1470
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_acqb)(&var->native, val->sint, old_val->sint);
 
1471
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_WB)
 
1472
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1473
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_wb)(&var->native, val->sint, old_val->sint);
 
1474
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1475
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RB)
 
1476
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1477
    res = ETHR_DW_NATMC_FUNC__(cmpxchg_rb)(&var->native, val->sint, old_val->sint);
 
1478
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1479
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG)
 
1480
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1481
    res = ETHR_DW_NATMC_FUNC__(cmpxchg)(&var->native, val->sint, old_val->sint);
 
1482
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1483
#else
 
1484
#error "Missing implementation of ethr_dw_atomic_cmpxchg_mb()!"
 
1485
#endif
 
1486
 
 
1487
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1488
    } else { res = ETHR_DW_ATOMIC_FUNC__(cmpxchg_mb)(var, val, old_val); }
 
1489
#endif
 
1490
 
 
1491
    return res;
 
1492
}
 
1493
 
 
1494
 
 
1495
/* --- set() --- */
 
1496
 
 
1497
 
 
1498
static ETHR_INLINE void ETHR_DW_ATMC_FUNC__(set)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val)
 
1499
{
 
1500
 
 
1501
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1502
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
1503
#endif
 
1504
 
 
1505
#if defined(ETHR_HAVE_SU_DW_NATMC_SET)
 
1506
    ETHR_SU_DW_NATMC_FUNC__(set)(&var->native, val->dw_sint);
 
1507
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_RB)
 
1508
    ETHR_SU_DW_NATMC_FUNC__(set_rb)(&var->native, val->dw_sint);
 
1509
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_WB)
 
1510
    ETHR_SU_DW_NATMC_FUNC__(set_wb)(&var->native, val->dw_sint);
 
1511
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_ACQB)
 
1512
    ETHR_SU_DW_NATMC_FUNC__(set_acqb)(&var->native, val->dw_sint);
 
1513
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_RELB)
 
1514
    ETHR_SU_DW_NATMC_FUNC__(set_relb)(&var->native, val->dw_sint);
 
1515
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_MB)
 
1516
    ETHR_SU_DW_NATMC_FUNC__(set_mb)(&var->native, val->dw_sint);
 
1517
#elif defined(ETHR_HAVE_DW_NATMC_SET)
 
1518
    ETHR_DW_NATMC_FUNC__(set)(&var->native, val->sint);
 
1519
#elif defined(ETHR_HAVE_DW_NATMC_SET_RB)
 
1520
    ETHR_DW_NATMC_FUNC__(set_rb)(&var->native, val->sint);
 
1521
#elif defined(ETHR_HAVE_DW_NATMC_SET_WB)
 
1522
    ETHR_DW_NATMC_FUNC__(set_wb)(&var->native, val->sint);
 
1523
#elif defined(ETHR_HAVE_DW_NATMC_SET_ACQB)
 
1524
    ETHR_DW_NATMC_FUNC__(set_acqb)(&var->native, val->sint);
 
1525
#elif defined(ETHR_HAVE_DW_NATMC_SET_RELB)
 
1526
    ETHR_DW_NATMC_FUNC__(set_relb)(&var->native, val->sint);
 
1527
#elif defined(ETHR_HAVE_DW_NATMC_SET_MB)
 
1528
    ETHR_DW_NATMC_FUNC__(set_mb)(&var->native, val->sint);
 
1529
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG)
 
1530
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg), &var->native, aval, aval = val->dw_sint);
 
1531
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RB)
 
1532
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_rb), &var->native, aval, aval = val->dw_sint);
 
1533
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_WB)
 
1534
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_wb), &var->native, aval, aval = val->dw_sint);
 
1535
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_ACQB)
 
1536
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_acqb), &var->native, aval, aval = val->dw_sint);
 
1537
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RELB)
 
1538
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_relb), &var->native, aval, aval = val->dw_sint);
 
1539
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_MB)
 
1540
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_mb), &var->native, aval, aval = val->dw_sint);
 
1541
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG)
 
1542
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1543
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RB)
 
1544
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_rb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1545
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_WB)
 
1546
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_wb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1547
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_ACQB)
 
1548
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_acqb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1549
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RELB)
 
1550
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_relb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1551
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_MB)
 
1552
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_mb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1553
#else
 
1554
#error "Missing implementation of ethr_dw_atomic_set()!"
 
1555
#endif
 
1556
 
 
1557
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1558
    } else { ETHR_DW_ATOMIC_FUNC__(set)(var, val); }
 
1559
#endif
 
1560
 
 
1561
}
 
1562
 
 
1563
static ETHR_INLINE void ETHR_DW_ATMC_FUNC__(set_rb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val)
 
1564
{
 
1565
 
 
1566
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1567
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
1568
#endif
 
1569
 
 
1570
#if defined(ETHR_HAVE_SU_DW_NATMC_SET_RB)
 
1571
    ETHR_SU_DW_NATMC_FUNC__(set_rb)(&var->native, val->dw_sint);
 
1572
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET)
 
1573
    ETHR_SU_DW_NATMC_FUNC__(set)(&var->native, val->dw_sint);
 
1574
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1575
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_MB)
 
1576
    ETHR_SU_DW_NATMC_FUNC__(set_mb)(&var->native, val->dw_sint);
 
1577
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_WB)
 
1578
    ETHR_SU_DW_NATMC_FUNC__(set_wb)(&var->native, val->dw_sint);
 
1579
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1580
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_ACQB)
 
1581
    ETHR_SU_DW_NATMC_FUNC__(set_acqb)(&var->native, val->dw_sint);
 
1582
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1583
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_RELB)
 
1584
    ETHR_SU_DW_NATMC_FUNC__(set_relb)(&var->native, val->dw_sint);
 
1585
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1586
#elif defined(ETHR_HAVE_DW_NATMC_SET_RB)
 
1587
    ETHR_DW_NATMC_FUNC__(set_rb)(&var->native, val->sint);
 
1588
#elif defined(ETHR_HAVE_DW_NATMC_SET)
 
1589
    ETHR_DW_NATMC_FUNC__(set)(&var->native, val->sint);
 
1590
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1591
#elif defined(ETHR_HAVE_DW_NATMC_SET_MB)
 
1592
    ETHR_DW_NATMC_FUNC__(set_mb)(&var->native, val->sint);
 
1593
#elif defined(ETHR_HAVE_DW_NATMC_SET_WB)
 
1594
    ETHR_DW_NATMC_FUNC__(set_wb)(&var->native, val->sint);
 
1595
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1596
#elif defined(ETHR_HAVE_DW_NATMC_SET_ACQB)
 
1597
    ETHR_DW_NATMC_FUNC__(set_acqb)(&var->native, val->sint);
 
1598
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1599
#elif defined(ETHR_HAVE_DW_NATMC_SET_RELB)
 
1600
    ETHR_DW_NATMC_FUNC__(set_relb)(&var->native, val->sint);
 
1601
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1602
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RB)
 
1603
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_rb), &var->native, aval, aval = val->dw_sint);
 
1604
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG)
 
1605
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg), &var->native, aval, aval = val->dw_sint);
 
1606
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1607
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_MB)
 
1608
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_mb), &var->native, aval, aval = val->dw_sint);
 
1609
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_WB)
 
1610
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_wb), &var->native, aval, aval = val->dw_sint);
 
1611
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1612
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_ACQB)
 
1613
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_acqb), &var->native, aval, aval = val->dw_sint);
 
1614
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1615
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RELB)
 
1616
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_relb), &var->native, aval, aval = val->dw_sint);
 
1617
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1618
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RB)
 
1619
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_rb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1620
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG)
 
1621
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1622
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1623
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_MB)
 
1624
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_mb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1625
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_WB)
 
1626
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_wb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1627
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1628
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_ACQB)
 
1629
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_acqb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1630
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1631
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RELB)
 
1632
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_relb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1633
    ETHR_MEMBAR(ETHR_LoadLoad);
 
1634
#else
 
1635
#error "Missing implementation of ethr_dw_atomic_set_rb()!"
 
1636
#endif
 
1637
 
 
1638
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1639
    } else { ETHR_DW_ATOMIC_FUNC__(set_rb)(var, val); }
 
1640
#endif
 
1641
 
 
1642
}
 
1643
 
 
1644
static ETHR_INLINE void ETHR_DW_ATMC_FUNC__(set_wb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val)
 
1645
{
 
1646
 
 
1647
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1648
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
1649
#endif
 
1650
 
 
1651
#if defined(ETHR_HAVE_SU_DW_NATMC_SET_WB)
 
1652
    ETHR_SU_DW_NATMC_FUNC__(set_wb)(&var->native, val->dw_sint);
 
1653
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET)
 
1654
    ETHR_MEMBAR(ETHR_StoreStore);
 
1655
    ETHR_SU_DW_NATMC_FUNC__(set)(&var->native, val->dw_sint);
 
1656
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_MB)
 
1657
    ETHR_SU_DW_NATMC_FUNC__(set_mb)(&var->native, val->dw_sint);
 
1658
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_RB)
 
1659
    ETHR_MEMBAR(ETHR_StoreStore);
 
1660
    ETHR_SU_DW_NATMC_FUNC__(set_rb)(&var->native, val->dw_sint);
 
1661
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_ACQB)
 
1662
    ETHR_MEMBAR(ETHR_StoreStore);
 
1663
    ETHR_SU_DW_NATMC_FUNC__(set_acqb)(&var->native, val->dw_sint);
 
1664
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_RELB)
 
1665
    ETHR_MEMBAR(ETHR_StoreStore);
 
1666
    ETHR_SU_DW_NATMC_FUNC__(set_relb)(&var->native, val->dw_sint);
 
1667
#elif defined(ETHR_HAVE_DW_NATMC_SET_WB)
 
1668
    ETHR_DW_NATMC_FUNC__(set_wb)(&var->native, val->sint);
 
1669
#elif defined(ETHR_HAVE_DW_NATMC_SET)
 
1670
    ETHR_MEMBAR(ETHR_StoreStore);
 
1671
    ETHR_DW_NATMC_FUNC__(set)(&var->native, val->sint);
 
1672
#elif defined(ETHR_HAVE_DW_NATMC_SET_MB)
 
1673
    ETHR_DW_NATMC_FUNC__(set_mb)(&var->native, val->sint);
 
1674
#elif defined(ETHR_HAVE_DW_NATMC_SET_RB)
 
1675
    ETHR_MEMBAR(ETHR_StoreStore);
 
1676
    ETHR_DW_NATMC_FUNC__(set_rb)(&var->native, val->sint);
 
1677
#elif defined(ETHR_HAVE_DW_NATMC_SET_ACQB)
 
1678
    ETHR_MEMBAR(ETHR_StoreStore);
 
1679
    ETHR_DW_NATMC_FUNC__(set_acqb)(&var->native, val->sint);
 
1680
#elif defined(ETHR_HAVE_DW_NATMC_SET_RELB)
 
1681
    ETHR_MEMBAR(ETHR_StoreStore);
 
1682
    ETHR_DW_NATMC_FUNC__(set_relb)(&var->native, val->sint);
 
1683
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_WB)
 
1684
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_wb), &var->native, aval, aval = val->dw_sint);
 
1685
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG)
 
1686
    ETHR_MEMBAR(ETHR_StoreStore);
 
1687
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg), &var->native, aval, aval = val->dw_sint);
 
1688
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_MB)
 
1689
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_mb), &var->native, aval, aval = val->dw_sint);
 
1690
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RB)
 
1691
    ETHR_MEMBAR(ETHR_StoreStore);
 
1692
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_rb), &var->native, aval, aval = val->dw_sint);
 
1693
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_ACQB)
 
1694
    ETHR_MEMBAR(ETHR_StoreStore);
 
1695
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_acqb), &var->native, aval, aval = val->dw_sint);
 
1696
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RELB)
 
1697
    ETHR_MEMBAR(ETHR_StoreStore);
 
1698
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_relb), &var->native, aval, aval = val->dw_sint);
 
1699
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_WB)
 
1700
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_wb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1701
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG)
 
1702
    ETHR_MEMBAR(ETHR_StoreStore);
 
1703
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1704
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_MB)
 
1705
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_mb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1706
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RB)
 
1707
    ETHR_MEMBAR(ETHR_StoreStore);
 
1708
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_rb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1709
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_ACQB)
 
1710
    ETHR_MEMBAR(ETHR_StoreStore);
 
1711
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_acqb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1712
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RELB)
 
1713
    ETHR_MEMBAR(ETHR_StoreStore);
 
1714
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_relb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1715
#else
 
1716
#error "Missing implementation of ethr_dw_atomic_set_wb()!"
 
1717
#endif
 
1718
 
 
1719
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1720
    } else { ETHR_DW_ATOMIC_FUNC__(set_wb)(var, val); }
 
1721
#endif
 
1722
 
 
1723
}
 
1724
 
 
1725
static ETHR_INLINE void ETHR_DW_ATMC_FUNC__(set_acqb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val)
 
1726
{
 
1727
 
 
1728
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1729
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
1730
#endif
 
1731
 
 
1732
#if defined(ETHR_HAVE_SU_DW_NATMC_SET_ACQB)
 
1733
    ETHR_SU_DW_NATMC_FUNC__(set_acqb)(&var->native, val->dw_sint);
 
1734
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_RB)
 
1735
    ETHR_SU_DW_NATMC_FUNC__(set_rb)(&var->native, val->dw_sint);
 
1736
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
1737
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET)
 
1738
    ETHR_SU_DW_NATMC_FUNC__(set)(&var->native, val->dw_sint);
 
1739
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
1740
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_MB)
 
1741
    ETHR_SU_DW_NATMC_FUNC__(set_mb)(&var->native, val->dw_sint);
 
1742
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_WB)
 
1743
    ETHR_SU_DW_NATMC_FUNC__(set_wb)(&var->native, val->dw_sint);
 
1744
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
1745
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_RELB)
 
1746
    ETHR_SU_DW_NATMC_FUNC__(set_relb)(&var->native, val->dw_sint);
 
1747
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
1748
#elif defined(ETHR_HAVE_DW_NATMC_SET_ACQB)
 
1749
    ETHR_DW_NATMC_FUNC__(set_acqb)(&var->native, val->sint);
 
1750
#elif defined(ETHR_HAVE_DW_NATMC_SET_RB)
 
1751
    ETHR_DW_NATMC_FUNC__(set_rb)(&var->native, val->sint);
 
1752
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
1753
#elif defined(ETHR_HAVE_DW_NATMC_SET)
 
1754
    ETHR_DW_NATMC_FUNC__(set)(&var->native, val->sint);
 
1755
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
1756
#elif defined(ETHR_HAVE_DW_NATMC_SET_MB)
 
1757
    ETHR_DW_NATMC_FUNC__(set_mb)(&var->native, val->sint);
 
1758
#elif defined(ETHR_HAVE_DW_NATMC_SET_WB)
 
1759
    ETHR_DW_NATMC_FUNC__(set_wb)(&var->native, val->sint);
 
1760
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
1761
#elif defined(ETHR_HAVE_DW_NATMC_SET_RELB)
 
1762
    ETHR_DW_NATMC_FUNC__(set_relb)(&var->native, val->sint);
 
1763
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
1764
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_ACQB)
 
1765
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_acqb), &var->native, aval, aval = val->dw_sint);
 
1766
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RB)
 
1767
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_rb), &var->native, aval, aval = val->dw_sint);
 
1768
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1769
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG)
 
1770
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg), &var->native, aval, aval = val->dw_sint);
 
1771
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1772
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_MB)
 
1773
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_mb), &var->native, aval, aval = val->dw_sint);
 
1774
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_WB)
 
1775
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_wb), &var->native, aval, aval = val->dw_sint);
 
1776
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1777
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RELB)
 
1778
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_relb), &var->native, aval, aval = val->dw_sint);
 
1779
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1780
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_ACQB)
 
1781
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_acqb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1782
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RB)
 
1783
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_rb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1784
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1785
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG)
 
1786
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1787
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1788
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_MB)
 
1789
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_mb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1790
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_WB)
 
1791
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_wb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1792
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1793
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RELB)
 
1794
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_relb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1795
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1796
#else
 
1797
#error "Missing implementation of ethr_dw_atomic_set_acqb()!"
 
1798
#endif
 
1799
 
 
1800
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1801
    } else { ETHR_DW_ATOMIC_FUNC__(set_acqb)(var, val); }
 
1802
#endif
 
1803
 
 
1804
}
 
1805
 
 
1806
static ETHR_INLINE void ETHR_DW_ATMC_FUNC__(set_relb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val)
 
1807
{
 
1808
 
 
1809
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1810
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
1811
#endif
 
1812
 
 
1813
#if defined(ETHR_HAVE_SU_DW_NATMC_SET_RELB)
 
1814
    ETHR_SU_DW_NATMC_FUNC__(set_relb)(&var->native, val->dw_sint);
 
1815
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_WB)
 
1816
    ETHR_MEMBAR(ETHR_LoadStore);
 
1817
    ETHR_SU_DW_NATMC_FUNC__(set_wb)(&var->native, val->dw_sint);
 
1818
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET)
 
1819
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
1820
    ETHR_SU_DW_NATMC_FUNC__(set)(&var->native, val->dw_sint);
 
1821
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_MB)
 
1822
    ETHR_SU_DW_NATMC_FUNC__(set_mb)(&var->native, val->dw_sint);
 
1823
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_RB)
 
1824
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
1825
    ETHR_SU_DW_NATMC_FUNC__(set_rb)(&var->native, val->dw_sint);
 
1826
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_ACQB)
 
1827
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
1828
    ETHR_SU_DW_NATMC_FUNC__(set_acqb)(&var->native, val->dw_sint);
 
1829
#elif defined(ETHR_HAVE_DW_NATMC_SET_RELB)
 
1830
    ETHR_DW_NATMC_FUNC__(set_relb)(&var->native, val->sint);
 
1831
#elif defined(ETHR_HAVE_DW_NATMC_SET_WB)
 
1832
    ETHR_MEMBAR(ETHR_LoadStore);
 
1833
    ETHR_DW_NATMC_FUNC__(set_wb)(&var->native, val->sint);
 
1834
#elif defined(ETHR_HAVE_DW_NATMC_SET)
 
1835
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
1836
    ETHR_DW_NATMC_FUNC__(set)(&var->native, val->sint);
 
1837
#elif defined(ETHR_HAVE_DW_NATMC_SET_MB)
 
1838
    ETHR_DW_NATMC_FUNC__(set_mb)(&var->native, val->sint);
 
1839
#elif defined(ETHR_HAVE_DW_NATMC_SET_RB)
 
1840
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
1841
    ETHR_DW_NATMC_FUNC__(set_rb)(&var->native, val->sint);
 
1842
#elif defined(ETHR_HAVE_DW_NATMC_SET_ACQB)
 
1843
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
1844
    ETHR_DW_NATMC_FUNC__(set_acqb)(&var->native, val->sint);
 
1845
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RELB)
 
1846
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_relb), &var->native, aval, aval = val->dw_sint);
 
1847
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_WB)
 
1848
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1849
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_wb), &var->native, aval, aval = val->dw_sint);
 
1850
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG)
 
1851
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1852
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg), &var->native, aval, aval = val->dw_sint);
 
1853
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_MB)
 
1854
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_mb), &var->native, aval, aval = val->dw_sint);
 
1855
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RB)
 
1856
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1857
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_rb), &var->native, aval, aval = val->dw_sint);
 
1858
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_ACQB)
 
1859
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1860
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_acqb), &var->native, aval, aval = val->dw_sint);
 
1861
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RELB)
 
1862
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_relb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1863
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_WB)
 
1864
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1865
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_wb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1866
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG)
 
1867
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1868
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1869
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_MB)
 
1870
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_mb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1871
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RB)
 
1872
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1873
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_rb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1874
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_ACQB)
 
1875
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1876
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_acqb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1877
#else
 
1878
#error "Missing implementation of ethr_dw_atomic_set_relb()!"
 
1879
#endif
 
1880
 
 
1881
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1882
    } else { ETHR_DW_ATOMIC_FUNC__(set_relb)(var, val); }
 
1883
#endif
 
1884
 
 
1885
}
 
1886
 
 
1887
static ETHR_INLINE void ETHR_DW_ATMC_FUNC__(set_mb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val)
 
1888
{
 
1889
 
 
1890
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1891
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
1892
#endif
 
1893
 
 
1894
#if defined(ETHR_HAVE_SU_DW_NATMC_SET_MB)
 
1895
    ETHR_SU_DW_NATMC_FUNC__(set_mb)(&var->native, val->dw_sint);
 
1896
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_RELB)
 
1897
    ETHR_SU_DW_NATMC_FUNC__(set_relb)(&var->native, val->dw_sint);
 
1898
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
1899
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_ACQB)
 
1900
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
1901
    ETHR_SU_DW_NATMC_FUNC__(set_acqb)(&var->native, val->dw_sint);
 
1902
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_WB)
 
1903
    ETHR_MEMBAR(ETHR_LoadStore);
 
1904
    ETHR_SU_DW_NATMC_FUNC__(set_wb)(&var->native, val->dw_sint);
 
1905
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
1906
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET_RB)
 
1907
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
1908
    ETHR_SU_DW_NATMC_FUNC__(set_rb)(&var->native, val->dw_sint);
 
1909
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
1910
#elif defined(ETHR_HAVE_SU_DW_NATMC_SET)
 
1911
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
1912
    ETHR_SU_DW_NATMC_FUNC__(set)(&var->native, val->dw_sint);
 
1913
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
1914
#elif defined(ETHR_HAVE_DW_NATMC_SET_MB)
 
1915
    ETHR_DW_NATMC_FUNC__(set_mb)(&var->native, val->sint);
 
1916
#elif defined(ETHR_HAVE_DW_NATMC_SET_RELB)
 
1917
    ETHR_DW_NATMC_FUNC__(set_relb)(&var->native, val->sint);
 
1918
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
1919
#elif defined(ETHR_HAVE_DW_NATMC_SET_ACQB)
 
1920
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
1921
    ETHR_DW_NATMC_FUNC__(set_acqb)(&var->native, val->sint);
 
1922
#elif defined(ETHR_HAVE_DW_NATMC_SET_WB)
 
1923
    ETHR_MEMBAR(ETHR_LoadStore);
 
1924
    ETHR_DW_NATMC_FUNC__(set_wb)(&var->native, val->sint);
 
1925
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
1926
#elif defined(ETHR_HAVE_DW_NATMC_SET_RB)
 
1927
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
1928
    ETHR_DW_NATMC_FUNC__(set_rb)(&var->native, val->sint);
 
1929
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
1930
#elif defined(ETHR_HAVE_DW_NATMC_SET)
 
1931
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
1932
    ETHR_DW_NATMC_FUNC__(set)(&var->native, val->sint);
 
1933
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
1934
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_MB)
 
1935
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_mb), &var->native, aval, aval = val->dw_sint);
 
1936
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RELB)
 
1937
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_relb), &var->native, aval, aval = val->dw_sint);
 
1938
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1939
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_ACQB)
 
1940
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1941
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_acqb), &var->native, aval, aval = val->dw_sint);
 
1942
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_WB)
 
1943
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1944
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_wb), &var->native, aval, aval = val->dw_sint);
 
1945
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1946
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG_RB)
 
1947
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1948
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg_rb), &var->native, aval, aval = val->dw_sint);
 
1949
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1950
#elif defined(ETHR_HAVE_SU_DW_NATMC_CMPXCHG)
 
1951
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1952
    ETHR_SU_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_SU_DW_NATMC_FUNC__(cmpxchg), &var->native, aval, aval = val->dw_sint);
 
1953
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1954
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_MB)
 
1955
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_mb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1956
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RELB)
 
1957
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_relb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1958
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1959
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_ACQB)
 
1960
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1961
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_acqb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1962
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_WB)
 
1963
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1964
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_wb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1965
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1966
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG_RB)
 
1967
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1968
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg_rb), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1969
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1970
#elif defined(ETHR_HAVE_DW_NATMC_CMPXCHG)
 
1971
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
1972
    ETHR_DW_NATMC_CMPXCHG_FALLBACK__(ETHR_DW_NATMC_FUNC__(cmpxchg), &var->native, aval, aval.sint[0] = val->sint[0]; aval.sint[1] = val->sint[1]);
 
1973
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
1974
#else
 
1975
#error "Missing implementation of ethr_dw_atomic_set_mb()!"
 
1976
#endif
 
1977
 
 
1978
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1979
    } else { ETHR_DW_ATOMIC_FUNC__(set_mb)(var, val); }
 
1980
#endif
 
1981
 
 
1982
}
 
1983
 
 
1984
 
 
1985
/* --- read() --- */
 
1986
 
 
1987
 
 
1988
static ETHR_INLINE void ETHR_DW_ATMC_FUNC__(read)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val)
 
1989
{
 
1990
 
 
1991
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
1992
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
1993
#endif
 
1994
 
 
1995
#if defined(ETHR_HAVE_SU_DW_NATMC_READ)
 
1996
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read)(&var->native);
 
1997
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_RB)
 
1998
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_rb)(&var->native);
 
1999
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_WB)
 
2000
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_wb)(&var->native);
 
2001
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_ACQB)
 
2002
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_acqb)(&var->native);
 
2003
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_RELB)
 
2004
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_relb)(&var->native);
 
2005
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_MB)
 
2006
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_mb)(&var->native);
 
2007
#elif defined(ETHR_HAVE_DW_NATMC_READ)
 
2008
    ETHR_DW_NATMC_FUNC__(read)(&var->native, val->sint);
 
2009
#elif defined(ETHR_HAVE_DW_NATMC_READ_RB)
 
2010
    ETHR_DW_NATMC_FUNC__(read_rb)(&var->native, val->sint);
 
2011
#elif defined(ETHR_HAVE_DW_NATMC_READ_WB)
 
2012
    ETHR_DW_NATMC_FUNC__(read_wb)(&var->native, val->sint);
 
2013
#elif defined(ETHR_HAVE_DW_NATMC_READ_ACQB)
 
2014
    ETHR_DW_NATMC_FUNC__(read_acqb)(&var->native, val->sint);
 
2015
#elif defined(ETHR_HAVE_DW_NATMC_READ_RELB)
 
2016
    ETHR_DW_NATMC_FUNC__(read_relb)(&var->native, val->sint);
 
2017
#elif defined(ETHR_HAVE_DW_NATMC_READ_MB)
 
2018
    ETHR_DW_NATMC_FUNC__(read_mb)(&var->native, val->sint);
 
2019
#else
 
2020
    ethr_dw_sint_t tmp;
 
2021
    tmp.sint[0] = ETHR_UNUSUAL_SINT_VAL__;
 
2022
    tmp.sint[1] = ETHR_UNUSUAL_SINT_VAL__;
 
2023
    val->sint[0] = ETHR_UNUSUAL_SINT_VAL__;
 
2024
    val->sint[1] = ETHR_UNUSUAL_SINT_VAL__;
 
2025
    (void) ETHR_DW_ATMC_FUNC__(cmpxchg)(var, &tmp, val);
 
2026
#endif
 
2027
 
 
2028
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2029
    } else { ETHR_DW_ATOMIC_FUNC__(read)(var, val); }
 
2030
#endif
 
2031
 
 
2032
}
 
2033
 
 
2034
static ETHR_INLINE void ETHR_DW_ATMC_FUNC__(read_rb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val)
 
2035
{
 
2036
 
 
2037
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2038
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
2039
#endif
 
2040
 
 
2041
#if defined(ETHR_HAVE_SU_DW_NATMC_READ_RB)
 
2042
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_rb)(&var->native);
 
2043
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ)
 
2044
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read)(&var->native);
 
2045
    ETHR_MEMBAR(ETHR_LoadLoad);
 
2046
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_MB)
 
2047
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_mb)(&var->native);
 
2048
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_WB)
 
2049
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_wb)(&var->native);
 
2050
    ETHR_MEMBAR(ETHR_LoadLoad);
 
2051
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_ACQB)
 
2052
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_acqb)(&var->native);
 
2053
    ETHR_MEMBAR(ETHR_LoadLoad);
 
2054
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_RELB)
 
2055
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_relb)(&var->native);
 
2056
    ETHR_MEMBAR(ETHR_LoadLoad);
 
2057
#elif defined(ETHR_HAVE_DW_NATMC_READ_RB)
 
2058
    ETHR_DW_NATMC_FUNC__(read_rb)(&var->native, val->sint);
 
2059
#elif defined(ETHR_HAVE_DW_NATMC_READ)
 
2060
    ETHR_DW_NATMC_FUNC__(read)(&var->native, val->sint);
 
2061
    ETHR_MEMBAR(ETHR_LoadLoad);
 
2062
#elif defined(ETHR_HAVE_DW_NATMC_READ_MB)
 
2063
    ETHR_DW_NATMC_FUNC__(read_mb)(&var->native, val->sint);
 
2064
#elif defined(ETHR_HAVE_DW_NATMC_READ_WB)
 
2065
    ETHR_DW_NATMC_FUNC__(read_wb)(&var->native, val->sint);
 
2066
    ETHR_MEMBAR(ETHR_LoadLoad);
 
2067
#elif defined(ETHR_HAVE_DW_NATMC_READ_ACQB)
 
2068
    ETHR_DW_NATMC_FUNC__(read_acqb)(&var->native, val->sint);
 
2069
    ETHR_MEMBAR(ETHR_LoadLoad);
 
2070
#elif defined(ETHR_HAVE_DW_NATMC_READ_RELB)
 
2071
    ETHR_DW_NATMC_FUNC__(read_relb)(&var->native, val->sint);
 
2072
    ETHR_MEMBAR(ETHR_LoadLoad);
 
2073
#else
 
2074
    ethr_dw_sint_t tmp;
 
2075
    tmp.sint[0] = ETHR_UNUSUAL_SINT_VAL__;
 
2076
    tmp.sint[1] = ETHR_UNUSUAL_SINT_VAL__;
 
2077
    val->sint[0] = ETHR_UNUSUAL_SINT_VAL__;
 
2078
    val->sint[1] = ETHR_UNUSUAL_SINT_VAL__;
 
2079
    (void) ETHR_DW_ATMC_FUNC__(cmpxchg_rb)(var, &tmp, val);
 
2080
#endif
 
2081
 
 
2082
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2083
    } else { ETHR_DW_ATOMIC_FUNC__(read_rb)(var, val); }
 
2084
#endif
 
2085
 
 
2086
}
 
2087
 
 
2088
static ETHR_INLINE void ETHR_DW_ATMC_FUNC__(read_wb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val)
 
2089
{
 
2090
 
 
2091
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2092
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
2093
#endif
 
2094
 
 
2095
#if defined(ETHR_HAVE_SU_DW_NATMC_READ_WB)
 
2096
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_wb)(&var->native);
 
2097
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ)
 
2098
    ETHR_MEMBAR(ETHR_StoreStore);
 
2099
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read)(&var->native);
 
2100
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_MB)
 
2101
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_mb)(&var->native);
 
2102
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_RB)
 
2103
    ETHR_MEMBAR(ETHR_StoreStore);
 
2104
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_rb)(&var->native);
 
2105
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_ACQB)
 
2106
    ETHR_MEMBAR(ETHR_StoreStore);
 
2107
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_acqb)(&var->native);
 
2108
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_RELB)
 
2109
    ETHR_MEMBAR(ETHR_StoreStore);
 
2110
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_relb)(&var->native);
 
2111
#elif defined(ETHR_HAVE_DW_NATMC_READ_WB)
 
2112
    ETHR_DW_NATMC_FUNC__(read_wb)(&var->native, val->sint);
 
2113
#elif defined(ETHR_HAVE_DW_NATMC_READ)
 
2114
    ETHR_MEMBAR(ETHR_StoreStore);
 
2115
    ETHR_DW_NATMC_FUNC__(read)(&var->native, val->sint);
 
2116
#elif defined(ETHR_HAVE_DW_NATMC_READ_MB)
 
2117
    ETHR_DW_NATMC_FUNC__(read_mb)(&var->native, val->sint);
 
2118
#elif defined(ETHR_HAVE_DW_NATMC_READ_RB)
 
2119
    ETHR_MEMBAR(ETHR_StoreStore);
 
2120
    ETHR_DW_NATMC_FUNC__(read_rb)(&var->native, val->sint);
 
2121
#elif defined(ETHR_HAVE_DW_NATMC_READ_ACQB)
 
2122
    ETHR_MEMBAR(ETHR_StoreStore);
 
2123
    ETHR_DW_NATMC_FUNC__(read_acqb)(&var->native, val->sint);
 
2124
#elif defined(ETHR_HAVE_DW_NATMC_READ_RELB)
 
2125
    ETHR_MEMBAR(ETHR_StoreStore);
 
2126
    ETHR_DW_NATMC_FUNC__(read_relb)(&var->native, val->sint);
 
2127
#else
 
2128
    ethr_dw_sint_t tmp;
 
2129
    tmp.sint[0] = ETHR_UNUSUAL_SINT_VAL__;
 
2130
    tmp.sint[1] = ETHR_UNUSUAL_SINT_VAL__;
 
2131
    val->sint[0] = ETHR_UNUSUAL_SINT_VAL__;
 
2132
    val->sint[1] = ETHR_UNUSUAL_SINT_VAL__;
 
2133
    (void) ETHR_DW_ATMC_FUNC__(cmpxchg_wb)(var, &tmp, val);
 
2134
#endif
 
2135
 
 
2136
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2137
    } else { ETHR_DW_ATOMIC_FUNC__(read_wb)(var, val); }
 
2138
#endif
 
2139
 
 
2140
}
 
2141
 
 
2142
static ETHR_INLINE void ETHR_DW_ATMC_FUNC__(read_acqb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val)
 
2143
{
 
2144
 
 
2145
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2146
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
2147
#endif
 
2148
 
 
2149
#if defined(ETHR_HAVE_SU_DW_NATMC_READ_ACQB)
 
2150
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_acqb)(&var->native);
 
2151
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_RB)
 
2152
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_rb)(&var->native);
 
2153
    ETHR_MEMBAR(ETHR_LoadStore);
 
2154
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ)
 
2155
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read)(&var->native);
 
2156
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
2157
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_MB)
 
2158
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_mb)(&var->native);
 
2159
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_WB)
 
2160
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_wb)(&var->native);
 
2161
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
2162
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_RELB)
 
2163
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_relb)(&var->native);
 
2164
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
2165
#elif defined(ETHR_HAVE_DW_NATMC_READ_ACQB)
 
2166
    ETHR_DW_NATMC_FUNC__(read_acqb)(&var->native, val->sint);
 
2167
#elif defined(ETHR_HAVE_DW_NATMC_READ_RB)
 
2168
    ETHR_DW_NATMC_FUNC__(read_rb)(&var->native, val->sint);
 
2169
    ETHR_MEMBAR(ETHR_LoadStore);
 
2170
#elif defined(ETHR_HAVE_DW_NATMC_READ)
 
2171
    ETHR_DW_NATMC_FUNC__(read)(&var->native, val->sint);
 
2172
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
2173
#elif defined(ETHR_HAVE_DW_NATMC_READ_MB)
 
2174
    ETHR_DW_NATMC_FUNC__(read_mb)(&var->native, val->sint);
 
2175
#elif defined(ETHR_HAVE_DW_NATMC_READ_WB)
 
2176
    ETHR_DW_NATMC_FUNC__(read_wb)(&var->native, val->sint);
 
2177
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
2178
#elif defined(ETHR_HAVE_DW_NATMC_READ_RELB)
 
2179
    ETHR_DW_NATMC_FUNC__(read_relb)(&var->native, val->sint);
 
2180
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
2181
#else
 
2182
    ethr_dw_sint_t tmp;
 
2183
    tmp.sint[0] = ETHR_UNUSUAL_SINT_VAL__;
 
2184
    tmp.sint[1] = ETHR_UNUSUAL_SINT_VAL__;
 
2185
    val->sint[0] = ETHR_UNUSUAL_SINT_VAL__;
 
2186
    val->sint[1] = ETHR_UNUSUAL_SINT_VAL__;
 
2187
    (void) ETHR_DW_ATMC_FUNC__(cmpxchg_acqb)(var, &tmp, val);
 
2188
#endif
 
2189
 
 
2190
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2191
    } else { ETHR_DW_ATOMIC_FUNC__(read_acqb)(var, val); }
 
2192
#endif
 
2193
 
 
2194
}
 
2195
 
 
2196
static ETHR_INLINE void ETHR_DW_ATMC_FUNC__(read_relb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val)
 
2197
{
 
2198
 
 
2199
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2200
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
2201
#endif
 
2202
 
 
2203
#if defined(ETHR_HAVE_SU_DW_NATMC_READ_RELB)
 
2204
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_relb)(&var->native);
 
2205
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_WB)
 
2206
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
2207
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_wb)(&var->native);
 
2208
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ)
 
2209
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
2210
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read)(&var->native);
 
2211
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_MB)
 
2212
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_mb)(&var->native);
 
2213
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_RB)
 
2214
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
2215
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_rb)(&var->native);
 
2216
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_ACQB)
 
2217
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
2218
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_acqb)(&var->native);
 
2219
#elif defined(ETHR_HAVE_DW_NATMC_READ_RELB)
 
2220
    ETHR_DW_NATMC_FUNC__(read_relb)(&var->native, val->sint);
 
2221
#elif defined(ETHR_HAVE_DW_NATMC_READ_WB)
 
2222
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
2223
    ETHR_DW_NATMC_FUNC__(read_wb)(&var->native, val->sint);
 
2224
#elif defined(ETHR_HAVE_DW_NATMC_READ)
 
2225
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
2226
    ETHR_DW_NATMC_FUNC__(read)(&var->native, val->sint);
 
2227
#elif defined(ETHR_HAVE_DW_NATMC_READ_MB)
 
2228
    ETHR_DW_NATMC_FUNC__(read_mb)(&var->native, val->sint);
 
2229
#elif defined(ETHR_HAVE_DW_NATMC_READ_RB)
 
2230
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
2231
    ETHR_DW_NATMC_FUNC__(read_rb)(&var->native, val->sint);
 
2232
#elif defined(ETHR_HAVE_DW_NATMC_READ_ACQB)
 
2233
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
2234
    ETHR_DW_NATMC_FUNC__(read_acqb)(&var->native, val->sint);
 
2235
#else
 
2236
    ethr_dw_sint_t tmp;
 
2237
    tmp.sint[0] = ETHR_UNUSUAL_SINT_VAL__;
 
2238
    tmp.sint[1] = ETHR_UNUSUAL_SINT_VAL__;
 
2239
    val->sint[0] = ETHR_UNUSUAL_SINT_VAL__;
 
2240
    val->sint[1] = ETHR_UNUSUAL_SINT_VAL__;
 
2241
    (void) ETHR_DW_ATMC_FUNC__(cmpxchg_relb)(var, &tmp, val);
 
2242
#endif
 
2243
 
 
2244
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2245
    } else { ETHR_DW_ATOMIC_FUNC__(read_relb)(var, val); }
 
2246
#endif
 
2247
 
 
2248
}
 
2249
 
 
2250
static ETHR_INLINE void ETHR_DW_ATMC_FUNC__(read_mb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val)
 
2251
{
 
2252
 
 
2253
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2254
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
2255
#endif
 
2256
 
 
2257
#if defined(ETHR_HAVE_SU_DW_NATMC_READ_MB)
 
2258
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_mb)(&var->native);
 
2259
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_RELB)
 
2260
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_relb)(&var->native);
 
2261
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
2262
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_ACQB)
 
2263
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
2264
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_acqb)(&var->native);
 
2265
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_WB)
 
2266
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
2267
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_wb)(&var->native);
 
2268
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
2269
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ_RB)
 
2270
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
2271
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read_rb)(&var->native);
 
2272
    ETHR_MEMBAR(ETHR_LoadStore);
 
2273
#elif defined(ETHR_HAVE_SU_DW_NATMC_READ)
 
2274
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
2275
    val->dw_sint = ETHR_SU_DW_NATMC_FUNC__(read)(&var->native);
 
2276
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
2277
#elif defined(ETHR_HAVE_DW_NATMC_READ_MB)
 
2278
    ETHR_DW_NATMC_FUNC__(read_mb)(&var->native, val->sint);
 
2279
#elif defined(ETHR_HAVE_DW_NATMC_READ_RELB)
 
2280
    ETHR_DW_NATMC_FUNC__(read_relb)(&var->native, val->sint);
 
2281
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
2282
#elif defined(ETHR_HAVE_DW_NATMC_READ_ACQB)
 
2283
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
2284
    ETHR_DW_NATMC_FUNC__(read_acqb)(&var->native, val->sint);
 
2285
#elif defined(ETHR_HAVE_DW_NATMC_READ_WB)
 
2286
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
2287
    ETHR_DW_NATMC_FUNC__(read_wb)(&var->native, val->sint);
 
2288
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
2289
#elif defined(ETHR_HAVE_DW_NATMC_READ_RB)
 
2290
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
2291
    ETHR_DW_NATMC_FUNC__(read_rb)(&var->native, val->sint);
 
2292
    ETHR_MEMBAR(ETHR_LoadStore);
 
2293
#elif defined(ETHR_HAVE_DW_NATMC_READ)
 
2294
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
2295
    ETHR_DW_NATMC_FUNC__(read)(&var->native, val->sint);
 
2296
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
2297
#else
 
2298
    ethr_dw_sint_t tmp;
 
2299
    tmp.sint[0] = ETHR_UNUSUAL_SINT_VAL__;
 
2300
    tmp.sint[1] = ETHR_UNUSUAL_SINT_VAL__;
 
2301
    val->sint[0] = ETHR_UNUSUAL_SINT_VAL__;
 
2302
    val->sint[1] = ETHR_UNUSUAL_SINT_VAL__;
 
2303
    (void) ETHR_DW_ATMC_FUNC__(cmpxchg_mb)(var, &tmp, val);
 
2304
#endif
 
2305
 
 
2306
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2307
    } else { ETHR_DW_ATOMIC_FUNC__(read_mb)(var, val); }
 
2308
#endif
 
2309
 
 
2310
}
 
2311
 
 
2312
 
 
2313
/* --- init() --- */
 
2314
 
 
2315
 
 
2316
static ETHR_INLINE void ETHR_DW_ATMC_FUNC__(init)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val)
 
2317
{
 
2318
 
 
2319
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2320
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
2321
#endif
 
2322
 
 
2323
#if defined(ETHR_HAVE_SU_DW_NATMC_INIT)
 
2324
    ETHR_SU_DW_NATMC_FUNC__(init)(&var->native, val->dw_sint);
 
2325
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_RB)
 
2326
    ETHR_SU_DW_NATMC_FUNC__(init_rb)(&var->native, val->dw_sint);
 
2327
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_WB)
 
2328
    ETHR_SU_DW_NATMC_FUNC__(init_wb)(&var->native, val->dw_sint);
 
2329
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_ACQB)
 
2330
    ETHR_SU_DW_NATMC_FUNC__(init_acqb)(&var->native, val->dw_sint);
 
2331
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_RELB)
 
2332
    ETHR_SU_DW_NATMC_FUNC__(init_relb)(&var->native, val->dw_sint);
 
2333
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_MB)
 
2334
    ETHR_SU_DW_NATMC_FUNC__(init_mb)(&var->native, val->dw_sint);
 
2335
#elif defined(ETHR_HAVE_DW_NATMC_INIT)
 
2336
    ETHR_DW_NATMC_FUNC__(init)(&var->native, val->sint);
 
2337
#elif defined(ETHR_HAVE_DW_NATMC_INIT_RB)
 
2338
    ETHR_DW_NATMC_FUNC__(init_rb)(&var->native, val->sint);
 
2339
#elif defined(ETHR_HAVE_DW_NATMC_INIT_WB)
 
2340
    ETHR_DW_NATMC_FUNC__(init_wb)(&var->native, val->sint);
 
2341
#elif defined(ETHR_HAVE_DW_NATMC_INIT_ACQB)
 
2342
    ETHR_DW_NATMC_FUNC__(init_acqb)(&var->native, val->sint);
 
2343
#elif defined(ETHR_HAVE_DW_NATMC_INIT_RELB)
 
2344
    ETHR_DW_NATMC_FUNC__(init_relb)(&var->native, val->sint);
 
2345
#elif defined(ETHR_HAVE_DW_NATMC_INIT_MB)
 
2346
    ETHR_DW_NATMC_FUNC__(init_mb)(&var->native, val->sint);
 
2347
#else
 
2348
    ETHR_DW_ATMC_FUNC__(set)(var, val);
 
2349
#endif
 
2350
 
 
2351
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2352
    } else { ETHR_DW_ATOMIC_FUNC__(init)(var, val); }
 
2353
#endif
 
2354
 
 
2355
}
 
2356
 
 
2357
static ETHR_INLINE void ETHR_DW_ATMC_FUNC__(init_rb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val)
 
2358
{
 
2359
 
 
2360
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2361
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
2362
#endif
 
2363
 
 
2364
#if defined(ETHR_HAVE_SU_DW_NATMC_INIT_RB)
 
2365
    ETHR_SU_DW_NATMC_FUNC__(init_rb)(&var->native, val->dw_sint);
 
2366
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT)
 
2367
    ETHR_SU_DW_NATMC_FUNC__(init)(&var->native, val->dw_sint);
 
2368
    ETHR_MEMBAR(ETHR_LoadLoad);
 
2369
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_MB)
 
2370
    ETHR_SU_DW_NATMC_FUNC__(init_mb)(&var->native, val->dw_sint);
 
2371
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_WB)
 
2372
    ETHR_SU_DW_NATMC_FUNC__(init_wb)(&var->native, val->dw_sint);
 
2373
    ETHR_MEMBAR(ETHR_LoadLoad);
 
2374
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_ACQB)
 
2375
    ETHR_SU_DW_NATMC_FUNC__(init_acqb)(&var->native, val->dw_sint);
 
2376
    ETHR_MEMBAR(ETHR_LoadLoad);
 
2377
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_RELB)
 
2378
    ETHR_SU_DW_NATMC_FUNC__(init_relb)(&var->native, val->dw_sint);
 
2379
    ETHR_MEMBAR(ETHR_LoadLoad);
 
2380
#elif defined(ETHR_HAVE_DW_NATMC_INIT_RB)
 
2381
    ETHR_DW_NATMC_FUNC__(init_rb)(&var->native, val->sint);
 
2382
#elif defined(ETHR_HAVE_DW_NATMC_INIT)
 
2383
    ETHR_DW_NATMC_FUNC__(init)(&var->native, val->sint);
 
2384
    ETHR_MEMBAR(ETHR_LoadLoad);
 
2385
#elif defined(ETHR_HAVE_DW_NATMC_INIT_MB)
 
2386
    ETHR_DW_NATMC_FUNC__(init_mb)(&var->native, val->sint);
 
2387
#elif defined(ETHR_HAVE_DW_NATMC_INIT_WB)
 
2388
    ETHR_DW_NATMC_FUNC__(init_wb)(&var->native, val->sint);
 
2389
    ETHR_MEMBAR(ETHR_LoadLoad);
 
2390
#elif defined(ETHR_HAVE_DW_NATMC_INIT_ACQB)
 
2391
    ETHR_DW_NATMC_FUNC__(init_acqb)(&var->native, val->sint);
 
2392
    ETHR_MEMBAR(ETHR_LoadLoad);
 
2393
#elif defined(ETHR_HAVE_DW_NATMC_INIT_RELB)
 
2394
    ETHR_DW_NATMC_FUNC__(init_relb)(&var->native, val->sint);
 
2395
    ETHR_MEMBAR(ETHR_LoadLoad);
 
2396
#else
 
2397
    ETHR_DW_ATMC_FUNC__(set_rb)(var, val);
 
2398
#endif
 
2399
 
 
2400
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2401
    } else { ETHR_DW_ATOMIC_FUNC__(init_rb)(var, val); }
 
2402
#endif
 
2403
 
 
2404
}
 
2405
 
 
2406
static ETHR_INLINE void ETHR_DW_ATMC_FUNC__(init_wb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val)
 
2407
{
 
2408
 
 
2409
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2410
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
2411
#endif
 
2412
 
 
2413
#if defined(ETHR_HAVE_SU_DW_NATMC_INIT_WB)
 
2414
    ETHR_SU_DW_NATMC_FUNC__(init_wb)(&var->native, val->dw_sint);
 
2415
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT)
 
2416
    ETHR_MEMBAR(ETHR_StoreStore);
 
2417
    ETHR_SU_DW_NATMC_FUNC__(init)(&var->native, val->dw_sint);
 
2418
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_MB)
 
2419
    ETHR_SU_DW_NATMC_FUNC__(init_mb)(&var->native, val->dw_sint);
 
2420
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_RB)
 
2421
    ETHR_MEMBAR(ETHR_StoreStore);
 
2422
    ETHR_SU_DW_NATMC_FUNC__(init_rb)(&var->native, val->dw_sint);
 
2423
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_ACQB)
 
2424
    ETHR_MEMBAR(ETHR_StoreStore);
 
2425
    ETHR_SU_DW_NATMC_FUNC__(init_acqb)(&var->native, val->dw_sint);
 
2426
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_RELB)
 
2427
    ETHR_MEMBAR(ETHR_StoreStore);
 
2428
    ETHR_SU_DW_NATMC_FUNC__(init_relb)(&var->native, val->dw_sint);
 
2429
#elif defined(ETHR_HAVE_DW_NATMC_INIT_WB)
 
2430
    ETHR_DW_NATMC_FUNC__(init_wb)(&var->native, val->sint);
 
2431
#elif defined(ETHR_HAVE_DW_NATMC_INIT)
 
2432
    ETHR_MEMBAR(ETHR_StoreStore);
 
2433
    ETHR_DW_NATMC_FUNC__(init)(&var->native, val->sint);
 
2434
#elif defined(ETHR_HAVE_DW_NATMC_INIT_MB)
 
2435
    ETHR_DW_NATMC_FUNC__(init_mb)(&var->native, val->sint);
 
2436
#elif defined(ETHR_HAVE_DW_NATMC_INIT_RB)
 
2437
    ETHR_MEMBAR(ETHR_StoreStore);
 
2438
    ETHR_DW_NATMC_FUNC__(init_rb)(&var->native, val->sint);
 
2439
#elif defined(ETHR_HAVE_DW_NATMC_INIT_ACQB)
 
2440
    ETHR_MEMBAR(ETHR_StoreStore);
 
2441
    ETHR_DW_NATMC_FUNC__(init_acqb)(&var->native, val->sint);
 
2442
#elif defined(ETHR_HAVE_DW_NATMC_INIT_RELB)
 
2443
    ETHR_MEMBAR(ETHR_StoreStore);
 
2444
    ETHR_DW_NATMC_FUNC__(init_relb)(&var->native, val->sint);
 
2445
#else
 
2446
    ETHR_DW_ATMC_FUNC__(set_wb)(var, val);
 
2447
#endif
 
2448
 
 
2449
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2450
    } else { ETHR_DW_ATOMIC_FUNC__(init_wb)(var, val); }
 
2451
#endif
 
2452
 
 
2453
}
 
2454
 
 
2455
static ETHR_INLINE void ETHR_DW_ATMC_FUNC__(init_acqb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val)
 
2456
{
 
2457
 
 
2458
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2459
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
2460
#endif
 
2461
 
 
2462
#if defined(ETHR_HAVE_SU_DW_NATMC_INIT_ACQB)
 
2463
    ETHR_SU_DW_NATMC_FUNC__(init_acqb)(&var->native, val->dw_sint);
 
2464
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_RB)
 
2465
    ETHR_SU_DW_NATMC_FUNC__(init_rb)(&var->native, val->dw_sint);
 
2466
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2467
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT)
 
2468
    ETHR_SU_DW_NATMC_FUNC__(init)(&var->native, val->dw_sint);
 
2469
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2470
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_MB)
 
2471
    ETHR_SU_DW_NATMC_FUNC__(init_mb)(&var->native, val->dw_sint);
 
2472
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_WB)
 
2473
    ETHR_SU_DW_NATMC_FUNC__(init_wb)(&var->native, val->dw_sint);
 
2474
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2475
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_RELB)
 
2476
    ETHR_SU_DW_NATMC_FUNC__(init_relb)(&var->native, val->dw_sint);
 
2477
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2478
#elif defined(ETHR_HAVE_DW_NATMC_INIT_ACQB)
 
2479
    ETHR_DW_NATMC_FUNC__(init_acqb)(&var->native, val->sint);
 
2480
#elif defined(ETHR_HAVE_DW_NATMC_INIT_RB)
 
2481
    ETHR_DW_NATMC_FUNC__(init_rb)(&var->native, val->sint);
 
2482
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2483
#elif defined(ETHR_HAVE_DW_NATMC_INIT)
 
2484
    ETHR_DW_NATMC_FUNC__(init)(&var->native, val->sint);
 
2485
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2486
#elif defined(ETHR_HAVE_DW_NATMC_INIT_MB)
 
2487
    ETHR_DW_NATMC_FUNC__(init_mb)(&var->native, val->sint);
 
2488
#elif defined(ETHR_HAVE_DW_NATMC_INIT_WB)
 
2489
    ETHR_DW_NATMC_FUNC__(init_wb)(&var->native, val->sint);
 
2490
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2491
#elif defined(ETHR_HAVE_DW_NATMC_INIT_RELB)
 
2492
    ETHR_DW_NATMC_FUNC__(init_relb)(&var->native, val->sint);
 
2493
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2494
#else
 
2495
    ETHR_DW_ATMC_FUNC__(set_acqb)(var, val);
 
2496
#endif
 
2497
 
 
2498
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2499
    } else { ETHR_DW_ATOMIC_FUNC__(init_acqb)(var, val); }
 
2500
#endif
 
2501
 
 
2502
}
 
2503
 
 
2504
static ETHR_INLINE void ETHR_DW_ATMC_FUNC__(init_relb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val)
 
2505
{
 
2506
 
 
2507
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2508
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
2509
#endif
 
2510
 
 
2511
#if defined(ETHR_HAVE_SU_DW_NATMC_INIT_RELB)
 
2512
    ETHR_SU_DW_NATMC_FUNC__(init_relb)(&var->native, val->dw_sint);
 
2513
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_WB)
 
2514
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad);
 
2515
    ETHR_SU_DW_NATMC_FUNC__(init_wb)(&var->native, val->dw_sint);
 
2516
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT)
 
2517
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2518
    ETHR_SU_DW_NATMC_FUNC__(init)(&var->native, val->dw_sint);
 
2519
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_MB)
 
2520
    ETHR_SU_DW_NATMC_FUNC__(init_mb)(&var->native, val->dw_sint);
 
2521
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_RB)
 
2522
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2523
    ETHR_SU_DW_NATMC_FUNC__(init_rb)(&var->native, val->dw_sint);
 
2524
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_ACQB)
 
2525
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2526
    ETHR_SU_DW_NATMC_FUNC__(init_acqb)(&var->native, val->dw_sint);
 
2527
#elif defined(ETHR_HAVE_DW_NATMC_INIT_RELB)
 
2528
    ETHR_DW_NATMC_FUNC__(init_relb)(&var->native, val->sint);
 
2529
#elif defined(ETHR_HAVE_DW_NATMC_INIT_WB)
 
2530
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad);
 
2531
    ETHR_DW_NATMC_FUNC__(init_wb)(&var->native, val->sint);
 
2532
#elif defined(ETHR_HAVE_DW_NATMC_INIT)
 
2533
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2534
    ETHR_DW_NATMC_FUNC__(init)(&var->native, val->sint);
 
2535
#elif defined(ETHR_HAVE_DW_NATMC_INIT_MB)
 
2536
    ETHR_DW_NATMC_FUNC__(init_mb)(&var->native, val->sint);
 
2537
#elif defined(ETHR_HAVE_DW_NATMC_INIT_RB)
 
2538
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2539
    ETHR_DW_NATMC_FUNC__(init_rb)(&var->native, val->sint);
 
2540
#elif defined(ETHR_HAVE_DW_NATMC_INIT_ACQB)
 
2541
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2542
    ETHR_DW_NATMC_FUNC__(init_acqb)(&var->native, val->sint);
 
2543
#else
 
2544
    ETHR_DW_ATMC_FUNC__(set_relb)(var, val);
 
2545
#endif
 
2546
 
 
2547
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2548
    } else { ETHR_DW_ATOMIC_FUNC__(init_relb)(var, val); }
 
2549
#endif
 
2550
 
 
2551
}
 
2552
 
 
2553
static ETHR_INLINE void ETHR_DW_ATMC_FUNC__(init_mb)(ethr_dw_atomic_t *var, ethr_dw_sint_t *val)
 
2554
{
 
2555
 
 
2556
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2557
    if (ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__) {
 
2558
#endif
 
2559
 
 
2560
#if defined(ETHR_HAVE_SU_DW_NATMC_INIT_MB)
 
2561
    ETHR_SU_DW_NATMC_FUNC__(init_mb)(&var->native, val->dw_sint);
 
2562
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_RELB)
 
2563
    ETHR_SU_DW_NATMC_FUNC__(init_relb)(&var->native, val->dw_sint);
 
2564
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2565
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_ACQB)
 
2566
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2567
    ETHR_SU_DW_NATMC_FUNC__(init_acqb)(&var->native, val->dw_sint);
 
2568
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_WB)
 
2569
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad);
 
2570
    ETHR_SU_DW_NATMC_FUNC__(init_wb)(&var->native, val->dw_sint);
 
2571
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2572
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT_RB)
 
2573
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2574
    ETHR_SU_DW_NATMC_FUNC__(init_rb)(&var->native, val->dw_sint);
 
2575
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2576
#elif defined(ETHR_HAVE_SU_DW_NATMC_INIT)
 
2577
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2578
    ETHR_SU_DW_NATMC_FUNC__(init)(&var->native, val->dw_sint);
 
2579
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2580
#elif defined(ETHR_HAVE_DW_NATMC_INIT_MB)
 
2581
    ETHR_DW_NATMC_FUNC__(init_mb)(&var->native, val->sint);
 
2582
#elif defined(ETHR_HAVE_DW_NATMC_INIT_RELB)
 
2583
    ETHR_DW_NATMC_FUNC__(init_relb)(&var->native, val->sint);
 
2584
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2585
#elif defined(ETHR_HAVE_DW_NATMC_INIT_ACQB)
 
2586
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2587
    ETHR_DW_NATMC_FUNC__(init_acqb)(&var->native, val->sint);
 
2588
#elif defined(ETHR_HAVE_DW_NATMC_INIT_WB)
 
2589
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad);
 
2590
    ETHR_DW_NATMC_FUNC__(init_wb)(&var->native, val->sint);
 
2591
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2592
#elif defined(ETHR_HAVE_DW_NATMC_INIT_RB)
 
2593
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2594
    ETHR_DW_NATMC_FUNC__(init_rb)(&var->native, val->sint);
 
2595
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2596
#elif defined(ETHR_HAVE_DW_NATMC_INIT)
 
2597
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2598
    ETHR_DW_NATMC_FUNC__(init)(&var->native, val->sint);
 
2599
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
2600
#else
 
2601
    ETHR_DW_ATMC_FUNC__(set_mb)(var, val);
 
2602
#endif
 
2603
 
 
2604
#if defined(ETHR_RTCHK_USE_NATIVE_DW_ATOMIC_IMPL__)
 
2605
    } else { ETHR_DW_ATOMIC_FUNC__(init_mb)(var, val); }
 
2606
#endif
 
2607
 
 
2608
}
 
2609
 
 
2610
#endif /* ETHR_DW_ATMC_INLINE__ */
 
2611
 
 
2612
 
 
2613
/* ---------- Word size atomic implementation ---------- */
 
2614
 
 
2615
 
 
2616
#ifdef ETHR_NEED_ATMC_PROTOTYPES__
 
2617
ethr_sint_t *ethr_atomic_addr(ethr_atomic_t *var);
 
2618
ethr_sint_t ethr_atomic_cmpxchg(ethr_atomic_t *var, ethr_sint_t val, ethr_sint_t old_val);
 
2619
ethr_sint_t ethr_atomic_cmpxchg_rb(ethr_atomic_t *var, ethr_sint_t val, ethr_sint_t old_val);
 
2620
ethr_sint_t ethr_atomic_cmpxchg_wb(ethr_atomic_t *var, ethr_sint_t val, ethr_sint_t old_val);
 
2621
ethr_sint_t ethr_atomic_cmpxchg_acqb(ethr_atomic_t *var, ethr_sint_t val, ethr_sint_t old_val);
 
2622
ethr_sint_t ethr_atomic_cmpxchg_relb(ethr_atomic_t *var, ethr_sint_t val, ethr_sint_t old_val);
 
2623
ethr_sint_t ethr_atomic_cmpxchg_mb(ethr_atomic_t *var, ethr_sint_t val, ethr_sint_t old_val);
 
2624
ethr_sint_t ethr_atomic_xchg(ethr_atomic_t *var, ethr_sint_t val);
 
2625
ethr_sint_t ethr_atomic_xchg_rb(ethr_atomic_t *var, ethr_sint_t val);
 
2626
ethr_sint_t ethr_atomic_xchg_wb(ethr_atomic_t *var, ethr_sint_t val);
 
2627
ethr_sint_t ethr_atomic_xchg_acqb(ethr_atomic_t *var, ethr_sint_t val);
 
2628
ethr_sint_t ethr_atomic_xchg_relb(ethr_atomic_t *var, ethr_sint_t val);
 
2629
ethr_sint_t ethr_atomic_xchg_mb(ethr_atomic_t *var, ethr_sint_t val);
 
2630
void ethr_atomic_set(ethr_atomic_t *var, ethr_sint_t val);
 
2631
void ethr_atomic_set_rb(ethr_atomic_t *var, ethr_sint_t val);
 
2632
void ethr_atomic_set_wb(ethr_atomic_t *var, ethr_sint_t val);
 
2633
void ethr_atomic_set_acqb(ethr_atomic_t *var, ethr_sint_t val);
 
2634
void ethr_atomic_set_relb(ethr_atomic_t *var, ethr_sint_t val);
 
2635
void ethr_atomic_set_mb(ethr_atomic_t *var, ethr_sint_t val);
 
2636
void ethr_atomic_init(ethr_atomic_t *var, ethr_sint_t val);
 
2637
void ethr_atomic_init_rb(ethr_atomic_t *var, ethr_sint_t val);
 
2638
void ethr_atomic_init_wb(ethr_atomic_t *var, ethr_sint_t val);
 
2639
void ethr_atomic_init_acqb(ethr_atomic_t *var, ethr_sint_t val);
 
2640
void ethr_atomic_init_relb(ethr_atomic_t *var, ethr_sint_t val);
 
2641
void ethr_atomic_init_mb(ethr_atomic_t *var, ethr_sint_t val);
 
2642
ethr_sint_t ethr_atomic_add_read(ethr_atomic_t *var, ethr_sint_t val);
 
2643
ethr_sint_t ethr_atomic_add_read_rb(ethr_atomic_t *var, ethr_sint_t val);
 
2644
ethr_sint_t ethr_atomic_add_read_wb(ethr_atomic_t *var, ethr_sint_t val);
 
2645
ethr_sint_t ethr_atomic_add_read_acqb(ethr_atomic_t *var, ethr_sint_t val);
 
2646
ethr_sint_t ethr_atomic_add_read_relb(ethr_atomic_t *var, ethr_sint_t val);
 
2647
ethr_sint_t ethr_atomic_add_read_mb(ethr_atomic_t *var, ethr_sint_t val);
 
2648
ethr_sint_t ethr_atomic_read(ethr_atomic_t *var);
 
2649
ethr_sint_t ethr_atomic_read_rb(ethr_atomic_t *var);
 
2650
ethr_sint_t ethr_atomic_read_wb(ethr_atomic_t *var);
 
2651
ethr_sint_t ethr_atomic_read_acqb(ethr_atomic_t *var);
 
2652
ethr_sint_t ethr_atomic_read_relb(ethr_atomic_t *var);
 
2653
ethr_sint_t ethr_atomic_read_mb(ethr_atomic_t *var);
 
2654
ethr_sint_t ethr_atomic_inc_read(ethr_atomic_t *var);
 
2655
ethr_sint_t ethr_atomic_inc_read_rb(ethr_atomic_t *var);
 
2656
ethr_sint_t ethr_atomic_inc_read_wb(ethr_atomic_t *var);
 
2657
ethr_sint_t ethr_atomic_inc_read_acqb(ethr_atomic_t *var);
 
2658
ethr_sint_t ethr_atomic_inc_read_relb(ethr_atomic_t *var);
 
2659
ethr_sint_t ethr_atomic_inc_read_mb(ethr_atomic_t *var);
 
2660
ethr_sint_t ethr_atomic_dec_read(ethr_atomic_t *var);
 
2661
ethr_sint_t ethr_atomic_dec_read_rb(ethr_atomic_t *var);
 
2662
ethr_sint_t ethr_atomic_dec_read_wb(ethr_atomic_t *var);
 
2663
ethr_sint_t ethr_atomic_dec_read_acqb(ethr_atomic_t *var);
 
2664
ethr_sint_t ethr_atomic_dec_read_relb(ethr_atomic_t *var);
 
2665
ethr_sint_t ethr_atomic_dec_read_mb(ethr_atomic_t *var);
 
2666
void ethr_atomic_add(ethr_atomic_t *var, ethr_sint_t val);
 
2667
void ethr_atomic_add_rb(ethr_atomic_t *var, ethr_sint_t val);
 
2668
void ethr_atomic_add_wb(ethr_atomic_t *var, ethr_sint_t val);
 
2669
void ethr_atomic_add_acqb(ethr_atomic_t *var, ethr_sint_t val);
 
2670
void ethr_atomic_add_relb(ethr_atomic_t *var, ethr_sint_t val);
 
2671
void ethr_atomic_add_mb(ethr_atomic_t *var, ethr_sint_t val);
 
2672
void ethr_atomic_inc(ethr_atomic_t *var);
 
2673
void ethr_atomic_inc_rb(ethr_atomic_t *var);
 
2674
void ethr_atomic_inc_wb(ethr_atomic_t *var);
 
2675
void ethr_atomic_inc_acqb(ethr_atomic_t *var);
 
2676
void ethr_atomic_inc_relb(ethr_atomic_t *var);
 
2677
void ethr_atomic_inc_mb(ethr_atomic_t *var);
 
2678
void ethr_atomic_dec(ethr_atomic_t *var);
 
2679
void ethr_atomic_dec_rb(ethr_atomic_t *var);
 
2680
void ethr_atomic_dec_wb(ethr_atomic_t *var);
 
2681
void ethr_atomic_dec_acqb(ethr_atomic_t *var);
 
2682
void ethr_atomic_dec_relb(ethr_atomic_t *var);
 
2683
void ethr_atomic_dec_mb(ethr_atomic_t *var);
 
2684
ethr_sint_t ethr_atomic_read_band(ethr_atomic_t *var, ethr_sint_t val);
 
2685
ethr_sint_t ethr_atomic_read_band_rb(ethr_atomic_t *var, ethr_sint_t val);
 
2686
ethr_sint_t ethr_atomic_read_band_wb(ethr_atomic_t *var, ethr_sint_t val);
 
2687
ethr_sint_t ethr_atomic_read_band_acqb(ethr_atomic_t *var, ethr_sint_t val);
 
2688
ethr_sint_t ethr_atomic_read_band_relb(ethr_atomic_t *var, ethr_sint_t val);
 
2689
ethr_sint_t ethr_atomic_read_band_mb(ethr_atomic_t *var, ethr_sint_t val);
 
2690
ethr_sint_t ethr_atomic_read_bor(ethr_atomic_t *var, ethr_sint_t val);
 
2691
ethr_sint_t ethr_atomic_read_bor_rb(ethr_atomic_t *var, ethr_sint_t val);
 
2692
ethr_sint_t ethr_atomic_read_bor_wb(ethr_atomic_t *var, ethr_sint_t val);
 
2693
ethr_sint_t ethr_atomic_read_bor_acqb(ethr_atomic_t *var, ethr_sint_t val);
 
2694
ethr_sint_t ethr_atomic_read_bor_relb(ethr_atomic_t *var, ethr_sint_t val);
 
2695
ethr_sint_t ethr_atomic_read_bor_mb(ethr_atomic_t *var, ethr_sint_t val);
 
2696
#endif /* ETHR_NEED_ATMC_PROTOTYPES__ */
 
2697
 
 
2698
#if (defined(ETHR_HAVE_WORD_SZ_NATIVE_ATOMIC_OPS) \
 
2699
     && (defined(ETHR_ATMC_INLINE__) || defined(ETHR_ATOMIC_IMPL__)))
 
2700
 
 
2701
#if !defined(ETHR_NATMC_BITS__)
 
2702
#  error "Missing native atomic implementation"
 
2703
#elif ETHR_NATMC_BITS__ == 64
 
2704
#  undef ETHR_HAVE_NATMC_CMPXCHG
 
2705
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_CMPXCHG
 
2706
#    define ETHR_HAVE_NATMC_CMPXCHG 1
 
2707
#  endif
 
2708
#  undef ETHR_HAVE_NATMC_CMPXCHG_RB
 
2709
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_CMPXCHG_RB
 
2710
#    define ETHR_HAVE_NATMC_CMPXCHG_RB 1
 
2711
#  endif
 
2712
#  undef ETHR_HAVE_NATMC_CMPXCHG_WB
 
2713
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_CMPXCHG_WB
 
2714
#    define ETHR_HAVE_NATMC_CMPXCHG_WB 1
 
2715
#  endif
 
2716
#  undef ETHR_HAVE_NATMC_CMPXCHG_ACQB
 
2717
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_CMPXCHG_ACQB
 
2718
#    define ETHR_HAVE_NATMC_CMPXCHG_ACQB 1
 
2719
#  endif
 
2720
#  undef ETHR_HAVE_NATMC_CMPXCHG_RELB
 
2721
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_CMPXCHG_RELB
 
2722
#    define ETHR_HAVE_NATMC_CMPXCHG_RELB 1
 
2723
#  endif
 
2724
#  undef ETHR_HAVE_NATMC_CMPXCHG_MB
 
2725
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_CMPXCHG_MB
 
2726
#    define ETHR_HAVE_NATMC_CMPXCHG_MB 1
 
2727
#  endif
 
2728
#  undef ETHR_HAVE_NATMC_XCHG
 
2729
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_XCHG
 
2730
#    define ETHR_HAVE_NATMC_XCHG 1
 
2731
#  endif
 
2732
#  undef ETHR_HAVE_NATMC_XCHG_RB
 
2733
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_XCHG_RB
 
2734
#    define ETHR_HAVE_NATMC_XCHG_RB 1
 
2735
#  endif
 
2736
#  undef ETHR_HAVE_NATMC_XCHG_WB
 
2737
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_XCHG_WB
 
2738
#    define ETHR_HAVE_NATMC_XCHG_WB 1
 
2739
#  endif
 
2740
#  undef ETHR_HAVE_NATMC_XCHG_ACQB
 
2741
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_XCHG_ACQB
 
2742
#    define ETHR_HAVE_NATMC_XCHG_ACQB 1
 
2743
#  endif
 
2744
#  undef ETHR_HAVE_NATMC_XCHG_RELB
 
2745
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_XCHG_RELB
 
2746
#    define ETHR_HAVE_NATMC_XCHG_RELB 1
 
2747
#  endif
 
2748
#  undef ETHR_HAVE_NATMC_XCHG_MB
 
2749
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_XCHG_MB
 
2750
#    define ETHR_HAVE_NATMC_XCHG_MB 1
 
2751
#  endif
 
2752
#  undef ETHR_HAVE_NATMC_SET
 
2753
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_SET
 
2754
#    define ETHR_HAVE_NATMC_SET 1
 
2755
#  endif
 
2756
#  undef ETHR_HAVE_NATMC_SET_RB
 
2757
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_SET_RB
 
2758
#    define ETHR_HAVE_NATMC_SET_RB 1
 
2759
#  endif
 
2760
#  undef ETHR_HAVE_NATMC_SET_WB
 
2761
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_SET_WB
 
2762
#    define ETHR_HAVE_NATMC_SET_WB 1
 
2763
#  endif
 
2764
#  undef ETHR_HAVE_NATMC_SET_ACQB
 
2765
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_SET_ACQB
 
2766
#    define ETHR_HAVE_NATMC_SET_ACQB 1
 
2767
#  endif
 
2768
#  undef ETHR_HAVE_NATMC_SET_RELB
 
2769
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_SET_RELB
 
2770
#    define ETHR_HAVE_NATMC_SET_RELB 1
 
2771
#  endif
 
2772
#  undef ETHR_HAVE_NATMC_SET_MB
 
2773
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_SET_MB
 
2774
#    define ETHR_HAVE_NATMC_SET_MB 1
 
2775
#  endif
 
2776
#  undef ETHR_HAVE_NATMC_INIT
 
2777
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INIT
 
2778
#    define ETHR_HAVE_NATMC_INIT 1
 
2779
#  endif
 
2780
#  undef ETHR_HAVE_NATMC_INIT_RB
 
2781
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INIT_RB
 
2782
#    define ETHR_HAVE_NATMC_INIT_RB 1
 
2783
#  endif
 
2784
#  undef ETHR_HAVE_NATMC_INIT_WB
 
2785
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INIT_WB
 
2786
#    define ETHR_HAVE_NATMC_INIT_WB 1
 
2787
#  endif
 
2788
#  undef ETHR_HAVE_NATMC_INIT_ACQB
 
2789
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INIT_ACQB
 
2790
#    define ETHR_HAVE_NATMC_INIT_ACQB 1
 
2791
#  endif
 
2792
#  undef ETHR_HAVE_NATMC_INIT_RELB
 
2793
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INIT_RELB
 
2794
#    define ETHR_HAVE_NATMC_INIT_RELB 1
 
2795
#  endif
 
2796
#  undef ETHR_HAVE_NATMC_INIT_MB
 
2797
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INIT_MB
 
2798
#    define ETHR_HAVE_NATMC_INIT_MB 1
 
2799
#  endif
 
2800
#  undef ETHR_HAVE_NATMC_ADD_RETURN
 
2801
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_RETURN
 
2802
#    define ETHR_HAVE_NATMC_ADD_RETURN 1
 
2803
#  endif
 
2804
#  undef ETHR_HAVE_NATMC_ADD_RETURN_RB
 
2805
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_RETURN_RB
 
2806
#    define ETHR_HAVE_NATMC_ADD_RETURN_RB 1
 
2807
#  endif
 
2808
#  undef ETHR_HAVE_NATMC_ADD_RETURN_WB
 
2809
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_RETURN_WB
 
2810
#    define ETHR_HAVE_NATMC_ADD_RETURN_WB 1
 
2811
#  endif
 
2812
#  undef ETHR_HAVE_NATMC_ADD_RETURN_ACQB
 
2813
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_RETURN_ACQB
 
2814
#    define ETHR_HAVE_NATMC_ADD_RETURN_ACQB 1
 
2815
#  endif
 
2816
#  undef ETHR_HAVE_NATMC_ADD_RETURN_RELB
 
2817
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_RETURN_RELB
 
2818
#    define ETHR_HAVE_NATMC_ADD_RETURN_RELB 1
 
2819
#  endif
 
2820
#  undef ETHR_HAVE_NATMC_ADD_RETURN_MB
 
2821
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_RETURN_MB
 
2822
#    define ETHR_HAVE_NATMC_ADD_RETURN_MB 1
 
2823
#  endif
 
2824
#  undef ETHR_HAVE_NATMC_READ
 
2825
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_READ
 
2826
#    define ETHR_HAVE_NATMC_READ 1
 
2827
#  endif
 
2828
#  undef ETHR_HAVE_NATMC_READ_RB
 
2829
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_READ_RB
 
2830
#    define ETHR_HAVE_NATMC_READ_RB 1
 
2831
#  endif
 
2832
#  undef ETHR_HAVE_NATMC_READ_WB
 
2833
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_READ_WB
 
2834
#    define ETHR_HAVE_NATMC_READ_WB 1
 
2835
#  endif
 
2836
#  undef ETHR_HAVE_NATMC_READ_ACQB
 
2837
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_READ_ACQB
 
2838
#    define ETHR_HAVE_NATMC_READ_ACQB 1
 
2839
#  endif
 
2840
#  undef ETHR_HAVE_NATMC_READ_RELB
 
2841
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_READ_RELB
 
2842
#    define ETHR_HAVE_NATMC_READ_RELB 1
 
2843
#  endif
 
2844
#  undef ETHR_HAVE_NATMC_READ_MB
 
2845
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_READ_MB
 
2846
#    define ETHR_HAVE_NATMC_READ_MB 1
 
2847
#  endif
 
2848
#  undef ETHR_HAVE_NATMC_INC_RETURN
 
2849
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_RETURN
 
2850
#    define ETHR_HAVE_NATMC_INC_RETURN 1
 
2851
#  endif
 
2852
#  undef ETHR_HAVE_NATMC_INC_RETURN_RB
 
2853
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_RETURN_RB
 
2854
#    define ETHR_HAVE_NATMC_INC_RETURN_RB 1
 
2855
#  endif
 
2856
#  undef ETHR_HAVE_NATMC_INC_RETURN_WB
 
2857
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_RETURN_WB
 
2858
#    define ETHR_HAVE_NATMC_INC_RETURN_WB 1
 
2859
#  endif
 
2860
#  undef ETHR_HAVE_NATMC_INC_RETURN_ACQB
 
2861
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_RETURN_ACQB
 
2862
#    define ETHR_HAVE_NATMC_INC_RETURN_ACQB 1
 
2863
#  endif
 
2864
#  undef ETHR_HAVE_NATMC_INC_RETURN_RELB
 
2865
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_RETURN_RELB
 
2866
#    define ETHR_HAVE_NATMC_INC_RETURN_RELB 1
 
2867
#  endif
 
2868
#  undef ETHR_HAVE_NATMC_INC_RETURN_MB
 
2869
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_RETURN_MB
 
2870
#    define ETHR_HAVE_NATMC_INC_RETURN_MB 1
 
2871
#  endif
 
2872
#  undef ETHR_HAVE_NATMC_DEC_RETURN
 
2873
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_RETURN
 
2874
#    define ETHR_HAVE_NATMC_DEC_RETURN 1
 
2875
#  endif
 
2876
#  undef ETHR_HAVE_NATMC_DEC_RETURN_RB
 
2877
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_RETURN_RB
 
2878
#    define ETHR_HAVE_NATMC_DEC_RETURN_RB 1
 
2879
#  endif
 
2880
#  undef ETHR_HAVE_NATMC_DEC_RETURN_WB
 
2881
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_RETURN_WB
 
2882
#    define ETHR_HAVE_NATMC_DEC_RETURN_WB 1
 
2883
#  endif
 
2884
#  undef ETHR_HAVE_NATMC_DEC_RETURN_ACQB
 
2885
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_RETURN_ACQB
 
2886
#    define ETHR_HAVE_NATMC_DEC_RETURN_ACQB 1
 
2887
#  endif
 
2888
#  undef ETHR_HAVE_NATMC_DEC_RETURN_RELB
 
2889
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_RETURN_RELB
 
2890
#    define ETHR_HAVE_NATMC_DEC_RETURN_RELB 1
 
2891
#  endif
 
2892
#  undef ETHR_HAVE_NATMC_DEC_RETURN_MB
 
2893
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_RETURN_MB
 
2894
#    define ETHR_HAVE_NATMC_DEC_RETURN_MB 1
 
2895
#  endif
 
2896
#  undef ETHR_HAVE_NATMC_ADD
 
2897
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD
 
2898
#    define ETHR_HAVE_NATMC_ADD 1
 
2899
#  endif
 
2900
#  undef ETHR_HAVE_NATMC_ADD_RB
 
2901
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_RB
 
2902
#    define ETHR_HAVE_NATMC_ADD_RB 1
 
2903
#  endif
 
2904
#  undef ETHR_HAVE_NATMC_ADD_WB
 
2905
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_WB
 
2906
#    define ETHR_HAVE_NATMC_ADD_WB 1
 
2907
#  endif
 
2908
#  undef ETHR_HAVE_NATMC_ADD_ACQB
 
2909
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_ACQB
 
2910
#    define ETHR_HAVE_NATMC_ADD_ACQB 1
 
2911
#  endif
 
2912
#  undef ETHR_HAVE_NATMC_ADD_RELB
 
2913
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_RELB
 
2914
#    define ETHR_HAVE_NATMC_ADD_RELB 1
 
2915
#  endif
 
2916
#  undef ETHR_HAVE_NATMC_ADD_MB
 
2917
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_MB
 
2918
#    define ETHR_HAVE_NATMC_ADD_MB 1
 
2919
#  endif
 
2920
#  undef ETHR_HAVE_NATMC_INC
 
2921
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC
 
2922
#    define ETHR_HAVE_NATMC_INC 1
 
2923
#  endif
 
2924
#  undef ETHR_HAVE_NATMC_INC_RB
 
2925
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_RB
 
2926
#    define ETHR_HAVE_NATMC_INC_RB 1
 
2927
#  endif
 
2928
#  undef ETHR_HAVE_NATMC_INC_WB
 
2929
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_WB
 
2930
#    define ETHR_HAVE_NATMC_INC_WB 1
 
2931
#  endif
 
2932
#  undef ETHR_HAVE_NATMC_INC_ACQB
 
2933
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_ACQB
 
2934
#    define ETHR_HAVE_NATMC_INC_ACQB 1
 
2935
#  endif
 
2936
#  undef ETHR_HAVE_NATMC_INC_RELB
 
2937
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_RELB
 
2938
#    define ETHR_HAVE_NATMC_INC_RELB 1
 
2939
#  endif
 
2940
#  undef ETHR_HAVE_NATMC_INC_MB
 
2941
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_MB
 
2942
#    define ETHR_HAVE_NATMC_INC_MB 1
 
2943
#  endif
 
2944
#  undef ETHR_HAVE_NATMC_DEC
 
2945
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC
 
2946
#    define ETHR_HAVE_NATMC_DEC 1
 
2947
#  endif
 
2948
#  undef ETHR_HAVE_NATMC_DEC_RB
 
2949
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_RB
 
2950
#    define ETHR_HAVE_NATMC_DEC_RB 1
 
2951
#  endif
 
2952
#  undef ETHR_HAVE_NATMC_DEC_WB
 
2953
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_WB
 
2954
#    define ETHR_HAVE_NATMC_DEC_WB 1
 
2955
#  endif
 
2956
#  undef ETHR_HAVE_NATMC_DEC_ACQB
 
2957
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_ACQB
 
2958
#    define ETHR_HAVE_NATMC_DEC_ACQB 1
 
2959
#  endif
 
2960
#  undef ETHR_HAVE_NATMC_DEC_RELB
 
2961
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_RELB
 
2962
#    define ETHR_HAVE_NATMC_DEC_RELB 1
 
2963
#  endif
 
2964
#  undef ETHR_HAVE_NATMC_DEC_MB
 
2965
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_MB
 
2966
#    define ETHR_HAVE_NATMC_DEC_MB 1
 
2967
#  endif
 
2968
#  undef ETHR_HAVE_NATMC_AND_RETOLD
 
2969
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_AND_RETOLD
 
2970
#    define ETHR_HAVE_NATMC_AND_RETOLD 1
 
2971
#  endif
 
2972
#  undef ETHR_HAVE_NATMC_AND_RETOLD_RB
 
2973
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_AND_RETOLD_RB
 
2974
#    define ETHR_HAVE_NATMC_AND_RETOLD_RB 1
 
2975
#  endif
 
2976
#  undef ETHR_HAVE_NATMC_AND_RETOLD_WB
 
2977
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_AND_RETOLD_WB
 
2978
#    define ETHR_HAVE_NATMC_AND_RETOLD_WB 1
 
2979
#  endif
 
2980
#  undef ETHR_HAVE_NATMC_AND_RETOLD_ACQB
 
2981
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_AND_RETOLD_ACQB
 
2982
#    define ETHR_HAVE_NATMC_AND_RETOLD_ACQB 1
 
2983
#  endif
 
2984
#  undef ETHR_HAVE_NATMC_AND_RETOLD_RELB
 
2985
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_AND_RETOLD_RELB
 
2986
#    define ETHR_HAVE_NATMC_AND_RETOLD_RELB 1
 
2987
#  endif
 
2988
#  undef ETHR_HAVE_NATMC_AND_RETOLD_MB
 
2989
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_AND_RETOLD_MB
 
2990
#    define ETHR_HAVE_NATMC_AND_RETOLD_MB 1
 
2991
#  endif
 
2992
#  undef ETHR_HAVE_NATMC_OR_RETOLD
 
2993
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_OR_RETOLD
 
2994
#    define ETHR_HAVE_NATMC_OR_RETOLD 1
 
2995
#  endif
 
2996
#  undef ETHR_HAVE_NATMC_OR_RETOLD_RB
 
2997
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_OR_RETOLD_RB
 
2998
#    define ETHR_HAVE_NATMC_OR_RETOLD_RB 1
 
2999
#  endif
 
3000
#  undef ETHR_HAVE_NATMC_OR_RETOLD_WB
 
3001
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_OR_RETOLD_WB
 
3002
#    define ETHR_HAVE_NATMC_OR_RETOLD_WB 1
 
3003
#  endif
 
3004
#  undef ETHR_HAVE_NATMC_OR_RETOLD_ACQB
 
3005
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_OR_RETOLD_ACQB
 
3006
#    define ETHR_HAVE_NATMC_OR_RETOLD_ACQB 1
 
3007
#  endif
 
3008
#  undef ETHR_HAVE_NATMC_OR_RETOLD_RELB
 
3009
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_OR_RETOLD_RELB
 
3010
#    define ETHR_HAVE_NATMC_OR_RETOLD_RELB 1
 
3011
#  endif
 
3012
#  undef ETHR_HAVE_NATMC_OR_RETOLD_MB
 
3013
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_OR_RETOLD_MB
 
3014
#    define ETHR_HAVE_NATMC_OR_RETOLD_MB 1
 
3015
#  endif
 
3016
#elif ETHR_NATMC_BITS__ == 32
 
3017
#  undef ETHR_HAVE_NATMC_CMPXCHG
 
3018
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_CMPXCHG
 
3019
#    define ETHR_HAVE_NATMC_CMPXCHG 1
 
3020
#  endif
 
3021
#  undef ETHR_HAVE_NATMC_CMPXCHG_RB
 
3022
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_CMPXCHG_RB
 
3023
#    define ETHR_HAVE_NATMC_CMPXCHG_RB 1
 
3024
#  endif
 
3025
#  undef ETHR_HAVE_NATMC_CMPXCHG_WB
 
3026
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_CMPXCHG_WB
 
3027
#    define ETHR_HAVE_NATMC_CMPXCHG_WB 1
 
3028
#  endif
 
3029
#  undef ETHR_HAVE_NATMC_CMPXCHG_ACQB
 
3030
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_CMPXCHG_ACQB
 
3031
#    define ETHR_HAVE_NATMC_CMPXCHG_ACQB 1
 
3032
#  endif
 
3033
#  undef ETHR_HAVE_NATMC_CMPXCHG_RELB
 
3034
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_CMPXCHG_RELB
 
3035
#    define ETHR_HAVE_NATMC_CMPXCHG_RELB 1
 
3036
#  endif
 
3037
#  undef ETHR_HAVE_NATMC_CMPXCHG_MB
 
3038
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_CMPXCHG_MB
 
3039
#    define ETHR_HAVE_NATMC_CMPXCHG_MB 1
 
3040
#  endif
 
3041
#  undef ETHR_HAVE_NATMC_XCHG
 
3042
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_XCHG
 
3043
#    define ETHR_HAVE_NATMC_XCHG 1
 
3044
#  endif
 
3045
#  undef ETHR_HAVE_NATMC_XCHG_RB
 
3046
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_XCHG_RB
 
3047
#    define ETHR_HAVE_NATMC_XCHG_RB 1
 
3048
#  endif
 
3049
#  undef ETHR_HAVE_NATMC_XCHG_WB
 
3050
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_XCHG_WB
 
3051
#    define ETHR_HAVE_NATMC_XCHG_WB 1
 
3052
#  endif
 
3053
#  undef ETHR_HAVE_NATMC_XCHG_ACQB
 
3054
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_XCHG_ACQB
 
3055
#    define ETHR_HAVE_NATMC_XCHG_ACQB 1
 
3056
#  endif
 
3057
#  undef ETHR_HAVE_NATMC_XCHG_RELB
 
3058
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_XCHG_RELB
 
3059
#    define ETHR_HAVE_NATMC_XCHG_RELB 1
 
3060
#  endif
 
3061
#  undef ETHR_HAVE_NATMC_XCHG_MB
 
3062
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_XCHG_MB
 
3063
#    define ETHR_HAVE_NATMC_XCHG_MB 1
 
3064
#  endif
 
3065
#  undef ETHR_HAVE_NATMC_SET
 
3066
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_SET
 
3067
#    define ETHR_HAVE_NATMC_SET 1
 
3068
#  endif
 
3069
#  undef ETHR_HAVE_NATMC_SET_RB
 
3070
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_SET_RB
 
3071
#    define ETHR_HAVE_NATMC_SET_RB 1
 
3072
#  endif
 
3073
#  undef ETHR_HAVE_NATMC_SET_WB
 
3074
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_SET_WB
 
3075
#    define ETHR_HAVE_NATMC_SET_WB 1
 
3076
#  endif
 
3077
#  undef ETHR_HAVE_NATMC_SET_ACQB
 
3078
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_SET_ACQB
 
3079
#    define ETHR_HAVE_NATMC_SET_ACQB 1
 
3080
#  endif
 
3081
#  undef ETHR_HAVE_NATMC_SET_RELB
 
3082
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_SET_RELB
 
3083
#    define ETHR_HAVE_NATMC_SET_RELB 1
 
3084
#  endif
 
3085
#  undef ETHR_HAVE_NATMC_SET_MB
 
3086
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_SET_MB
 
3087
#    define ETHR_HAVE_NATMC_SET_MB 1
 
3088
#  endif
 
3089
#  undef ETHR_HAVE_NATMC_INIT
 
3090
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INIT
 
3091
#    define ETHR_HAVE_NATMC_INIT 1
 
3092
#  endif
 
3093
#  undef ETHR_HAVE_NATMC_INIT_RB
 
3094
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INIT_RB
 
3095
#    define ETHR_HAVE_NATMC_INIT_RB 1
 
3096
#  endif
 
3097
#  undef ETHR_HAVE_NATMC_INIT_WB
 
3098
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INIT_WB
 
3099
#    define ETHR_HAVE_NATMC_INIT_WB 1
 
3100
#  endif
 
3101
#  undef ETHR_HAVE_NATMC_INIT_ACQB
 
3102
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INIT_ACQB
 
3103
#    define ETHR_HAVE_NATMC_INIT_ACQB 1
 
3104
#  endif
 
3105
#  undef ETHR_HAVE_NATMC_INIT_RELB
 
3106
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INIT_RELB
 
3107
#    define ETHR_HAVE_NATMC_INIT_RELB 1
 
3108
#  endif
 
3109
#  undef ETHR_HAVE_NATMC_INIT_MB
 
3110
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INIT_MB
 
3111
#    define ETHR_HAVE_NATMC_INIT_MB 1
 
3112
#  endif
 
3113
#  undef ETHR_HAVE_NATMC_ADD_RETURN
 
3114
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_RETURN
 
3115
#    define ETHR_HAVE_NATMC_ADD_RETURN 1
 
3116
#  endif
 
3117
#  undef ETHR_HAVE_NATMC_ADD_RETURN_RB
 
3118
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_RETURN_RB
 
3119
#    define ETHR_HAVE_NATMC_ADD_RETURN_RB 1
 
3120
#  endif
 
3121
#  undef ETHR_HAVE_NATMC_ADD_RETURN_WB
 
3122
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_RETURN_WB
 
3123
#    define ETHR_HAVE_NATMC_ADD_RETURN_WB 1
 
3124
#  endif
 
3125
#  undef ETHR_HAVE_NATMC_ADD_RETURN_ACQB
 
3126
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_RETURN_ACQB
 
3127
#    define ETHR_HAVE_NATMC_ADD_RETURN_ACQB 1
 
3128
#  endif
 
3129
#  undef ETHR_HAVE_NATMC_ADD_RETURN_RELB
 
3130
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_RETURN_RELB
 
3131
#    define ETHR_HAVE_NATMC_ADD_RETURN_RELB 1
 
3132
#  endif
 
3133
#  undef ETHR_HAVE_NATMC_ADD_RETURN_MB
 
3134
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_RETURN_MB
 
3135
#    define ETHR_HAVE_NATMC_ADD_RETURN_MB 1
 
3136
#  endif
 
3137
#  undef ETHR_HAVE_NATMC_READ
 
3138
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_READ
 
3139
#    define ETHR_HAVE_NATMC_READ 1
 
3140
#  endif
 
3141
#  undef ETHR_HAVE_NATMC_READ_RB
 
3142
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_READ_RB
 
3143
#    define ETHR_HAVE_NATMC_READ_RB 1
 
3144
#  endif
 
3145
#  undef ETHR_HAVE_NATMC_READ_WB
 
3146
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_READ_WB
 
3147
#    define ETHR_HAVE_NATMC_READ_WB 1
 
3148
#  endif
 
3149
#  undef ETHR_HAVE_NATMC_READ_ACQB
 
3150
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_READ_ACQB
 
3151
#    define ETHR_HAVE_NATMC_READ_ACQB 1
 
3152
#  endif
 
3153
#  undef ETHR_HAVE_NATMC_READ_RELB
 
3154
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_READ_RELB
 
3155
#    define ETHR_HAVE_NATMC_READ_RELB 1
 
3156
#  endif
 
3157
#  undef ETHR_HAVE_NATMC_READ_MB
 
3158
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_READ_MB
 
3159
#    define ETHR_HAVE_NATMC_READ_MB 1
 
3160
#  endif
 
3161
#  undef ETHR_HAVE_NATMC_INC_RETURN
 
3162
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_RETURN
 
3163
#    define ETHR_HAVE_NATMC_INC_RETURN 1
 
3164
#  endif
 
3165
#  undef ETHR_HAVE_NATMC_INC_RETURN_RB
 
3166
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_RETURN_RB
 
3167
#    define ETHR_HAVE_NATMC_INC_RETURN_RB 1
 
3168
#  endif
 
3169
#  undef ETHR_HAVE_NATMC_INC_RETURN_WB
 
3170
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_RETURN_WB
 
3171
#    define ETHR_HAVE_NATMC_INC_RETURN_WB 1
 
3172
#  endif
 
3173
#  undef ETHR_HAVE_NATMC_INC_RETURN_ACQB
 
3174
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_RETURN_ACQB
 
3175
#    define ETHR_HAVE_NATMC_INC_RETURN_ACQB 1
 
3176
#  endif
 
3177
#  undef ETHR_HAVE_NATMC_INC_RETURN_RELB
 
3178
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_RETURN_RELB
 
3179
#    define ETHR_HAVE_NATMC_INC_RETURN_RELB 1
 
3180
#  endif
 
3181
#  undef ETHR_HAVE_NATMC_INC_RETURN_MB
 
3182
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_RETURN_MB
 
3183
#    define ETHR_HAVE_NATMC_INC_RETURN_MB 1
 
3184
#  endif
 
3185
#  undef ETHR_HAVE_NATMC_DEC_RETURN
 
3186
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_RETURN
 
3187
#    define ETHR_HAVE_NATMC_DEC_RETURN 1
 
3188
#  endif
 
3189
#  undef ETHR_HAVE_NATMC_DEC_RETURN_RB
 
3190
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_RETURN_RB
 
3191
#    define ETHR_HAVE_NATMC_DEC_RETURN_RB 1
 
3192
#  endif
 
3193
#  undef ETHR_HAVE_NATMC_DEC_RETURN_WB
 
3194
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_RETURN_WB
 
3195
#    define ETHR_HAVE_NATMC_DEC_RETURN_WB 1
 
3196
#  endif
 
3197
#  undef ETHR_HAVE_NATMC_DEC_RETURN_ACQB
 
3198
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_RETURN_ACQB
 
3199
#    define ETHR_HAVE_NATMC_DEC_RETURN_ACQB 1
 
3200
#  endif
 
3201
#  undef ETHR_HAVE_NATMC_DEC_RETURN_RELB
 
3202
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_RETURN_RELB
 
3203
#    define ETHR_HAVE_NATMC_DEC_RETURN_RELB 1
 
3204
#  endif
 
3205
#  undef ETHR_HAVE_NATMC_DEC_RETURN_MB
 
3206
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_RETURN_MB
 
3207
#    define ETHR_HAVE_NATMC_DEC_RETURN_MB 1
 
3208
#  endif
 
3209
#  undef ETHR_HAVE_NATMC_ADD
 
3210
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD
 
3211
#    define ETHR_HAVE_NATMC_ADD 1
 
3212
#  endif
 
3213
#  undef ETHR_HAVE_NATMC_ADD_RB
 
3214
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_RB
 
3215
#    define ETHR_HAVE_NATMC_ADD_RB 1
 
3216
#  endif
 
3217
#  undef ETHR_HAVE_NATMC_ADD_WB
 
3218
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_WB
 
3219
#    define ETHR_HAVE_NATMC_ADD_WB 1
 
3220
#  endif
 
3221
#  undef ETHR_HAVE_NATMC_ADD_ACQB
 
3222
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_ACQB
 
3223
#    define ETHR_HAVE_NATMC_ADD_ACQB 1
 
3224
#  endif
 
3225
#  undef ETHR_HAVE_NATMC_ADD_RELB
 
3226
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_RELB
 
3227
#    define ETHR_HAVE_NATMC_ADD_RELB 1
 
3228
#  endif
 
3229
#  undef ETHR_HAVE_NATMC_ADD_MB
 
3230
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_MB
 
3231
#    define ETHR_HAVE_NATMC_ADD_MB 1
 
3232
#  endif
 
3233
#  undef ETHR_HAVE_NATMC_INC
 
3234
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC
 
3235
#    define ETHR_HAVE_NATMC_INC 1
 
3236
#  endif
 
3237
#  undef ETHR_HAVE_NATMC_INC_RB
 
3238
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_RB
 
3239
#    define ETHR_HAVE_NATMC_INC_RB 1
 
3240
#  endif
 
3241
#  undef ETHR_HAVE_NATMC_INC_WB
 
3242
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_WB
 
3243
#    define ETHR_HAVE_NATMC_INC_WB 1
 
3244
#  endif
 
3245
#  undef ETHR_HAVE_NATMC_INC_ACQB
 
3246
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_ACQB
 
3247
#    define ETHR_HAVE_NATMC_INC_ACQB 1
 
3248
#  endif
 
3249
#  undef ETHR_HAVE_NATMC_INC_RELB
 
3250
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_RELB
 
3251
#    define ETHR_HAVE_NATMC_INC_RELB 1
 
3252
#  endif
 
3253
#  undef ETHR_HAVE_NATMC_INC_MB
 
3254
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_MB
 
3255
#    define ETHR_HAVE_NATMC_INC_MB 1
 
3256
#  endif
 
3257
#  undef ETHR_HAVE_NATMC_DEC
 
3258
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC
 
3259
#    define ETHR_HAVE_NATMC_DEC 1
 
3260
#  endif
 
3261
#  undef ETHR_HAVE_NATMC_DEC_RB
 
3262
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_RB
 
3263
#    define ETHR_HAVE_NATMC_DEC_RB 1
 
3264
#  endif
 
3265
#  undef ETHR_HAVE_NATMC_DEC_WB
 
3266
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_WB
 
3267
#    define ETHR_HAVE_NATMC_DEC_WB 1
 
3268
#  endif
 
3269
#  undef ETHR_HAVE_NATMC_DEC_ACQB
 
3270
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_ACQB
 
3271
#    define ETHR_HAVE_NATMC_DEC_ACQB 1
 
3272
#  endif
 
3273
#  undef ETHR_HAVE_NATMC_DEC_RELB
 
3274
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_RELB
 
3275
#    define ETHR_HAVE_NATMC_DEC_RELB 1
 
3276
#  endif
 
3277
#  undef ETHR_HAVE_NATMC_DEC_MB
 
3278
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_MB
 
3279
#    define ETHR_HAVE_NATMC_DEC_MB 1
 
3280
#  endif
 
3281
#  undef ETHR_HAVE_NATMC_AND_RETOLD
 
3282
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_AND_RETOLD
 
3283
#    define ETHR_HAVE_NATMC_AND_RETOLD 1
 
3284
#  endif
 
3285
#  undef ETHR_HAVE_NATMC_AND_RETOLD_RB
 
3286
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_AND_RETOLD_RB
 
3287
#    define ETHR_HAVE_NATMC_AND_RETOLD_RB 1
 
3288
#  endif
 
3289
#  undef ETHR_HAVE_NATMC_AND_RETOLD_WB
 
3290
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_AND_RETOLD_WB
 
3291
#    define ETHR_HAVE_NATMC_AND_RETOLD_WB 1
 
3292
#  endif
 
3293
#  undef ETHR_HAVE_NATMC_AND_RETOLD_ACQB
 
3294
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_AND_RETOLD_ACQB
 
3295
#    define ETHR_HAVE_NATMC_AND_RETOLD_ACQB 1
 
3296
#  endif
 
3297
#  undef ETHR_HAVE_NATMC_AND_RETOLD_RELB
 
3298
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_AND_RETOLD_RELB
 
3299
#    define ETHR_HAVE_NATMC_AND_RETOLD_RELB 1
 
3300
#  endif
 
3301
#  undef ETHR_HAVE_NATMC_AND_RETOLD_MB
 
3302
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_AND_RETOLD_MB
 
3303
#    define ETHR_HAVE_NATMC_AND_RETOLD_MB 1
 
3304
#  endif
 
3305
#  undef ETHR_HAVE_NATMC_OR_RETOLD
 
3306
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_OR_RETOLD
 
3307
#    define ETHR_HAVE_NATMC_OR_RETOLD 1
 
3308
#  endif
 
3309
#  undef ETHR_HAVE_NATMC_OR_RETOLD_RB
 
3310
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_OR_RETOLD_RB
 
3311
#    define ETHR_HAVE_NATMC_OR_RETOLD_RB 1
 
3312
#  endif
 
3313
#  undef ETHR_HAVE_NATMC_OR_RETOLD_WB
 
3314
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_OR_RETOLD_WB
 
3315
#    define ETHR_HAVE_NATMC_OR_RETOLD_WB 1
 
3316
#  endif
 
3317
#  undef ETHR_HAVE_NATMC_OR_RETOLD_ACQB
 
3318
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_OR_RETOLD_ACQB
 
3319
#    define ETHR_HAVE_NATMC_OR_RETOLD_ACQB 1
 
3320
#  endif
 
3321
#  undef ETHR_HAVE_NATMC_OR_RETOLD_RELB
 
3322
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_OR_RETOLD_RELB
 
3323
#    define ETHR_HAVE_NATMC_OR_RETOLD_RELB 1
 
3324
#  endif
 
3325
#  undef ETHR_HAVE_NATMC_OR_RETOLD_MB
 
3326
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_OR_RETOLD_MB
 
3327
#    define ETHR_HAVE_NATMC_OR_RETOLD_MB 1
 
3328
#  endif
 
3329
#else
 
3330
#  error "Invalid native atomic size"
 
3331
#endif
 
3332
 
 
3333
#if (!defined(ETHR_HAVE_NATMC_CMPXCHG) \
 
3334
     && !defined(ETHR_HAVE_NATMC_CMPXCHG_RB) \
 
3335
     && !defined(ETHR_HAVE_NATMC_CMPXCHG_WB) \
 
3336
     && !defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB) \
 
3337
     && !defined(ETHR_HAVE_NATMC_CMPXCHG_RELB) \
 
3338
     && !defined(ETHR_HAVE_NATMC_CMPXCHG_MB))
 
3339
#  error "No native cmpxchg() op available"
 
3340
#endif
 
3341
 
 
3342
 
 
3343
/*
 
3344
 * Read op used together with cmpxchg() fallback when no native op present.
 
3345
 */
 
3346
#if defined(ETHR_HAVE_NATMC_READ)
 
3347
#define ETHR_NATMC_CMPXCHG_FALLBACK_READ__(VAR) \
 
3348
  ETHR_NATMC_FUNC__(read)(VAR)
 
3349
#elif defined(ETHR_HAVE_NATMC_READ_RB)
 
3350
#define ETHR_NATMC_CMPXCHG_FALLBACK_READ__(VAR) \
 
3351
  ETHR_NATMC_FUNC__(read_rb)(VAR)
 
3352
#elif defined(ETHR_HAVE_NATMC_READ_WB)
 
3353
#define ETHR_NATMC_CMPXCHG_FALLBACK_READ__(VAR) \
 
3354
  ETHR_NATMC_FUNC__(read_wb)(VAR)
 
3355
#elif defined(ETHR_HAVE_NATMC_READ_ACQB)
 
3356
#define ETHR_NATMC_CMPXCHG_FALLBACK_READ__(VAR) \
 
3357
  ETHR_NATMC_FUNC__(read_acqb)(VAR)
 
3358
#elif defined(ETHR_HAVE_NATMC_READ_RELB)
 
3359
#define ETHR_NATMC_CMPXCHG_FALLBACK_READ__(VAR) \
 
3360
  ETHR_NATMC_FUNC__(read_relb)(VAR)
 
3361
#elif defined(ETHR_HAVE_NATMC_READ_MB)
 
3362
#define ETHR_NATMC_CMPXCHG_FALLBACK_READ__(VAR) \
 
3363
  ETHR_NATMC_FUNC__(read_mb)(VAR)
 
3364
#else
 
3365
/*
 
3366
 * We have no native read() op; guess zero and then use the
 
3367
 * the atomics actual value returned from cmpxchg().
 
3368
 */
 
3369
#define ETHR_NATMC_CMPXCHG_FALLBACK_READ__(VAR) \
 
3370
  ((ETHR_NAINT_T__) 0)
 
3371
#endif
 
3372
 
 
3373
/*
 
3374
 * Native cmpxchg() fallback used when no native op present.
 
3375
 */
 
3376
#define ETHR_NATMC_CMPXCHG_FALLBACK__(CMPXCHG, VAR, AVAL, OPS) \
 
3377
do { \
 
3378
    ethr_sint_t AVAL; \
 
3379
    ETHR_NAINT_T__ new__, act__, exp__; \
 
3380
    act__ = ETHR_NATMC_CMPXCHG_FALLBACK_READ__(VAR); \
 
3381
    do { \
 
3382
        exp__ = act__; \
 
3383
        AVAL = (ethr_sint_t) act__; \
 
3384
        { OPS; } \
 
3385
        new__ = (ETHR_NAINT_T__) AVAL; \
 
3386
        act__ = CMPXCHG(VAR, new__, exp__); \
 
3387
    } while (__builtin_expect(act__ != exp__, 0)); \
 
3388
} while (0)
 
3389
 
 
3390
 
 
3391
 
 
3392
/* --- addr() --- */
 
3393
 
 
3394
static ETHR_INLINE ethr_sint_t *ETHR_ATMC_FUNC__(addr)(ethr_atomic_t *var)
 
3395
{
 
3396
    return (ethr_sint_t *) ETHR_NATMC_ADDR_FUNC__(var);
 
3397
 
 
3398
}
 
3399
 
 
3400
 
 
3401
/* --- cmpxchg() --- */
 
3402
 
 
3403
 
 
3404
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(cmpxchg)(ethr_atomic_t *var, ethr_sint_t val, ethr_sint_t old_val)
 
3405
{
 
3406
    ethr_sint_t res;
 
3407
#if defined(ETHR_HAVE_NATMC_CMPXCHG)
 
3408
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3409
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
3410
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_rb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3411
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
3412
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_wb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3413
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
3414
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_acqb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3415
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
3416
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_relb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3417
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
3418
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_mb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3419
#else
 
3420
#error "Missing implementation of ethr_atomic_cmpxchg()!"
 
3421
#endif
 
3422
    return res;
 
3423
}
 
3424
 
 
3425
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(cmpxchg_rb)(ethr_atomic_t *var, ethr_sint_t val, ethr_sint_t old_val)
 
3426
{
 
3427
    ethr_sint_t res;
 
3428
#if defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
3429
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_rb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3430
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
3431
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3432
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3433
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
3434
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_mb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3435
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
3436
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_wb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3437
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3438
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
3439
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_acqb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3440
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3441
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
3442
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_relb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3443
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3444
#else
 
3445
#error "Missing implementation of ethr_atomic_cmpxchg_rb()!"
 
3446
#endif
 
3447
    return res;
 
3448
}
 
3449
 
 
3450
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(cmpxchg_wb)(ethr_atomic_t *var, ethr_sint_t val, ethr_sint_t old_val)
 
3451
{
 
3452
    ethr_sint_t res;
 
3453
#if defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
3454
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_wb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3455
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
3456
    ETHR_MEMBAR(ETHR_StoreStore);
 
3457
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3458
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
3459
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_mb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3460
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
3461
    ETHR_MEMBAR(ETHR_StoreStore);
 
3462
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_rb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3463
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
3464
    ETHR_MEMBAR(ETHR_StoreStore);
 
3465
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_acqb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3466
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
3467
    ETHR_MEMBAR(ETHR_StoreStore);
 
3468
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_relb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3469
#else
 
3470
#error "Missing implementation of ethr_atomic_cmpxchg_wb()!"
 
3471
#endif
 
3472
    return res;
 
3473
}
 
3474
 
 
3475
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(cmpxchg_acqb)(ethr_atomic_t *var, ethr_sint_t val, ethr_sint_t old_val)
 
3476
{
 
3477
    ethr_sint_t res;
 
3478
#if defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
3479
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_acqb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3480
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
3481
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_rb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3482
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3483
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
3484
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3485
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3486
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
3487
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_mb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3488
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
3489
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_wb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3490
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3491
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
3492
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_relb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3493
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3494
#else
 
3495
#error "Missing implementation of ethr_atomic_cmpxchg_acqb()!"
 
3496
#endif
 
3497
    return res;
 
3498
}
 
3499
 
 
3500
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(cmpxchg_relb)(ethr_atomic_t *var, ethr_sint_t val, ethr_sint_t old_val)
 
3501
{
 
3502
    ethr_sint_t res;
 
3503
#if defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
3504
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_relb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3505
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
3506
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3507
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_wb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3508
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
3509
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3510
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3511
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
3512
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_mb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3513
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
3514
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3515
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_rb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3516
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
3517
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3518
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_acqb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3519
#else
 
3520
#error "Missing implementation of ethr_atomic_cmpxchg_relb()!"
 
3521
#endif
 
3522
    return res;
 
3523
}
 
3524
 
 
3525
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(cmpxchg_mb)(ethr_atomic_t *var, ethr_sint_t val, ethr_sint_t old_val)
 
3526
{
 
3527
    ethr_sint_t res;
 
3528
#if defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
3529
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_mb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3530
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
3531
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_relb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3532
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3533
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
3534
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3535
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_acqb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3536
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
3537
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3538
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_wb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3539
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3540
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
3541
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3542
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg_rb)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3543
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3544
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
3545
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3546
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(cmpxchg)(var, (ETHR_NAINT_T__) val, (ETHR_NAINT_T__) old_val);
 
3547
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3548
#else
 
3549
#error "Missing implementation of ethr_atomic_cmpxchg_mb()!"
 
3550
#endif
 
3551
    return res;
 
3552
}
 
3553
 
 
3554
 
 
3555
/* --- xchg() --- */
 
3556
 
 
3557
 
 
3558
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(xchg)(ethr_atomic_t *var, ethr_sint_t val)
 
3559
{
 
3560
    ethr_sint_t res;
 
3561
#if defined(ETHR_HAVE_NATMC_XCHG)
 
3562
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg)(var, (ETHR_NAINT_T__) val);
 
3563
#elif defined(ETHR_HAVE_NATMC_XCHG_RB)
 
3564
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_rb)(var, (ETHR_NAINT_T__) val);
 
3565
#elif defined(ETHR_HAVE_NATMC_XCHG_WB)
 
3566
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_wb)(var, (ETHR_NAINT_T__) val);
 
3567
#elif defined(ETHR_HAVE_NATMC_XCHG_ACQB)
 
3568
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_acqb)(var, (ETHR_NAINT_T__) val);
 
3569
#elif defined(ETHR_HAVE_NATMC_XCHG_RELB)
 
3570
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_relb)(var, (ETHR_NAINT_T__) val);
 
3571
#elif defined(ETHR_HAVE_NATMC_XCHG_MB)
 
3572
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_mb)(var, (ETHR_NAINT_T__) val);
 
3573
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
3574
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, res = aval; aval = val);
 
3575
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
3576
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, res = aval; aval = val);
 
3577
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
3578
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, res = aval; aval = val);
 
3579
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
3580
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval = val);
 
3581
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
3582
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, res = aval; aval = val);
 
3583
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
3584
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, res = aval; aval = val);
 
3585
#else
 
3586
#error "Missing implementation of ethr_atomic_xchg()!"
 
3587
#endif
 
3588
    return res;
 
3589
}
 
3590
 
 
3591
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(xchg_rb)(ethr_atomic_t *var, ethr_sint_t val)
 
3592
{
 
3593
    ethr_sint_t res;
 
3594
#if defined(ETHR_HAVE_NATMC_XCHG_RB)
 
3595
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_rb)(var, (ETHR_NAINT_T__) val);
 
3596
#elif defined(ETHR_HAVE_NATMC_XCHG)
 
3597
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg)(var, (ETHR_NAINT_T__) val);
 
3598
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3599
#elif defined(ETHR_HAVE_NATMC_XCHG_MB)
 
3600
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_mb)(var, (ETHR_NAINT_T__) val);
 
3601
#elif defined(ETHR_HAVE_NATMC_XCHG_WB)
 
3602
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_wb)(var, (ETHR_NAINT_T__) val);
 
3603
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3604
#elif defined(ETHR_HAVE_NATMC_XCHG_ACQB)
 
3605
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_acqb)(var, (ETHR_NAINT_T__) val);
 
3606
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3607
#elif defined(ETHR_HAVE_NATMC_XCHG_RELB)
 
3608
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_relb)(var, (ETHR_NAINT_T__) val);
 
3609
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3610
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
3611
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, res = aval; aval = val);
 
3612
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
3613
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, res = aval; aval = val);
 
3614
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3615
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
3616
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, res = aval; aval = val);
 
3617
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
3618
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, res = aval; aval = val);
 
3619
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3620
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
3621
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval = val);
 
3622
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3623
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
3624
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, res = aval; aval = val);
 
3625
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3626
#else
 
3627
#error "Missing implementation of ethr_atomic_xchg_rb()!"
 
3628
#endif
 
3629
    return res;
 
3630
}
 
3631
 
 
3632
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(xchg_wb)(ethr_atomic_t *var, ethr_sint_t val)
 
3633
{
 
3634
    ethr_sint_t res;
 
3635
#if defined(ETHR_HAVE_NATMC_XCHG_WB)
 
3636
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_wb)(var, (ETHR_NAINT_T__) val);
 
3637
#elif defined(ETHR_HAVE_NATMC_XCHG)
 
3638
    ETHR_MEMBAR(ETHR_StoreStore);
 
3639
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg)(var, (ETHR_NAINT_T__) val);
 
3640
#elif defined(ETHR_HAVE_NATMC_XCHG_MB)
 
3641
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_mb)(var, (ETHR_NAINT_T__) val);
 
3642
#elif defined(ETHR_HAVE_NATMC_XCHG_RB)
 
3643
    ETHR_MEMBAR(ETHR_StoreStore);
 
3644
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_rb)(var, (ETHR_NAINT_T__) val);
 
3645
#elif defined(ETHR_HAVE_NATMC_XCHG_ACQB)
 
3646
    ETHR_MEMBAR(ETHR_StoreStore);
 
3647
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_acqb)(var, (ETHR_NAINT_T__) val);
 
3648
#elif defined(ETHR_HAVE_NATMC_XCHG_RELB)
 
3649
    ETHR_MEMBAR(ETHR_StoreStore);
 
3650
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_relb)(var, (ETHR_NAINT_T__) val);
 
3651
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
3652
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, res = aval; aval = val);
 
3653
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
3654
    ETHR_MEMBAR(ETHR_StoreStore);
 
3655
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, res = aval; aval = val);
 
3656
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
3657
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, res = aval; aval = val);
 
3658
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
3659
    ETHR_MEMBAR(ETHR_StoreStore);
 
3660
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, res = aval; aval = val);
 
3661
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
3662
    ETHR_MEMBAR(ETHR_StoreStore);
 
3663
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval = val);
 
3664
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
3665
    ETHR_MEMBAR(ETHR_StoreStore);
 
3666
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, res = aval; aval = val);
 
3667
#else
 
3668
#error "Missing implementation of ethr_atomic_xchg_wb()!"
 
3669
#endif
 
3670
    return res;
 
3671
}
 
3672
 
 
3673
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(xchg_acqb)(ethr_atomic_t *var, ethr_sint_t val)
 
3674
{
 
3675
    ethr_sint_t res;
 
3676
#if defined(ETHR_HAVE_NATMC_XCHG_ACQB)
 
3677
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_acqb)(var, (ETHR_NAINT_T__) val);
 
3678
#elif defined(ETHR_HAVE_NATMC_XCHG_RB)
 
3679
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_rb)(var, (ETHR_NAINT_T__) val);
 
3680
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3681
#elif defined(ETHR_HAVE_NATMC_XCHG)
 
3682
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg)(var, (ETHR_NAINT_T__) val);
 
3683
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3684
#elif defined(ETHR_HAVE_NATMC_XCHG_MB)
 
3685
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_mb)(var, (ETHR_NAINT_T__) val);
 
3686
#elif defined(ETHR_HAVE_NATMC_XCHG_WB)
 
3687
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_wb)(var, (ETHR_NAINT_T__) val);
 
3688
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3689
#elif defined(ETHR_HAVE_NATMC_XCHG_RELB)
 
3690
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_relb)(var, (ETHR_NAINT_T__) val);
 
3691
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3692
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
3693
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval = val);
 
3694
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
3695
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, res = aval; aval = val);
 
3696
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3697
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
3698
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, res = aval; aval = val);
 
3699
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3700
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
3701
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, res = aval; aval = val);
 
3702
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
3703
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, res = aval; aval = val);
 
3704
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3705
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
3706
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, res = aval; aval = val);
 
3707
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3708
#else
 
3709
#error "Missing implementation of ethr_atomic_xchg_acqb()!"
 
3710
#endif
 
3711
    return res;
 
3712
}
 
3713
 
 
3714
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(xchg_relb)(ethr_atomic_t *var, ethr_sint_t val)
 
3715
{
 
3716
    ethr_sint_t res;
 
3717
#if defined(ETHR_HAVE_NATMC_XCHG_RELB)
 
3718
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_relb)(var, (ETHR_NAINT_T__) val);
 
3719
#elif defined(ETHR_HAVE_NATMC_XCHG_WB)
 
3720
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3721
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_wb)(var, (ETHR_NAINT_T__) val);
 
3722
#elif defined(ETHR_HAVE_NATMC_XCHG)
 
3723
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3724
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg)(var, (ETHR_NAINT_T__) val);
 
3725
#elif defined(ETHR_HAVE_NATMC_XCHG_MB)
 
3726
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_mb)(var, (ETHR_NAINT_T__) val);
 
3727
#elif defined(ETHR_HAVE_NATMC_XCHG_RB)
 
3728
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3729
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_rb)(var, (ETHR_NAINT_T__) val);
 
3730
#elif defined(ETHR_HAVE_NATMC_XCHG_ACQB)
 
3731
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3732
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_acqb)(var, (ETHR_NAINT_T__) val);
 
3733
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
3734
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, res = aval; aval = val);
 
3735
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
3736
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3737
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, res = aval; aval = val);
 
3738
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
3739
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3740
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, res = aval; aval = val);
 
3741
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
3742
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, res = aval; aval = val);
 
3743
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
3744
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3745
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, res = aval; aval = val);
 
3746
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
3747
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3748
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval = val);
 
3749
#else
 
3750
#error "Missing implementation of ethr_atomic_xchg_relb()!"
 
3751
#endif
 
3752
    return res;
 
3753
}
 
3754
 
 
3755
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(xchg_mb)(ethr_atomic_t *var, ethr_sint_t val)
 
3756
{
 
3757
    ethr_sint_t res;
 
3758
#if defined(ETHR_HAVE_NATMC_XCHG_MB)
 
3759
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_mb)(var, (ETHR_NAINT_T__) val);
 
3760
#elif defined(ETHR_HAVE_NATMC_XCHG_RELB)
 
3761
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_relb)(var, (ETHR_NAINT_T__) val);
 
3762
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3763
#elif defined(ETHR_HAVE_NATMC_XCHG_ACQB)
 
3764
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3765
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_acqb)(var, (ETHR_NAINT_T__) val);
 
3766
#elif defined(ETHR_HAVE_NATMC_XCHG_WB)
 
3767
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3768
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_wb)(var, (ETHR_NAINT_T__) val);
 
3769
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3770
#elif defined(ETHR_HAVE_NATMC_XCHG_RB)
 
3771
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3772
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg_rb)(var, (ETHR_NAINT_T__) val);
 
3773
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3774
#elif defined(ETHR_HAVE_NATMC_XCHG)
 
3775
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3776
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(xchg)(var, (ETHR_NAINT_T__) val);
 
3777
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3778
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
3779
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, res = aval; aval = val);
 
3780
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
3781
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, res = aval; aval = val);
 
3782
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3783
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
3784
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3785
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval = val);
 
3786
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
3787
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3788
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, res = aval; aval = val);
 
3789
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3790
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
3791
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3792
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, res = aval; aval = val);
 
3793
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3794
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
3795
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
3796
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, res = aval; aval = val);
 
3797
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
3798
#else
 
3799
#error "Missing implementation of ethr_atomic_xchg_mb()!"
 
3800
#endif
 
3801
    return res;
 
3802
}
 
3803
 
 
3804
 
 
3805
/* --- set() --- */
 
3806
 
 
3807
 
 
3808
static ETHR_INLINE void ETHR_ATMC_FUNC__(set)(ethr_atomic_t *var, ethr_sint_t val)
 
3809
{
 
3810
#if defined(ETHR_HAVE_NATMC_SET)
 
3811
    ETHR_NATMC_FUNC__(set)(var, (ETHR_NAINT_T__) val);
 
3812
#elif defined(ETHR_HAVE_NATMC_SET_RB)
 
3813
    ETHR_NATMC_FUNC__(set_rb)(var, (ETHR_NAINT_T__) val);
 
3814
#elif defined(ETHR_HAVE_NATMC_SET_WB)
 
3815
    ETHR_NATMC_FUNC__(set_wb)(var, (ETHR_NAINT_T__) val);
 
3816
#elif defined(ETHR_HAVE_NATMC_SET_ACQB)
 
3817
    ETHR_NATMC_FUNC__(set_acqb)(var, (ETHR_NAINT_T__) val);
 
3818
#elif defined(ETHR_HAVE_NATMC_SET_RELB)
 
3819
    ETHR_NATMC_FUNC__(set_relb)(var, (ETHR_NAINT_T__) val);
 
3820
#elif defined(ETHR_HAVE_NATMC_SET_MB)
 
3821
    ETHR_NATMC_FUNC__(set_mb)(var, (ETHR_NAINT_T__) val);
 
3822
#else
 
3823
    (void) ETHR_ATMC_FUNC__(xchg)(var, val);
 
3824
#endif
 
3825
}
 
3826
 
 
3827
static ETHR_INLINE void ETHR_ATMC_FUNC__(set_rb)(ethr_atomic_t *var, ethr_sint_t val)
 
3828
{
 
3829
#if defined(ETHR_HAVE_NATMC_SET_RB)
 
3830
    ETHR_NATMC_FUNC__(set_rb)(var, (ETHR_NAINT_T__) val);
 
3831
#elif defined(ETHR_HAVE_NATMC_SET)
 
3832
    ETHR_NATMC_FUNC__(set)(var, (ETHR_NAINT_T__) val);
 
3833
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3834
#elif defined(ETHR_HAVE_NATMC_SET_MB)
 
3835
    ETHR_NATMC_FUNC__(set_mb)(var, (ETHR_NAINT_T__) val);
 
3836
#elif defined(ETHR_HAVE_NATMC_SET_WB)
 
3837
    ETHR_NATMC_FUNC__(set_wb)(var, (ETHR_NAINT_T__) val);
 
3838
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3839
#elif defined(ETHR_HAVE_NATMC_SET_ACQB)
 
3840
    ETHR_NATMC_FUNC__(set_acqb)(var, (ETHR_NAINT_T__) val);
 
3841
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3842
#elif defined(ETHR_HAVE_NATMC_SET_RELB)
 
3843
    ETHR_NATMC_FUNC__(set_relb)(var, (ETHR_NAINT_T__) val);
 
3844
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3845
#else
 
3846
    (void) ETHR_ATMC_FUNC__(xchg_rb)(var, val);
 
3847
#endif
 
3848
}
 
3849
 
 
3850
static ETHR_INLINE void ETHR_ATMC_FUNC__(set_wb)(ethr_atomic_t *var, ethr_sint_t val)
 
3851
{
 
3852
#if defined(ETHR_HAVE_NATMC_SET_WB)
 
3853
    ETHR_NATMC_FUNC__(set_wb)(var, (ETHR_NAINT_T__) val);
 
3854
#elif defined(ETHR_HAVE_NATMC_SET)
 
3855
    ETHR_MEMBAR(ETHR_StoreStore);
 
3856
    ETHR_NATMC_FUNC__(set)(var, (ETHR_NAINT_T__) val);
 
3857
#elif defined(ETHR_HAVE_NATMC_SET_MB)
 
3858
    ETHR_NATMC_FUNC__(set_mb)(var, (ETHR_NAINT_T__) val);
 
3859
#elif defined(ETHR_HAVE_NATMC_SET_RB)
 
3860
    ETHR_MEMBAR(ETHR_StoreStore);
 
3861
    ETHR_NATMC_FUNC__(set_rb)(var, (ETHR_NAINT_T__) val);
 
3862
#elif defined(ETHR_HAVE_NATMC_SET_ACQB)
 
3863
    ETHR_MEMBAR(ETHR_StoreStore);
 
3864
    ETHR_NATMC_FUNC__(set_acqb)(var, (ETHR_NAINT_T__) val);
 
3865
#elif defined(ETHR_HAVE_NATMC_SET_RELB)
 
3866
    ETHR_MEMBAR(ETHR_StoreStore);
 
3867
    ETHR_NATMC_FUNC__(set_relb)(var, (ETHR_NAINT_T__) val);
 
3868
#else
 
3869
    (void) ETHR_ATMC_FUNC__(xchg_wb)(var, val);
 
3870
#endif
 
3871
}
 
3872
 
 
3873
static ETHR_INLINE void ETHR_ATMC_FUNC__(set_acqb)(ethr_atomic_t *var, ethr_sint_t val)
 
3874
{
 
3875
#if defined(ETHR_HAVE_NATMC_SET_ACQB)
 
3876
    ETHR_NATMC_FUNC__(set_acqb)(var, (ETHR_NAINT_T__) val);
 
3877
#elif defined(ETHR_HAVE_NATMC_SET_RB)
 
3878
    ETHR_NATMC_FUNC__(set_rb)(var, (ETHR_NAINT_T__) val);
 
3879
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
3880
#elif defined(ETHR_HAVE_NATMC_SET)
 
3881
    ETHR_NATMC_FUNC__(set)(var, (ETHR_NAINT_T__) val);
 
3882
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
3883
#elif defined(ETHR_HAVE_NATMC_SET_MB)
 
3884
    ETHR_NATMC_FUNC__(set_mb)(var, (ETHR_NAINT_T__) val);
 
3885
#elif defined(ETHR_HAVE_NATMC_SET_WB)
 
3886
    ETHR_NATMC_FUNC__(set_wb)(var, (ETHR_NAINT_T__) val);
 
3887
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
3888
#elif defined(ETHR_HAVE_NATMC_SET_RELB)
 
3889
    ETHR_NATMC_FUNC__(set_relb)(var, (ETHR_NAINT_T__) val);
 
3890
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
3891
#else
 
3892
    (void) ETHR_ATMC_FUNC__(xchg_acqb)(var, val);
 
3893
#endif
 
3894
}
 
3895
 
 
3896
static ETHR_INLINE void ETHR_ATMC_FUNC__(set_relb)(ethr_atomic_t *var, ethr_sint_t val)
 
3897
{
 
3898
#if defined(ETHR_HAVE_NATMC_SET_RELB)
 
3899
    ETHR_NATMC_FUNC__(set_relb)(var, (ETHR_NAINT_T__) val);
 
3900
#elif defined(ETHR_HAVE_NATMC_SET_WB)
 
3901
    ETHR_MEMBAR(ETHR_LoadStore);
 
3902
    ETHR_NATMC_FUNC__(set_wb)(var, (ETHR_NAINT_T__) val);
 
3903
#elif defined(ETHR_HAVE_NATMC_SET)
 
3904
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
3905
    ETHR_NATMC_FUNC__(set)(var, (ETHR_NAINT_T__) val);
 
3906
#elif defined(ETHR_HAVE_NATMC_SET_MB)
 
3907
    ETHR_NATMC_FUNC__(set_mb)(var, (ETHR_NAINT_T__) val);
 
3908
#elif defined(ETHR_HAVE_NATMC_SET_RB)
 
3909
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
3910
    ETHR_NATMC_FUNC__(set_rb)(var, (ETHR_NAINT_T__) val);
 
3911
#elif defined(ETHR_HAVE_NATMC_SET_ACQB)
 
3912
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
3913
    ETHR_NATMC_FUNC__(set_acqb)(var, (ETHR_NAINT_T__) val);
 
3914
#else
 
3915
    (void) ETHR_ATMC_FUNC__(xchg_relb)(var, val);
 
3916
#endif
 
3917
}
 
3918
 
 
3919
static ETHR_INLINE void ETHR_ATMC_FUNC__(set_mb)(ethr_atomic_t *var, ethr_sint_t val)
 
3920
{
 
3921
#if defined(ETHR_HAVE_NATMC_SET_MB)
 
3922
    ETHR_NATMC_FUNC__(set_mb)(var, (ETHR_NAINT_T__) val);
 
3923
#elif defined(ETHR_HAVE_NATMC_SET_RELB)
 
3924
    ETHR_NATMC_FUNC__(set_relb)(var, (ETHR_NAINT_T__) val);
 
3925
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
3926
#elif defined(ETHR_HAVE_NATMC_SET_ACQB)
 
3927
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
3928
    ETHR_NATMC_FUNC__(set_acqb)(var, (ETHR_NAINT_T__) val);
 
3929
#elif defined(ETHR_HAVE_NATMC_SET_WB)
 
3930
    ETHR_MEMBAR(ETHR_LoadStore);
 
3931
    ETHR_NATMC_FUNC__(set_wb)(var, (ETHR_NAINT_T__) val);
 
3932
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
3933
#elif defined(ETHR_HAVE_NATMC_SET_RB)
 
3934
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
3935
    ETHR_NATMC_FUNC__(set_rb)(var, (ETHR_NAINT_T__) val);
 
3936
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
3937
#elif defined(ETHR_HAVE_NATMC_SET)
 
3938
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
3939
    ETHR_NATMC_FUNC__(set)(var, (ETHR_NAINT_T__) val);
 
3940
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
3941
#else
 
3942
    (void) ETHR_ATMC_FUNC__(xchg_mb)(var, val);
 
3943
#endif
 
3944
}
 
3945
 
 
3946
 
 
3947
/* --- init() --- */
 
3948
 
 
3949
 
 
3950
static ETHR_INLINE void ETHR_ATMC_FUNC__(init)(ethr_atomic_t *var, ethr_sint_t val)
 
3951
{
 
3952
#if defined(ETHR_HAVE_NATMC_INIT)
 
3953
    ETHR_NATMC_FUNC__(init)(var, (ETHR_NAINT_T__) val);
 
3954
#elif defined(ETHR_HAVE_NATMC_INIT_RB)
 
3955
    ETHR_NATMC_FUNC__(init_rb)(var, (ETHR_NAINT_T__) val);
 
3956
#elif defined(ETHR_HAVE_NATMC_INIT_WB)
 
3957
    ETHR_NATMC_FUNC__(init_wb)(var, (ETHR_NAINT_T__) val);
 
3958
#elif defined(ETHR_HAVE_NATMC_INIT_ACQB)
 
3959
    ETHR_NATMC_FUNC__(init_acqb)(var, (ETHR_NAINT_T__) val);
 
3960
#elif defined(ETHR_HAVE_NATMC_INIT_RELB)
 
3961
    ETHR_NATMC_FUNC__(init_relb)(var, (ETHR_NAINT_T__) val);
 
3962
#elif defined(ETHR_HAVE_NATMC_INIT_MB)
 
3963
    ETHR_NATMC_FUNC__(init_mb)(var, (ETHR_NAINT_T__) val);
 
3964
#else
 
3965
    ETHR_ATMC_FUNC__(set)(var, val);
 
3966
#endif
 
3967
}
 
3968
 
 
3969
static ETHR_INLINE void ETHR_ATMC_FUNC__(init_rb)(ethr_atomic_t *var, ethr_sint_t val)
 
3970
{
 
3971
#if defined(ETHR_HAVE_NATMC_INIT_RB)
 
3972
    ETHR_NATMC_FUNC__(init_rb)(var, (ETHR_NAINT_T__) val);
 
3973
#elif defined(ETHR_HAVE_NATMC_INIT)
 
3974
    ETHR_NATMC_FUNC__(init)(var, (ETHR_NAINT_T__) val);
 
3975
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3976
#elif defined(ETHR_HAVE_NATMC_INIT_MB)
 
3977
    ETHR_NATMC_FUNC__(init_mb)(var, (ETHR_NAINT_T__) val);
 
3978
#elif defined(ETHR_HAVE_NATMC_INIT_WB)
 
3979
    ETHR_NATMC_FUNC__(init_wb)(var, (ETHR_NAINT_T__) val);
 
3980
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3981
#elif defined(ETHR_HAVE_NATMC_INIT_ACQB)
 
3982
    ETHR_NATMC_FUNC__(init_acqb)(var, (ETHR_NAINT_T__) val);
 
3983
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3984
#elif defined(ETHR_HAVE_NATMC_INIT_RELB)
 
3985
    ETHR_NATMC_FUNC__(init_relb)(var, (ETHR_NAINT_T__) val);
 
3986
    ETHR_MEMBAR(ETHR_LoadLoad);
 
3987
#else
 
3988
    ETHR_ATMC_FUNC__(set_rb)(var, val);
 
3989
#endif
 
3990
}
 
3991
 
 
3992
static ETHR_INLINE void ETHR_ATMC_FUNC__(init_wb)(ethr_atomic_t *var, ethr_sint_t val)
 
3993
{
 
3994
#if defined(ETHR_HAVE_NATMC_INIT_WB)
 
3995
    ETHR_NATMC_FUNC__(init_wb)(var, (ETHR_NAINT_T__) val);
 
3996
#elif defined(ETHR_HAVE_NATMC_INIT)
 
3997
    ETHR_MEMBAR(ETHR_StoreStore);
 
3998
    ETHR_NATMC_FUNC__(init)(var, (ETHR_NAINT_T__) val);
 
3999
#elif defined(ETHR_HAVE_NATMC_INIT_MB)
 
4000
    ETHR_NATMC_FUNC__(init_mb)(var, (ETHR_NAINT_T__) val);
 
4001
#elif defined(ETHR_HAVE_NATMC_INIT_RB)
 
4002
    ETHR_MEMBAR(ETHR_StoreStore);
 
4003
    ETHR_NATMC_FUNC__(init_rb)(var, (ETHR_NAINT_T__) val);
 
4004
#elif defined(ETHR_HAVE_NATMC_INIT_ACQB)
 
4005
    ETHR_MEMBAR(ETHR_StoreStore);
 
4006
    ETHR_NATMC_FUNC__(init_acqb)(var, (ETHR_NAINT_T__) val);
 
4007
#elif defined(ETHR_HAVE_NATMC_INIT_RELB)
 
4008
    ETHR_MEMBAR(ETHR_StoreStore);
 
4009
    ETHR_NATMC_FUNC__(init_relb)(var, (ETHR_NAINT_T__) val);
 
4010
#else
 
4011
    ETHR_ATMC_FUNC__(set_wb)(var, val);
 
4012
#endif
 
4013
}
 
4014
 
 
4015
static ETHR_INLINE void ETHR_ATMC_FUNC__(init_acqb)(ethr_atomic_t *var, ethr_sint_t val)
 
4016
{
 
4017
#if defined(ETHR_HAVE_NATMC_INIT_ACQB)
 
4018
    ETHR_NATMC_FUNC__(init_acqb)(var, (ETHR_NAINT_T__) val);
 
4019
#elif defined(ETHR_HAVE_NATMC_INIT_RB)
 
4020
    ETHR_NATMC_FUNC__(init_rb)(var, (ETHR_NAINT_T__) val);
 
4021
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4022
#elif defined(ETHR_HAVE_NATMC_INIT)
 
4023
    ETHR_NATMC_FUNC__(init)(var, (ETHR_NAINT_T__) val);
 
4024
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4025
#elif defined(ETHR_HAVE_NATMC_INIT_MB)
 
4026
    ETHR_NATMC_FUNC__(init_mb)(var, (ETHR_NAINT_T__) val);
 
4027
#elif defined(ETHR_HAVE_NATMC_INIT_WB)
 
4028
    ETHR_NATMC_FUNC__(init_wb)(var, (ETHR_NAINT_T__) val);
 
4029
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4030
#elif defined(ETHR_HAVE_NATMC_INIT_RELB)
 
4031
    ETHR_NATMC_FUNC__(init_relb)(var, (ETHR_NAINT_T__) val);
 
4032
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4033
#else
 
4034
    ETHR_ATMC_FUNC__(set_acqb)(var, val);
 
4035
#endif
 
4036
}
 
4037
 
 
4038
static ETHR_INLINE void ETHR_ATMC_FUNC__(init_relb)(ethr_atomic_t *var, ethr_sint_t val)
 
4039
{
 
4040
#if defined(ETHR_HAVE_NATMC_INIT_RELB)
 
4041
    ETHR_NATMC_FUNC__(init_relb)(var, (ETHR_NAINT_T__) val);
 
4042
#elif defined(ETHR_HAVE_NATMC_INIT_WB)
 
4043
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad);
 
4044
    ETHR_NATMC_FUNC__(init_wb)(var, (ETHR_NAINT_T__) val);
 
4045
#elif defined(ETHR_HAVE_NATMC_INIT)
 
4046
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4047
    ETHR_NATMC_FUNC__(init)(var, (ETHR_NAINT_T__) val);
 
4048
#elif defined(ETHR_HAVE_NATMC_INIT_MB)
 
4049
    ETHR_NATMC_FUNC__(init_mb)(var, (ETHR_NAINT_T__) val);
 
4050
#elif defined(ETHR_HAVE_NATMC_INIT_RB)
 
4051
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4052
    ETHR_NATMC_FUNC__(init_rb)(var, (ETHR_NAINT_T__) val);
 
4053
#elif defined(ETHR_HAVE_NATMC_INIT_ACQB)
 
4054
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4055
    ETHR_NATMC_FUNC__(init_acqb)(var, (ETHR_NAINT_T__) val);
 
4056
#else
 
4057
    ETHR_ATMC_FUNC__(set_relb)(var, val);
 
4058
#endif
 
4059
}
 
4060
 
 
4061
static ETHR_INLINE void ETHR_ATMC_FUNC__(init_mb)(ethr_atomic_t *var, ethr_sint_t val)
 
4062
{
 
4063
#if defined(ETHR_HAVE_NATMC_INIT_MB)
 
4064
    ETHR_NATMC_FUNC__(init_mb)(var, (ETHR_NAINT_T__) val);
 
4065
#elif defined(ETHR_HAVE_NATMC_INIT_RELB)
 
4066
    ETHR_NATMC_FUNC__(init_relb)(var, (ETHR_NAINT_T__) val);
 
4067
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4068
#elif defined(ETHR_HAVE_NATMC_INIT_ACQB)
 
4069
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4070
    ETHR_NATMC_FUNC__(init_acqb)(var, (ETHR_NAINT_T__) val);
 
4071
#elif defined(ETHR_HAVE_NATMC_INIT_WB)
 
4072
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad);
 
4073
    ETHR_NATMC_FUNC__(init_wb)(var, (ETHR_NAINT_T__) val);
 
4074
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4075
#elif defined(ETHR_HAVE_NATMC_INIT_RB)
 
4076
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4077
    ETHR_NATMC_FUNC__(init_rb)(var, (ETHR_NAINT_T__) val);
 
4078
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4079
#elif defined(ETHR_HAVE_NATMC_INIT)
 
4080
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4081
    ETHR_NATMC_FUNC__(init)(var, (ETHR_NAINT_T__) val);
 
4082
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4083
#else
 
4084
    ETHR_ATMC_FUNC__(set_mb)(var, val);
 
4085
#endif
 
4086
}
 
4087
 
 
4088
 
 
4089
/* --- add_read() --- */
 
4090
 
 
4091
 
 
4092
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(add_read)(ethr_atomic_t *var, ethr_sint_t val)
 
4093
{
 
4094
    ethr_sint_t res;
 
4095
#if defined(ETHR_HAVE_NATMC_ADD_RETURN)
 
4096
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return)(var, (ETHR_NAINT_T__) val);
 
4097
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_RB)
 
4098
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_rb)(var, (ETHR_NAINT_T__) val);
 
4099
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_WB)
 
4100
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_wb)(var, (ETHR_NAINT_T__) val);
 
4101
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_ACQB)
 
4102
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_acqb)(var, (ETHR_NAINT_T__) val);
 
4103
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_RELB)
 
4104
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_relb)(var, (ETHR_NAINT_T__) val);
 
4105
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_MB)
 
4106
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_mb)(var, (ETHR_NAINT_T__) val);
 
4107
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
4108
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, aval += val; res = aval);
 
4109
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
4110
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, aval += val; res = aval);
 
4111
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
4112
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, aval += val; res = aval);
 
4113
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
4114
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, aval += val; res = aval);
 
4115
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
4116
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, aval += val; res = aval);
 
4117
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
4118
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, aval += val; res = aval);
 
4119
#else
 
4120
#error "Missing implementation of ethr_atomic_add_read()!"
 
4121
#endif
 
4122
    return res;
 
4123
}
 
4124
 
 
4125
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(add_read_rb)(ethr_atomic_t *var, ethr_sint_t val)
 
4126
{
 
4127
    ethr_sint_t res;
 
4128
#if defined(ETHR_HAVE_NATMC_ADD_RETURN_RB)
 
4129
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_rb)(var, (ETHR_NAINT_T__) val);
 
4130
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN)
 
4131
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return)(var, (ETHR_NAINT_T__) val);
 
4132
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4133
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_MB)
 
4134
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_mb)(var, (ETHR_NAINT_T__) val);
 
4135
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_WB)
 
4136
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_wb)(var, (ETHR_NAINT_T__) val);
 
4137
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4138
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_ACQB)
 
4139
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_acqb)(var, (ETHR_NAINT_T__) val);
 
4140
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4141
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_RELB)
 
4142
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_relb)(var, (ETHR_NAINT_T__) val);
 
4143
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4144
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
4145
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, aval += val; res = aval);
 
4146
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
4147
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, aval += val; res = aval);
 
4148
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4149
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
4150
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, aval += val; res = aval);
 
4151
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
4152
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, aval += val; res = aval);
 
4153
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4154
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
4155
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, aval += val; res = aval);
 
4156
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4157
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
4158
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, aval += val; res = aval);
 
4159
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4160
#else
 
4161
#error "Missing implementation of ethr_atomic_add_read_rb()!"
 
4162
#endif
 
4163
    return res;
 
4164
}
 
4165
 
 
4166
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(add_read_wb)(ethr_atomic_t *var, ethr_sint_t val)
 
4167
{
 
4168
    ethr_sint_t res;
 
4169
#if defined(ETHR_HAVE_NATMC_ADD_RETURN_WB)
 
4170
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_wb)(var, (ETHR_NAINT_T__) val);
 
4171
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN)
 
4172
    ETHR_MEMBAR(ETHR_StoreStore);
 
4173
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return)(var, (ETHR_NAINT_T__) val);
 
4174
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_MB)
 
4175
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_mb)(var, (ETHR_NAINT_T__) val);
 
4176
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_RB)
 
4177
    ETHR_MEMBAR(ETHR_StoreStore);
 
4178
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_rb)(var, (ETHR_NAINT_T__) val);
 
4179
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_ACQB)
 
4180
    ETHR_MEMBAR(ETHR_StoreStore);
 
4181
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_acqb)(var, (ETHR_NAINT_T__) val);
 
4182
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_RELB)
 
4183
    ETHR_MEMBAR(ETHR_StoreStore);
 
4184
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_relb)(var, (ETHR_NAINT_T__) val);
 
4185
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
4186
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, aval += val; res = aval);
 
4187
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
4188
    ETHR_MEMBAR(ETHR_StoreStore);
 
4189
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, aval += val; res = aval);
 
4190
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
4191
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, aval += val; res = aval);
 
4192
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
4193
    ETHR_MEMBAR(ETHR_StoreStore);
 
4194
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, aval += val; res = aval);
 
4195
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
4196
    ETHR_MEMBAR(ETHR_StoreStore);
 
4197
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, aval += val; res = aval);
 
4198
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
4199
    ETHR_MEMBAR(ETHR_StoreStore);
 
4200
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, aval += val; res = aval);
 
4201
#else
 
4202
#error "Missing implementation of ethr_atomic_add_read_wb()!"
 
4203
#endif
 
4204
    return res;
 
4205
}
 
4206
 
 
4207
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(add_read_acqb)(ethr_atomic_t *var, ethr_sint_t val)
 
4208
{
 
4209
    ethr_sint_t res;
 
4210
#if defined(ETHR_HAVE_NATMC_ADD_RETURN_ACQB)
 
4211
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_acqb)(var, (ETHR_NAINT_T__) val);
 
4212
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_RB)
 
4213
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_rb)(var, (ETHR_NAINT_T__) val);
 
4214
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4215
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN)
 
4216
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return)(var, (ETHR_NAINT_T__) val);
 
4217
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4218
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_MB)
 
4219
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_mb)(var, (ETHR_NAINT_T__) val);
 
4220
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_WB)
 
4221
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_wb)(var, (ETHR_NAINT_T__) val);
 
4222
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4223
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_RELB)
 
4224
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_relb)(var, (ETHR_NAINT_T__) val);
 
4225
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4226
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
4227
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, aval += val; res = aval);
 
4228
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
4229
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, aval += val; res = aval);
 
4230
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4231
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
4232
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, aval += val; res = aval);
 
4233
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4234
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
4235
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, aval += val; res = aval);
 
4236
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
4237
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, aval += val; res = aval);
 
4238
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4239
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
4240
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, aval += val; res = aval);
 
4241
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4242
#else
 
4243
#error "Missing implementation of ethr_atomic_add_read_acqb()!"
 
4244
#endif
 
4245
    return res;
 
4246
}
 
4247
 
 
4248
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(add_read_relb)(ethr_atomic_t *var, ethr_sint_t val)
 
4249
{
 
4250
    ethr_sint_t res;
 
4251
#if defined(ETHR_HAVE_NATMC_ADD_RETURN_RELB)
 
4252
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_relb)(var, (ETHR_NAINT_T__) val);
 
4253
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_WB)
 
4254
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4255
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_wb)(var, (ETHR_NAINT_T__) val);
 
4256
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN)
 
4257
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4258
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return)(var, (ETHR_NAINT_T__) val);
 
4259
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_MB)
 
4260
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_mb)(var, (ETHR_NAINT_T__) val);
 
4261
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_RB)
 
4262
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4263
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_rb)(var, (ETHR_NAINT_T__) val);
 
4264
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_ACQB)
 
4265
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4266
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_acqb)(var, (ETHR_NAINT_T__) val);
 
4267
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
4268
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, aval += val; res = aval);
 
4269
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
4270
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4271
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, aval += val; res = aval);
 
4272
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
4273
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4274
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, aval += val; res = aval);
 
4275
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
4276
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, aval += val; res = aval);
 
4277
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
4278
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4279
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, aval += val; res = aval);
 
4280
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
4281
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4282
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, aval += val; res = aval);
 
4283
#else
 
4284
#error "Missing implementation of ethr_atomic_add_read_relb()!"
 
4285
#endif
 
4286
    return res;
 
4287
}
 
4288
 
 
4289
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(add_read_mb)(ethr_atomic_t *var, ethr_sint_t val)
 
4290
{
 
4291
    ethr_sint_t res;
 
4292
#if defined(ETHR_HAVE_NATMC_ADD_RETURN_MB)
 
4293
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_mb)(var, (ETHR_NAINT_T__) val);
 
4294
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_RELB)
 
4295
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_relb)(var, (ETHR_NAINT_T__) val);
 
4296
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4297
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_ACQB)
 
4298
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4299
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_acqb)(var, (ETHR_NAINT_T__) val);
 
4300
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_WB)
 
4301
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4302
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_wb)(var, (ETHR_NAINT_T__) val);
 
4303
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4304
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN_RB)
 
4305
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4306
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return_rb)(var, (ETHR_NAINT_T__) val);
 
4307
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4308
#elif defined(ETHR_HAVE_NATMC_ADD_RETURN)
 
4309
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4310
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(add_return)(var, (ETHR_NAINT_T__) val);
 
4311
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4312
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
4313
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, aval += val; res = aval);
 
4314
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
4315
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, aval += val; res = aval);
 
4316
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4317
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
4318
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4319
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, aval += val; res = aval);
 
4320
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
4321
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4322
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, aval += val; res = aval);
 
4323
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4324
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
4325
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4326
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, aval += val; res = aval);
 
4327
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4328
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
4329
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4330
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, aval += val; res = aval);
 
4331
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4332
#else
 
4333
#error "Missing implementation of ethr_atomic_add_read_mb()!"
 
4334
#endif
 
4335
    return res;
 
4336
}
 
4337
 
 
4338
 
 
4339
/* --- read() --- */
 
4340
 
 
4341
 
 
4342
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(read)(ethr_atomic_t *var)
 
4343
{
 
4344
    ethr_sint_t res;
 
4345
#if defined(ETHR_HAVE_NATMC_READ)
 
4346
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read)(var);
 
4347
#elif defined(ETHR_HAVE_NATMC_READ_RB)
 
4348
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_rb)(var);
 
4349
#elif defined(ETHR_HAVE_NATMC_READ_WB)
 
4350
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_wb)(var);
 
4351
#elif defined(ETHR_HAVE_NATMC_READ_ACQB)
 
4352
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_acqb)(var);
 
4353
#elif defined(ETHR_HAVE_NATMC_READ_RELB)
 
4354
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_relb)(var);
 
4355
#elif defined(ETHR_HAVE_NATMC_READ_MB)
 
4356
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_mb)(var);
 
4357
#else
 
4358
    res = ETHR_ATMC_FUNC__(cmpxchg)(var, (ethr_sint_t) ETHR_UNUSUAL_SINT_VAL__, (ethr_sint_t) ETHR_UNUSUAL_SINT_VAL__);
 
4359
#endif
 
4360
    return res;
 
4361
}
 
4362
 
 
4363
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(read_rb)(ethr_atomic_t *var)
 
4364
{
 
4365
    ethr_sint_t res;
 
4366
#if defined(ETHR_HAVE_NATMC_READ_RB)
 
4367
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_rb)(var);
 
4368
#elif defined(ETHR_HAVE_NATMC_READ)
 
4369
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read)(var);
 
4370
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4371
#elif defined(ETHR_HAVE_NATMC_READ_MB)
 
4372
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_mb)(var);
 
4373
#elif defined(ETHR_HAVE_NATMC_READ_WB)
 
4374
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_wb)(var);
 
4375
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4376
#elif defined(ETHR_HAVE_NATMC_READ_ACQB)
 
4377
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_acqb)(var);
 
4378
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4379
#elif defined(ETHR_HAVE_NATMC_READ_RELB)
 
4380
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_relb)(var);
 
4381
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4382
#else
 
4383
    res = ETHR_ATMC_FUNC__(cmpxchg_rb)(var, (ethr_sint_t) ETHR_UNUSUAL_SINT_VAL__, (ethr_sint_t) ETHR_UNUSUAL_SINT_VAL__);
 
4384
#endif
 
4385
    return res;
 
4386
}
 
4387
 
 
4388
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(read_wb)(ethr_atomic_t *var)
 
4389
{
 
4390
    ethr_sint_t res;
 
4391
#if defined(ETHR_HAVE_NATMC_READ_WB)
 
4392
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_wb)(var);
 
4393
#elif defined(ETHR_HAVE_NATMC_READ)
 
4394
    ETHR_MEMBAR(ETHR_StoreStore);
 
4395
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read)(var);
 
4396
#elif defined(ETHR_HAVE_NATMC_READ_MB)
 
4397
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_mb)(var);
 
4398
#elif defined(ETHR_HAVE_NATMC_READ_RB)
 
4399
    ETHR_MEMBAR(ETHR_StoreStore);
 
4400
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_rb)(var);
 
4401
#elif defined(ETHR_HAVE_NATMC_READ_ACQB)
 
4402
    ETHR_MEMBAR(ETHR_StoreStore);
 
4403
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_acqb)(var);
 
4404
#elif defined(ETHR_HAVE_NATMC_READ_RELB)
 
4405
    ETHR_MEMBAR(ETHR_StoreStore);
 
4406
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_relb)(var);
 
4407
#else
 
4408
    res = ETHR_ATMC_FUNC__(cmpxchg_wb)(var, (ethr_sint_t) ETHR_UNUSUAL_SINT_VAL__, (ethr_sint_t) ETHR_UNUSUAL_SINT_VAL__);
 
4409
#endif
 
4410
    return res;
 
4411
}
 
4412
 
 
4413
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(read_acqb)(ethr_atomic_t *var)
 
4414
{
 
4415
    ethr_sint_t res;
 
4416
#if defined(ETHR_HAVE_NATMC_READ_ACQB)
 
4417
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_acqb)(var);
 
4418
#elif defined(ETHR_HAVE_NATMC_READ_RB)
 
4419
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_rb)(var);
 
4420
    ETHR_MEMBAR(ETHR_LoadStore);
 
4421
#elif defined(ETHR_HAVE_NATMC_READ)
 
4422
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read)(var);
 
4423
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
4424
#elif defined(ETHR_HAVE_NATMC_READ_MB)
 
4425
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_mb)(var);
 
4426
#elif defined(ETHR_HAVE_NATMC_READ_WB)
 
4427
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_wb)(var);
 
4428
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
4429
#elif defined(ETHR_HAVE_NATMC_READ_RELB)
 
4430
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_relb)(var);
 
4431
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
4432
#else
 
4433
    res = ETHR_ATMC_FUNC__(cmpxchg_acqb)(var, (ethr_sint_t) ETHR_UNUSUAL_SINT_VAL__, (ethr_sint_t) ETHR_UNUSUAL_SINT_VAL__);
 
4434
#endif
 
4435
    return res;
 
4436
}
 
4437
 
 
4438
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(read_relb)(ethr_atomic_t *var)
 
4439
{
 
4440
    ethr_sint_t res;
 
4441
#if defined(ETHR_HAVE_NATMC_READ_RELB)
 
4442
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_relb)(var);
 
4443
#elif defined(ETHR_HAVE_NATMC_READ_WB)
 
4444
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4445
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_wb)(var);
 
4446
#elif defined(ETHR_HAVE_NATMC_READ)
 
4447
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4448
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read)(var);
 
4449
#elif defined(ETHR_HAVE_NATMC_READ_MB)
 
4450
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_mb)(var);
 
4451
#elif defined(ETHR_HAVE_NATMC_READ_RB)
 
4452
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4453
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_rb)(var);
 
4454
#elif defined(ETHR_HAVE_NATMC_READ_ACQB)
 
4455
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4456
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_acqb)(var);
 
4457
#else
 
4458
    res = ETHR_ATMC_FUNC__(cmpxchg_relb)(var, (ethr_sint_t) ETHR_UNUSUAL_SINT_VAL__, (ethr_sint_t) ETHR_UNUSUAL_SINT_VAL__);
 
4459
#endif
 
4460
    return res;
 
4461
}
 
4462
 
 
4463
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(read_mb)(ethr_atomic_t *var)
 
4464
{
 
4465
    ethr_sint_t res;
 
4466
#if defined(ETHR_HAVE_NATMC_READ_MB)
 
4467
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_mb)(var);
 
4468
#elif defined(ETHR_HAVE_NATMC_READ_RELB)
 
4469
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_relb)(var);
 
4470
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
4471
#elif defined(ETHR_HAVE_NATMC_READ_ACQB)
 
4472
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4473
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_acqb)(var);
 
4474
#elif defined(ETHR_HAVE_NATMC_READ_WB)
 
4475
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4476
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_wb)(var);
 
4477
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
4478
#elif defined(ETHR_HAVE_NATMC_READ_RB)
 
4479
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4480
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read_rb)(var);
 
4481
    ETHR_MEMBAR(ETHR_LoadStore);
 
4482
#elif defined(ETHR_HAVE_NATMC_READ)
 
4483
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4484
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(read)(var);
 
4485
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
4486
#else
 
4487
    res = ETHR_ATMC_FUNC__(cmpxchg_mb)(var, (ethr_sint_t) ETHR_UNUSUAL_SINT_VAL__, (ethr_sint_t) ETHR_UNUSUAL_SINT_VAL__);
 
4488
#endif
 
4489
    return res;
 
4490
}
 
4491
 
 
4492
 
 
4493
/* --- inc_read() --- */
 
4494
 
 
4495
 
 
4496
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(inc_read)(ethr_atomic_t *var)
 
4497
{
 
4498
    ethr_sint_t res;
 
4499
#if defined(ETHR_HAVE_NATMC_INC_RETURN)
 
4500
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return)(var);
 
4501
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_RB)
 
4502
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_rb)(var);
 
4503
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_WB)
 
4504
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_wb)(var);
 
4505
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_ACQB)
 
4506
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_acqb)(var);
 
4507
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_RELB)
 
4508
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_relb)(var);
 
4509
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_MB)
 
4510
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_mb)(var);
 
4511
#else
 
4512
    res = ETHR_ATMC_FUNC__(add_read)(var, (ethr_sint_t) 1);
 
4513
#endif
 
4514
    return res;
 
4515
}
 
4516
 
 
4517
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(inc_read_rb)(ethr_atomic_t *var)
 
4518
{
 
4519
    ethr_sint_t res;
 
4520
#if defined(ETHR_HAVE_NATMC_INC_RETURN_RB)
 
4521
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_rb)(var);
 
4522
#elif defined(ETHR_HAVE_NATMC_INC_RETURN)
 
4523
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return)(var);
 
4524
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4525
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_MB)
 
4526
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_mb)(var);
 
4527
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_WB)
 
4528
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_wb)(var);
 
4529
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4530
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_ACQB)
 
4531
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_acqb)(var);
 
4532
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4533
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_RELB)
 
4534
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_relb)(var);
 
4535
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4536
#else
 
4537
    res = ETHR_ATMC_FUNC__(add_read_rb)(var, (ethr_sint_t) 1);
 
4538
#endif
 
4539
    return res;
 
4540
}
 
4541
 
 
4542
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(inc_read_wb)(ethr_atomic_t *var)
 
4543
{
 
4544
    ethr_sint_t res;
 
4545
#if defined(ETHR_HAVE_NATMC_INC_RETURN_WB)
 
4546
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_wb)(var);
 
4547
#elif defined(ETHR_HAVE_NATMC_INC_RETURN)
 
4548
    ETHR_MEMBAR(ETHR_StoreStore);
 
4549
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return)(var);
 
4550
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_MB)
 
4551
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_mb)(var);
 
4552
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_RB)
 
4553
    ETHR_MEMBAR(ETHR_StoreStore);
 
4554
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_rb)(var);
 
4555
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_ACQB)
 
4556
    ETHR_MEMBAR(ETHR_StoreStore);
 
4557
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_acqb)(var);
 
4558
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_RELB)
 
4559
    ETHR_MEMBAR(ETHR_StoreStore);
 
4560
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_relb)(var);
 
4561
#else
 
4562
    res = ETHR_ATMC_FUNC__(add_read_wb)(var, (ethr_sint_t) 1);
 
4563
#endif
 
4564
    return res;
 
4565
}
 
4566
 
 
4567
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(inc_read_acqb)(ethr_atomic_t *var)
 
4568
{
 
4569
    ethr_sint_t res;
 
4570
#if defined(ETHR_HAVE_NATMC_INC_RETURN_ACQB)
 
4571
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_acqb)(var);
 
4572
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_RB)
 
4573
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_rb)(var);
 
4574
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4575
#elif defined(ETHR_HAVE_NATMC_INC_RETURN)
 
4576
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return)(var);
 
4577
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4578
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_MB)
 
4579
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_mb)(var);
 
4580
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_WB)
 
4581
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_wb)(var);
 
4582
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4583
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_RELB)
 
4584
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_relb)(var);
 
4585
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4586
#else
 
4587
    res = ETHR_ATMC_FUNC__(add_read_acqb)(var, (ethr_sint_t) 1);
 
4588
#endif
 
4589
    return res;
 
4590
}
 
4591
 
 
4592
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(inc_read_relb)(ethr_atomic_t *var)
 
4593
{
 
4594
    ethr_sint_t res;
 
4595
#if defined(ETHR_HAVE_NATMC_INC_RETURN_RELB)
 
4596
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_relb)(var);
 
4597
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_WB)
 
4598
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4599
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_wb)(var);
 
4600
#elif defined(ETHR_HAVE_NATMC_INC_RETURN)
 
4601
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4602
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return)(var);
 
4603
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_MB)
 
4604
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_mb)(var);
 
4605
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_RB)
 
4606
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4607
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_rb)(var);
 
4608
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_ACQB)
 
4609
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4610
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_acqb)(var);
 
4611
#else
 
4612
    res = ETHR_ATMC_FUNC__(add_read_relb)(var, (ethr_sint_t) 1);
 
4613
#endif
 
4614
    return res;
 
4615
}
 
4616
 
 
4617
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(inc_read_mb)(ethr_atomic_t *var)
 
4618
{
 
4619
    ethr_sint_t res;
 
4620
#if defined(ETHR_HAVE_NATMC_INC_RETURN_MB)
 
4621
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_mb)(var);
 
4622
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_RELB)
 
4623
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_relb)(var);
 
4624
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4625
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_ACQB)
 
4626
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4627
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_acqb)(var);
 
4628
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_WB)
 
4629
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4630
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_wb)(var);
 
4631
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4632
#elif defined(ETHR_HAVE_NATMC_INC_RETURN_RB)
 
4633
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4634
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return_rb)(var);
 
4635
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4636
#elif defined(ETHR_HAVE_NATMC_INC_RETURN)
 
4637
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4638
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(inc_return)(var);
 
4639
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4640
#else
 
4641
    res = ETHR_ATMC_FUNC__(add_read_mb)(var, (ethr_sint_t) 1);
 
4642
#endif
 
4643
    return res;
 
4644
}
 
4645
 
 
4646
 
 
4647
/* --- dec_read() --- */
 
4648
 
 
4649
 
 
4650
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(dec_read)(ethr_atomic_t *var)
 
4651
{
 
4652
    ethr_sint_t res;
 
4653
#if defined(ETHR_HAVE_NATMC_DEC_RETURN)
 
4654
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return)(var);
 
4655
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_RB)
 
4656
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_rb)(var);
 
4657
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_WB)
 
4658
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_wb)(var);
 
4659
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_ACQB)
 
4660
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_acqb)(var);
 
4661
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_RELB)
 
4662
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_relb)(var);
 
4663
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_MB)
 
4664
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_mb)(var);
 
4665
#else
 
4666
    res = ETHR_ATMC_FUNC__(add_read)(var, (ethr_sint_t) -1);
 
4667
#endif
 
4668
    return res;
 
4669
}
 
4670
 
 
4671
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(dec_read_rb)(ethr_atomic_t *var)
 
4672
{
 
4673
    ethr_sint_t res;
 
4674
#if defined(ETHR_HAVE_NATMC_DEC_RETURN_RB)
 
4675
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_rb)(var);
 
4676
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN)
 
4677
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return)(var);
 
4678
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4679
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_MB)
 
4680
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_mb)(var);
 
4681
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_WB)
 
4682
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_wb)(var);
 
4683
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4684
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_ACQB)
 
4685
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_acqb)(var);
 
4686
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4687
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_RELB)
 
4688
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_relb)(var);
 
4689
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4690
#else
 
4691
    res = ETHR_ATMC_FUNC__(add_read_rb)(var, (ethr_sint_t) -1);
 
4692
#endif
 
4693
    return res;
 
4694
}
 
4695
 
 
4696
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(dec_read_wb)(ethr_atomic_t *var)
 
4697
{
 
4698
    ethr_sint_t res;
 
4699
#if defined(ETHR_HAVE_NATMC_DEC_RETURN_WB)
 
4700
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_wb)(var);
 
4701
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN)
 
4702
    ETHR_MEMBAR(ETHR_StoreStore);
 
4703
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return)(var);
 
4704
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_MB)
 
4705
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_mb)(var);
 
4706
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_RB)
 
4707
    ETHR_MEMBAR(ETHR_StoreStore);
 
4708
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_rb)(var);
 
4709
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_ACQB)
 
4710
    ETHR_MEMBAR(ETHR_StoreStore);
 
4711
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_acqb)(var);
 
4712
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_RELB)
 
4713
    ETHR_MEMBAR(ETHR_StoreStore);
 
4714
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_relb)(var);
 
4715
#else
 
4716
    res = ETHR_ATMC_FUNC__(add_read_wb)(var, (ethr_sint_t) -1);
 
4717
#endif
 
4718
    return res;
 
4719
}
 
4720
 
 
4721
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(dec_read_acqb)(ethr_atomic_t *var)
 
4722
{
 
4723
    ethr_sint_t res;
 
4724
#if defined(ETHR_HAVE_NATMC_DEC_RETURN_ACQB)
 
4725
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_acqb)(var);
 
4726
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_RB)
 
4727
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_rb)(var);
 
4728
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4729
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN)
 
4730
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return)(var);
 
4731
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4732
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_MB)
 
4733
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_mb)(var);
 
4734
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_WB)
 
4735
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_wb)(var);
 
4736
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4737
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_RELB)
 
4738
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_relb)(var);
 
4739
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4740
#else
 
4741
    res = ETHR_ATMC_FUNC__(add_read_acqb)(var, (ethr_sint_t) -1);
 
4742
#endif
 
4743
    return res;
 
4744
}
 
4745
 
 
4746
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(dec_read_relb)(ethr_atomic_t *var)
 
4747
{
 
4748
    ethr_sint_t res;
 
4749
#if defined(ETHR_HAVE_NATMC_DEC_RETURN_RELB)
 
4750
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_relb)(var);
 
4751
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_WB)
 
4752
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4753
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_wb)(var);
 
4754
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN)
 
4755
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4756
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return)(var);
 
4757
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_MB)
 
4758
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_mb)(var);
 
4759
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_RB)
 
4760
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4761
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_rb)(var);
 
4762
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_ACQB)
 
4763
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4764
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_acqb)(var);
 
4765
#else
 
4766
    res = ETHR_ATMC_FUNC__(add_read_relb)(var, (ethr_sint_t) -1);
 
4767
#endif
 
4768
    return res;
 
4769
}
 
4770
 
 
4771
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(dec_read_mb)(ethr_atomic_t *var)
 
4772
{
 
4773
    ethr_sint_t res;
 
4774
#if defined(ETHR_HAVE_NATMC_DEC_RETURN_MB)
 
4775
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_mb)(var);
 
4776
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_RELB)
 
4777
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_relb)(var);
 
4778
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4779
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_ACQB)
 
4780
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4781
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_acqb)(var);
 
4782
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_WB)
 
4783
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4784
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_wb)(var);
 
4785
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4786
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN_RB)
 
4787
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4788
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return_rb)(var);
 
4789
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4790
#elif defined(ETHR_HAVE_NATMC_DEC_RETURN)
 
4791
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4792
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(dec_return)(var);
 
4793
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4794
#else
 
4795
    res = ETHR_ATMC_FUNC__(add_read_mb)(var, (ethr_sint_t) -1);
 
4796
#endif
 
4797
    return res;
 
4798
}
 
4799
 
 
4800
 
 
4801
/* --- add() --- */
 
4802
 
 
4803
 
 
4804
static ETHR_INLINE void ETHR_ATMC_FUNC__(add)(ethr_atomic_t *var, ethr_sint_t val)
 
4805
{
 
4806
#if defined(ETHR_HAVE_NATMC_ADD)
 
4807
    ETHR_NATMC_FUNC__(add)(var, (ETHR_NAINT_T__) val);
 
4808
#elif defined(ETHR_HAVE_NATMC_ADD_RB)
 
4809
    ETHR_NATMC_FUNC__(add_rb)(var, (ETHR_NAINT_T__) val);
 
4810
#elif defined(ETHR_HAVE_NATMC_ADD_WB)
 
4811
    ETHR_NATMC_FUNC__(add_wb)(var, (ETHR_NAINT_T__) val);
 
4812
#elif defined(ETHR_HAVE_NATMC_ADD_ACQB)
 
4813
    ETHR_NATMC_FUNC__(add_acqb)(var, (ETHR_NAINT_T__) val);
 
4814
#elif defined(ETHR_HAVE_NATMC_ADD_RELB)
 
4815
    ETHR_NATMC_FUNC__(add_relb)(var, (ETHR_NAINT_T__) val);
 
4816
#elif defined(ETHR_HAVE_NATMC_ADD_MB)
 
4817
    ETHR_NATMC_FUNC__(add_mb)(var, (ETHR_NAINT_T__) val);
 
4818
#else
 
4819
    (void) ETHR_ATMC_FUNC__(add_read)(var, val);
 
4820
#endif
 
4821
}
 
4822
 
 
4823
static ETHR_INLINE void ETHR_ATMC_FUNC__(add_rb)(ethr_atomic_t *var, ethr_sint_t val)
 
4824
{
 
4825
#if defined(ETHR_HAVE_NATMC_ADD_RB)
 
4826
    ETHR_NATMC_FUNC__(add_rb)(var, (ETHR_NAINT_T__) val);
 
4827
#elif defined(ETHR_HAVE_NATMC_ADD)
 
4828
    ETHR_NATMC_FUNC__(add)(var, (ETHR_NAINT_T__) val);
 
4829
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4830
#elif defined(ETHR_HAVE_NATMC_ADD_MB)
 
4831
    ETHR_NATMC_FUNC__(add_mb)(var, (ETHR_NAINT_T__) val);
 
4832
#elif defined(ETHR_HAVE_NATMC_ADD_WB)
 
4833
    ETHR_NATMC_FUNC__(add_wb)(var, (ETHR_NAINT_T__) val);
 
4834
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4835
#elif defined(ETHR_HAVE_NATMC_ADD_ACQB)
 
4836
    ETHR_NATMC_FUNC__(add_acqb)(var, (ETHR_NAINT_T__) val);
 
4837
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4838
#elif defined(ETHR_HAVE_NATMC_ADD_RELB)
 
4839
    ETHR_NATMC_FUNC__(add_relb)(var, (ETHR_NAINT_T__) val);
 
4840
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4841
#else
 
4842
    (void) ETHR_ATMC_FUNC__(add_read_rb)(var, val);
 
4843
#endif
 
4844
}
 
4845
 
 
4846
static ETHR_INLINE void ETHR_ATMC_FUNC__(add_wb)(ethr_atomic_t *var, ethr_sint_t val)
 
4847
{
 
4848
#if defined(ETHR_HAVE_NATMC_ADD_WB)
 
4849
    ETHR_NATMC_FUNC__(add_wb)(var, (ETHR_NAINT_T__) val);
 
4850
#elif defined(ETHR_HAVE_NATMC_ADD)
 
4851
    ETHR_MEMBAR(ETHR_StoreStore);
 
4852
    ETHR_NATMC_FUNC__(add)(var, (ETHR_NAINT_T__) val);
 
4853
#elif defined(ETHR_HAVE_NATMC_ADD_MB)
 
4854
    ETHR_NATMC_FUNC__(add_mb)(var, (ETHR_NAINT_T__) val);
 
4855
#elif defined(ETHR_HAVE_NATMC_ADD_RB)
 
4856
    ETHR_MEMBAR(ETHR_StoreStore);
 
4857
    ETHR_NATMC_FUNC__(add_rb)(var, (ETHR_NAINT_T__) val);
 
4858
#elif defined(ETHR_HAVE_NATMC_ADD_ACQB)
 
4859
    ETHR_MEMBAR(ETHR_StoreStore);
 
4860
    ETHR_NATMC_FUNC__(add_acqb)(var, (ETHR_NAINT_T__) val);
 
4861
#elif defined(ETHR_HAVE_NATMC_ADD_RELB)
 
4862
    ETHR_MEMBAR(ETHR_StoreStore);
 
4863
    ETHR_NATMC_FUNC__(add_relb)(var, (ETHR_NAINT_T__) val);
 
4864
#else
 
4865
    (void) ETHR_ATMC_FUNC__(add_read_wb)(var, val);
 
4866
#endif
 
4867
}
 
4868
 
 
4869
static ETHR_INLINE void ETHR_ATMC_FUNC__(add_acqb)(ethr_atomic_t *var, ethr_sint_t val)
 
4870
{
 
4871
#if defined(ETHR_HAVE_NATMC_ADD_ACQB)
 
4872
    ETHR_NATMC_FUNC__(add_acqb)(var, (ETHR_NAINT_T__) val);
 
4873
#elif defined(ETHR_HAVE_NATMC_ADD_RB)
 
4874
    ETHR_NATMC_FUNC__(add_rb)(var, (ETHR_NAINT_T__) val);
 
4875
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4876
#elif defined(ETHR_HAVE_NATMC_ADD)
 
4877
    ETHR_NATMC_FUNC__(add)(var, (ETHR_NAINT_T__) val);
 
4878
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4879
#elif defined(ETHR_HAVE_NATMC_ADD_MB)
 
4880
    ETHR_NATMC_FUNC__(add_mb)(var, (ETHR_NAINT_T__) val);
 
4881
#elif defined(ETHR_HAVE_NATMC_ADD_WB)
 
4882
    ETHR_NATMC_FUNC__(add_wb)(var, (ETHR_NAINT_T__) val);
 
4883
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4884
#elif defined(ETHR_HAVE_NATMC_ADD_RELB)
 
4885
    ETHR_NATMC_FUNC__(add_relb)(var, (ETHR_NAINT_T__) val);
 
4886
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4887
#else
 
4888
    (void) ETHR_ATMC_FUNC__(add_read_acqb)(var, val);
 
4889
#endif
 
4890
}
 
4891
 
 
4892
static ETHR_INLINE void ETHR_ATMC_FUNC__(add_relb)(ethr_atomic_t *var, ethr_sint_t val)
 
4893
{
 
4894
#if defined(ETHR_HAVE_NATMC_ADD_RELB)
 
4895
    ETHR_NATMC_FUNC__(add_relb)(var, (ETHR_NAINT_T__) val);
 
4896
#elif defined(ETHR_HAVE_NATMC_ADD_WB)
 
4897
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4898
    ETHR_NATMC_FUNC__(add_wb)(var, (ETHR_NAINT_T__) val);
 
4899
#elif defined(ETHR_HAVE_NATMC_ADD)
 
4900
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4901
    ETHR_NATMC_FUNC__(add)(var, (ETHR_NAINT_T__) val);
 
4902
#elif defined(ETHR_HAVE_NATMC_ADD_MB)
 
4903
    ETHR_NATMC_FUNC__(add_mb)(var, (ETHR_NAINT_T__) val);
 
4904
#elif defined(ETHR_HAVE_NATMC_ADD_RB)
 
4905
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4906
    ETHR_NATMC_FUNC__(add_rb)(var, (ETHR_NAINT_T__) val);
 
4907
#elif defined(ETHR_HAVE_NATMC_ADD_ACQB)
 
4908
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4909
    ETHR_NATMC_FUNC__(add_acqb)(var, (ETHR_NAINT_T__) val);
 
4910
#else
 
4911
    (void) ETHR_ATMC_FUNC__(add_read_relb)(var, val);
 
4912
#endif
 
4913
}
 
4914
 
 
4915
static ETHR_INLINE void ETHR_ATMC_FUNC__(add_mb)(ethr_atomic_t *var, ethr_sint_t val)
 
4916
{
 
4917
#if defined(ETHR_HAVE_NATMC_ADD_MB)
 
4918
    ETHR_NATMC_FUNC__(add_mb)(var, (ETHR_NAINT_T__) val);
 
4919
#elif defined(ETHR_HAVE_NATMC_ADD_RELB)
 
4920
    ETHR_NATMC_FUNC__(add_relb)(var, (ETHR_NAINT_T__) val);
 
4921
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4922
#elif defined(ETHR_HAVE_NATMC_ADD_ACQB)
 
4923
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4924
    ETHR_NATMC_FUNC__(add_acqb)(var, (ETHR_NAINT_T__) val);
 
4925
#elif defined(ETHR_HAVE_NATMC_ADD_WB)
 
4926
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4927
    ETHR_NATMC_FUNC__(add_wb)(var, (ETHR_NAINT_T__) val);
 
4928
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4929
#elif defined(ETHR_HAVE_NATMC_ADD_RB)
 
4930
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4931
    ETHR_NATMC_FUNC__(add_rb)(var, (ETHR_NAINT_T__) val);
 
4932
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4933
#elif defined(ETHR_HAVE_NATMC_ADD)
 
4934
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
4935
    ETHR_NATMC_FUNC__(add)(var, (ETHR_NAINT_T__) val);
 
4936
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
4937
#else
 
4938
    (void) ETHR_ATMC_FUNC__(add_read_mb)(var, val);
 
4939
#endif
 
4940
}
 
4941
 
 
4942
 
 
4943
/* --- inc() --- */
 
4944
 
 
4945
 
 
4946
static ETHR_INLINE void ETHR_ATMC_FUNC__(inc)(ethr_atomic_t *var)
 
4947
{
 
4948
#if defined(ETHR_HAVE_NATMC_INC)
 
4949
    ETHR_NATMC_FUNC__(inc)(var);
 
4950
#elif defined(ETHR_HAVE_NATMC_INC_RB)
 
4951
    ETHR_NATMC_FUNC__(inc_rb)(var);
 
4952
#elif defined(ETHR_HAVE_NATMC_INC_WB)
 
4953
    ETHR_NATMC_FUNC__(inc_wb)(var);
 
4954
#elif defined(ETHR_HAVE_NATMC_INC_ACQB)
 
4955
    ETHR_NATMC_FUNC__(inc_acqb)(var);
 
4956
#elif defined(ETHR_HAVE_NATMC_INC_RELB)
 
4957
    ETHR_NATMC_FUNC__(inc_relb)(var);
 
4958
#elif defined(ETHR_HAVE_NATMC_INC_MB)
 
4959
    ETHR_NATMC_FUNC__(inc_mb)(var);
 
4960
#else
 
4961
    (void) ETHR_ATMC_FUNC__(inc_read)(var);
 
4962
#endif
 
4963
}
 
4964
 
 
4965
static ETHR_INLINE void ETHR_ATMC_FUNC__(inc_rb)(ethr_atomic_t *var)
 
4966
{
 
4967
#if defined(ETHR_HAVE_NATMC_INC_RB)
 
4968
    ETHR_NATMC_FUNC__(inc_rb)(var);
 
4969
#elif defined(ETHR_HAVE_NATMC_INC)
 
4970
    ETHR_NATMC_FUNC__(inc)(var);
 
4971
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4972
#elif defined(ETHR_HAVE_NATMC_INC_MB)
 
4973
    ETHR_NATMC_FUNC__(inc_mb)(var);
 
4974
#elif defined(ETHR_HAVE_NATMC_INC_WB)
 
4975
    ETHR_NATMC_FUNC__(inc_wb)(var);
 
4976
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4977
#elif defined(ETHR_HAVE_NATMC_INC_ACQB)
 
4978
    ETHR_NATMC_FUNC__(inc_acqb)(var);
 
4979
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4980
#elif defined(ETHR_HAVE_NATMC_INC_RELB)
 
4981
    ETHR_NATMC_FUNC__(inc_relb)(var);
 
4982
    ETHR_MEMBAR(ETHR_LoadLoad);
 
4983
#else
 
4984
    (void) ETHR_ATMC_FUNC__(inc_read_rb)(var);
 
4985
#endif
 
4986
}
 
4987
 
 
4988
static ETHR_INLINE void ETHR_ATMC_FUNC__(inc_wb)(ethr_atomic_t *var)
 
4989
{
 
4990
#if defined(ETHR_HAVE_NATMC_INC_WB)
 
4991
    ETHR_NATMC_FUNC__(inc_wb)(var);
 
4992
#elif defined(ETHR_HAVE_NATMC_INC)
 
4993
    ETHR_MEMBAR(ETHR_StoreStore);
 
4994
    ETHR_NATMC_FUNC__(inc)(var);
 
4995
#elif defined(ETHR_HAVE_NATMC_INC_MB)
 
4996
    ETHR_NATMC_FUNC__(inc_mb)(var);
 
4997
#elif defined(ETHR_HAVE_NATMC_INC_RB)
 
4998
    ETHR_MEMBAR(ETHR_StoreStore);
 
4999
    ETHR_NATMC_FUNC__(inc_rb)(var);
 
5000
#elif defined(ETHR_HAVE_NATMC_INC_ACQB)
 
5001
    ETHR_MEMBAR(ETHR_StoreStore);
 
5002
    ETHR_NATMC_FUNC__(inc_acqb)(var);
 
5003
#elif defined(ETHR_HAVE_NATMC_INC_RELB)
 
5004
    ETHR_MEMBAR(ETHR_StoreStore);
 
5005
    ETHR_NATMC_FUNC__(inc_relb)(var);
 
5006
#else
 
5007
    (void) ETHR_ATMC_FUNC__(inc_read_wb)(var);
 
5008
#endif
 
5009
}
 
5010
 
 
5011
static ETHR_INLINE void ETHR_ATMC_FUNC__(inc_acqb)(ethr_atomic_t *var)
 
5012
{
 
5013
#if defined(ETHR_HAVE_NATMC_INC_ACQB)
 
5014
    ETHR_NATMC_FUNC__(inc_acqb)(var);
 
5015
#elif defined(ETHR_HAVE_NATMC_INC_RB)
 
5016
    ETHR_NATMC_FUNC__(inc_rb)(var);
 
5017
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5018
#elif defined(ETHR_HAVE_NATMC_INC)
 
5019
    ETHR_NATMC_FUNC__(inc)(var);
 
5020
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5021
#elif defined(ETHR_HAVE_NATMC_INC_MB)
 
5022
    ETHR_NATMC_FUNC__(inc_mb)(var);
 
5023
#elif defined(ETHR_HAVE_NATMC_INC_WB)
 
5024
    ETHR_NATMC_FUNC__(inc_wb)(var);
 
5025
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5026
#elif defined(ETHR_HAVE_NATMC_INC_RELB)
 
5027
    ETHR_NATMC_FUNC__(inc_relb)(var);
 
5028
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5029
#else
 
5030
    (void) ETHR_ATMC_FUNC__(inc_read_acqb)(var);
 
5031
#endif
 
5032
}
 
5033
 
 
5034
static ETHR_INLINE void ETHR_ATMC_FUNC__(inc_relb)(ethr_atomic_t *var)
 
5035
{
 
5036
#if defined(ETHR_HAVE_NATMC_INC_RELB)
 
5037
    ETHR_NATMC_FUNC__(inc_relb)(var);
 
5038
#elif defined(ETHR_HAVE_NATMC_INC_WB)
 
5039
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5040
    ETHR_NATMC_FUNC__(inc_wb)(var);
 
5041
#elif defined(ETHR_HAVE_NATMC_INC)
 
5042
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5043
    ETHR_NATMC_FUNC__(inc)(var);
 
5044
#elif defined(ETHR_HAVE_NATMC_INC_MB)
 
5045
    ETHR_NATMC_FUNC__(inc_mb)(var);
 
5046
#elif defined(ETHR_HAVE_NATMC_INC_RB)
 
5047
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5048
    ETHR_NATMC_FUNC__(inc_rb)(var);
 
5049
#elif defined(ETHR_HAVE_NATMC_INC_ACQB)
 
5050
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5051
    ETHR_NATMC_FUNC__(inc_acqb)(var);
 
5052
#else
 
5053
    (void) ETHR_ATMC_FUNC__(inc_read_relb)(var);
 
5054
#endif
 
5055
}
 
5056
 
 
5057
static ETHR_INLINE void ETHR_ATMC_FUNC__(inc_mb)(ethr_atomic_t *var)
 
5058
{
 
5059
#if defined(ETHR_HAVE_NATMC_INC_MB)
 
5060
    ETHR_NATMC_FUNC__(inc_mb)(var);
 
5061
#elif defined(ETHR_HAVE_NATMC_INC_RELB)
 
5062
    ETHR_NATMC_FUNC__(inc_relb)(var);
 
5063
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5064
#elif defined(ETHR_HAVE_NATMC_INC_ACQB)
 
5065
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5066
    ETHR_NATMC_FUNC__(inc_acqb)(var);
 
5067
#elif defined(ETHR_HAVE_NATMC_INC_WB)
 
5068
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5069
    ETHR_NATMC_FUNC__(inc_wb)(var);
 
5070
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5071
#elif defined(ETHR_HAVE_NATMC_INC_RB)
 
5072
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5073
    ETHR_NATMC_FUNC__(inc_rb)(var);
 
5074
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5075
#elif defined(ETHR_HAVE_NATMC_INC)
 
5076
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5077
    ETHR_NATMC_FUNC__(inc)(var);
 
5078
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5079
#else
 
5080
    (void) ETHR_ATMC_FUNC__(inc_read_mb)(var);
 
5081
#endif
 
5082
}
 
5083
 
 
5084
 
 
5085
/* --- dec() --- */
 
5086
 
 
5087
 
 
5088
static ETHR_INLINE void ETHR_ATMC_FUNC__(dec)(ethr_atomic_t *var)
 
5089
{
 
5090
#if defined(ETHR_HAVE_NATMC_DEC)
 
5091
    ETHR_NATMC_FUNC__(dec)(var);
 
5092
#elif defined(ETHR_HAVE_NATMC_DEC_RB)
 
5093
    ETHR_NATMC_FUNC__(dec_rb)(var);
 
5094
#elif defined(ETHR_HAVE_NATMC_DEC_WB)
 
5095
    ETHR_NATMC_FUNC__(dec_wb)(var);
 
5096
#elif defined(ETHR_HAVE_NATMC_DEC_ACQB)
 
5097
    ETHR_NATMC_FUNC__(dec_acqb)(var);
 
5098
#elif defined(ETHR_HAVE_NATMC_DEC_RELB)
 
5099
    ETHR_NATMC_FUNC__(dec_relb)(var);
 
5100
#elif defined(ETHR_HAVE_NATMC_DEC_MB)
 
5101
    ETHR_NATMC_FUNC__(dec_mb)(var);
 
5102
#else
 
5103
    (void) ETHR_ATMC_FUNC__(dec_read)(var);
 
5104
#endif
 
5105
}
 
5106
 
 
5107
static ETHR_INLINE void ETHR_ATMC_FUNC__(dec_rb)(ethr_atomic_t *var)
 
5108
{
 
5109
#if defined(ETHR_HAVE_NATMC_DEC_RB)
 
5110
    ETHR_NATMC_FUNC__(dec_rb)(var);
 
5111
#elif defined(ETHR_HAVE_NATMC_DEC)
 
5112
    ETHR_NATMC_FUNC__(dec)(var);
 
5113
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5114
#elif defined(ETHR_HAVE_NATMC_DEC_MB)
 
5115
    ETHR_NATMC_FUNC__(dec_mb)(var);
 
5116
#elif defined(ETHR_HAVE_NATMC_DEC_WB)
 
5117
    ETHR_NATMC_FUNC__(dec_wb)(var);
 
5118
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5119
#elif defined(ETHR_HAVE_NATMC_DEC_ACQB)
 
5120
    ETHR_NATMC_FUNC__(dec_acqb)(var);
 
5121
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5122
#elif defined(ETHR_HAVE_NATMC_DEC_RELB)
 
5123
    ETHR_NATMC_FUNC__(dec_relb)(var);
 
5124
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5125
#else
 
5126
    (void) ETHR_ATMC_FUNC__(dec_read_rb)(var);
 
5127
#endif
 
5128
}
 
5129
 
 
5130
static ETHR_INLINE void ETHR_ATMC_FUNC__(dec_wb)(ethr_atomic_t *var)
 
5131
{
 
5132
#if defined(ETHR_HAVE_NATMC_DEC_WB)
 
5133
    ETHR_NATMC_FUNC__(dec_wb)(var);
 
5134
#elif defined(ETHR_HAVE_NATMC_DEC)
 
5135
    ETHR_MEMBAR(ETHR_StoreStore);
 
5136
    ETHR_NATMC_FUNC__(dec)(var);
 
5137
#elif defined(ETHR_HAVE_NATMC_DEC_MB)
 
5138
    ETHR_NATMC_FUNC__(dec_mb)(var);
 
5139
#elif defined(ETHR_HAVE_NATMC_DEC_RB)
 
5140
    ETHR_MEMBAR(ETHR_StoreStore);
 
5141
    ETHR_NATMC_FUNC__(dec_rb)(var);
 
5142
#elif defined(ETHR_HAVE_NATMC_DEC_ACQB)
 
5143
    ETHR_MEMBAR(ETHR_StoreStore);
 
5144
    ETHR_NATMC_FUNC__(dec_acqb)(var);
 
5145
#elif defined(ETHR_HAVE_NATMC_DEC_RELB)
 
5146
    ETHR_MEMBAR(ETHR_StoreStore);
 
5147
    ETHR_NATMC_FUNC__(dec_relb)(var);
 
5148
#else
 
5149
    (void) ETHR_ATMC_FUNC__(dec_read_wb)(var);
 
5150
#endif
 
5151
}
 
5152
 
 
5153
static ETHR_INLINE void ETHR_ATMC_FUNC__(dec_acqb)(ethr_atomic_t *var)
 
5154
{
 
5155
#if defined(ETHR_HAVE_NATMC_DEC_ACQB)
 
5156
    ETHR_NATMC_FUNC__(dec_acqb)(var);
 
5157
#elif defined(ETHR_HAVE_NATMC_DEC_RB)
 
5158
    ETHR_NATMC_FUNC__(dec_rb)(var);
 
5159
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5160
#elif defined(ETHR_HAVE_NATMC_DEC)
 
5161
    ETHR_NATMC_FUNC__(dec)(var);
 
5162
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5163
#elif defined(ETHR_HAVE_NATMC_DEC_MB)
 
5164
    ETHR_NATMC_FUNC__(dec_mb)(var);
 
5165
#elif defined(ETHR_HAVE_NATMC_DEC_WB)
 
5166
    ETHR_NATMC_FUNC__(dec_wb)(var);
 
5167
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5168
#elif defined(ETHR_HAVE_NATMC_DEC_RELB)
 
5169
    ETHR_NATMC_FUNC__(dec_relb)(var);
 
5170
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5171
#else
 
5172
    (void) ETHR_ATMC_FUNC__(dec_read_acqb)(var);
 
5173
#endif
 
5174
}
 
5175
 
 
5176
static ETHR_INLINE void ETHR_ATMC_FUNC__(dec_relb)(ethr_atomic_t *var)
 
5177
{
 
5178
#if defined(ETHR_HAVE_NATMC_DEC_RELB)
 
5179
    ETHR_NATMC_FUNC__(dec_relb)(var);
 
5180
#elif defined(ETHR_HAVE_NATMC_DEC_WB)
 
5181
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5182
    ETHR_NATMC_FUNC__(dec_wb)(var);
 
5183
#elif defined(ETHR_HAVE_NATMC_DEC)
 
5184
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5185
    ETHR_NATMC_FUNC__(dec)(var);
 
5186
#elif defined(ETHR_HAVE_NATMC_DEC_MB)
 
5187
    ETHR_NATMC_FUNC__(dec_mb)(var);
 
5188
#elif defined(ETHR_HAVE_NATMC_DEC_RB)
 
5189
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5190
    ETHR_NATMC_FUNC__(dec_rb)(var);
 
5191
#elif defined(ETHR_HAVE_NATMC_DEC_ACQB)
 
5192
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5193
    ETHR_NATMC_FUNC__(dec_acqb)(var);
 
5194
#else
 
5195
    (void) ETHR_ATMC_FUNC__(dec_read_relb)(var);
 
5196
#endif
 
5197
}
 
5198
 
 
5199
static ETHR_INLINE void ETHR_ATMC_FUNC__(dec_mb)(ethr_atomic_t *var)
 
5200
{
 
5201
#if defined(ETHR_HAVE_NATMC_DEC_MB)
 
5202
    ETHR_NATMC_FUNC__(dec_mb)(var);
 
5203
#elif defined(ETHR_HAVE_NATMC_DEC_RELB)
 
5204
    ETHR_NATMC_FUNC__(dec_relb)(var);
 
5205
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5206
#elif defined(ETHR_HAVE_NATMC_DEC_ACQB)
 
5207
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5208
    ETHR_NATMC_FUNC__(dec_acqb)(var);
 
5209
#elif defined(ETHR_HAVE_NATMC_DEC_WB)
 
5210
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5211
    ETHR_NATMC_FUNC__(dec_wb)(var);
 
5212
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5213
#elif defined(ETHR_HAVE_NATMC_DEC_RB)
 
5214
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5215
    ETHR_NATMC_FUNC__(dec_rb)(var);
 
5216
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5217
#elif defined(ETHR_HAVE_NATMC_DEC)
 
5218
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5219
    ETHR_NATMC_FUNC__(dec)(var);
 
5220
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5221
#else
 
5222
    (void) ETHR_ATMC_FUNC__(dec_read_mb)(var);
 
5223
#endif
 
5224
}
 
5225
 
 
5226
 
 
5227
/* --- read_band() --- */
 
5228
 
 
5229
 
 
5230
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(read_band)(ethr_atomic_t *var, ethr_sint_t val)
 
5231
{
 
5232
    ethr_sint_t res;
 
5233
#if defined(ETHR_HAVE_NATMC_AND_RETOLD)
 
5234
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold)(var, (ETHR_NAINT_T__) val);
 
5235
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_RB)
 
5236
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_rb)(var, (ETHR_NAINT_T__) val);
 
5237
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_WB)
 
5238
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_wb)(var, (ETHR_NAINT_T__) val);
 
5239
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_ACQB)
 
5240
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_acqb)(var, (ETHR_NAINT_T__) val);
 
5241
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_RELB)
 
5242
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_relb)(var, (ETHR_NAINT_T__) val);
 
5243
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_MB)
 
5244
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_mb)(var, (ETHR_NAINT_T__) val);
 
5245
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
5246
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, res = aval; aval &= val);
 
5247
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
5248
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, res = aval; aval &= val);
 
5249
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
5250
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, res = aval; aval &= val);
 
5251
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
5252
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval &= val);
 
5253
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
5254
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, res = aval; aval &= val);
 
5255
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
5256
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, res = aval; aval &= val);
 
5257
#else
 
5258
#error "Missing implementation of ethr_atomic_read_band()!"
 
5259
#endif
 
5260
    return res;
 
5261
}
 
5262
 
 
5263
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(read_band_rb)(ethr_atomic_t *var, ethr_sint_t val)
 
5264
{
 
5265
    ethr_sint_t res;
 
5266
#if defined(ETHR_HAVE_NATMC_AND_RETOLD_RB)
 
5267
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_rb)(var, (ETHR_NAINT_T__) val);
 
5268
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD)
 
5269
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold)(var, (ETHR_NAINT_T__) val);
 
5270
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5271
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_MB)
 
5272
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_mb)(var, (ETHR_NAINT_T__) val);
 
5273
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_WB)
 
5274
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_wb)(var, (ETHR_NAINT_T__) val);
 
5275
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5276
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_ACQB)
 
5277
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_acqb)(var, (ETHR_NAINT_T__) val);
 
5278
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5279
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_RELB)
 
5280
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_relb)(var, (ETHR_NAINT_T__) val);
 
5281
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5282
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
5283
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, res = aval; aval &= val);
 
5284
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
5285
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, res = aval; aval &= val);
 
5286
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5287
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
5288
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, res = aval; aval &= val);
 
5289
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
5290
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, res = aval; aval &= val);
 
5291
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5292
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
5293
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval &= val);
 
5294
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5295
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
5296
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, res = aval; aval &= val);
 
5297
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5298
#else
 
5299
#error "Missing implementation of ethr_atomic_read_band_rb()!"
 
5300
#endif
 
5301
    return res;
 
5302
}
 
5303
 
 
5304
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(read_band_wb)(ethr_atomic_t *var, ethr_sint_t val)
 
5305
{
 
5306
    ethr_sint_t res;
 
5307
#if defined(ETHR_HAVE_NATMC_AND_RETOLD_WB)
 
5308
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_wb)(var, (ETHR_NAINT_T__) val);
 
5309
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD)
 
5310
    ETHR_MEMBAR(ETHR_StoreStore);
 
5311
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold)(var, (ETHR_NAINT_T__) val);
 
5312
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_MB)
 
5313
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_mb)(var, (ETHR_NAINT_T__) val);
 
5314
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_RB)
 
5315
    ETHR_MEMBAR(ETHR_StoreStore);
 
5316
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_rb)(var, (ETHR_NAINT_T__) val);
 
5317
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_ACQB)
 
5318
    ETHR_MEMBAR(ETHR_StoreStore);
 
5319
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_acqb)(var, (ETHR_NAINT_T__) val);
 
5320
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_RELB)
 
5321
    ETHR_MEMBAR(ETHR_StoreStore);
 
5322
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_relb)(var, (ETHR_NAINT_T__) val);
 
5323
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
5324
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, res = aval; aval &= val);
 
5325
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
5326
    ETHR_MEMBAR(ETHR_StoreStore);
 
5327
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, res = aval; aval &= val);
 
5328
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
5329
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, res = aval; aval &= val);
 
5330
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
5331
    ETHR_MEMBAR(ETHR_StoreStore);
 
5332
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, res = aval; aval &= val);
 
5333
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
5334
    ETHR_MEMBAR(ETHR_StoreStore);
 
5335
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval &= val);
 
5336
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
5337
    ETHR_MEMBAR(ETHR_StoreStore);
 
5338
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, res = aval; aval &= val);
 
5339
#else
 
5340
#error "Missing implementation of ethr_atomic_read_band_wb()!"
 
5341
#endif
 
5342
    return res;
 
5343
}
 
5344
 
 
5345
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(read_band_acqb)(ethr_atomic_t *var, ethr_sint_t val)
 
5346
{
 
5347
    ethr_sint_t res;
 
5348
#if defined(ETHR_HAVE_NATMC_AND_RETOLD_ACQB)
 
5349
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_acqb)(var, (ETHR_NAINT_T__) val);
 
5350
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_RB)
 
5351
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_rb)(var, (ETHR_NAINT_T__) val);
 
5352
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5353
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD)
 
5354
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold)(var, (ETHR_NAINT_T__) val);
 
5355
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5356
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_MB)
 
5357
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_mb)(var, (ETHR_NAINT_T__) val);
 
5358
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_WB)
 
5359
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_wb)(var, (ETHR_NAINT_T__) val);
 
5360
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5361
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_RELB)
 
5362
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_relb)(var, (ETHR_NAINT_T__) val);
 
5363
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5364
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
5365
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval &= val);
 
5366
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
5367
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, res = aval; aval &= val);
 
5368
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5369
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
5370
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, res = aval; aval &= val);
 
5371
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5372
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
5373
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, res = aval; aval &= val);
 
5374
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
5375
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, res = aval; aval &= val);
 
5376
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5377
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
5378
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, res = aval; aval &= val);
 
5379
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5380
#else
 
5381
#error "Missing implementation of ethr_atomic_read_band_acqb()!"
 
5382
#endif
 
5383
    return res;
 
5384
}
 
5385
 
 
5386
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(read_band_relb)(ethr_atomic_t *var, ethr_sint_t val)
 
5387
{
 
5388
    ethr_sint_t res;
 
5389
#if defined(ETHR_HAVE_NATMC_AND_RETOLD_RELB)
 
5390
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_relb)(var, (ETHR_NAINT_T__) val);
 
5391
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_WB)
 
5392
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5393
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_wb)(var, (ETHR_NAINT_T__) val);
 
5394
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD)
 
5395
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5396
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold)(var, (ETHR_NAINT_T__) val);
 
5397
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_MB)
 
5398
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_mb)(var, (ETHR_NAINT_T__) val);
 
5399
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_RB)
 
5400
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5401
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_rb)(var, (ETHR_NAINT_T__) val);
 
5402
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_ACQB)
 
5403
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5404
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_acqb)(var, (ETHR_NAINT_T__) val);
 
5405
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
5406
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, res = aval; aval &= val);
 
5407
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
5408
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5409
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, res = aval; aval &= val);
 
5410
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
5411
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5412
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, res = aval; aval &= val);
 
5413
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
5414
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, res = aval; aval &= val);
 
5415
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
5416
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5417
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, res = aval; aval &= val);
 
5418
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
5419
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5420
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval &= val);
 
5421
#else
 
5422
#error "Missing implementation of ethr_atomic_read_band_relb()!"
 
5423
#endif
 
5424
    return res;
 
5425
}
 
5426
 
 
5427
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(read_band_mb)(ethr_atomic_t *var, ethr_sint_t val)
 
5428
{
 
5429
    ethr_sint_t res;
 
5430
#if defined(ETHR_HAVE_NATMC_AND_RETOLD_MB)
 
5431
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_mb)(var, (ETHR_NAINT_T__) val);
 
5432
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_RELB)
 
5433
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_relb)(var, (ETHR_NAINT_T__) val);
 
5434
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5435
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_ACQB)
 
5436
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5437
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_acqb)(var, (ETHR_NAINT_T__) val);
 
5438
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_WB)
 
5439
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5440
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_wb)(var, (ETHR_NAINT_T__) val);
 
5441
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5442
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD_RB)
 
5443
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5444
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold_rb)(var, (ETHR_NAINT_T__) val);
 
5445
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5446
#elif defined(ETHR_HAVE_NATMC_AND_RETOLD)
 
5447
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5448
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(and_retold)(var, (ETHR_NAINT_T__) val);
 
5449
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5450
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
5451
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, res = aval; aval &= val);
 
5452
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
5453
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, res = aval; aval &= val);
 
5454
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5455
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
5456
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5457
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval &= val);
 
5458
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
5459
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5460
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, res = aval; aval &= val);
 
5461
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5462
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
5463
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5464
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, res = aval; aval &= val);
 
5465
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5466
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
5467
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5468
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, res = aval; aval &= val);
 
5469
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5470
#else
 
5471
#error "Missing implementation of ethr_atomic_read_band_mb()!"
 
5472
#endif
 
5473
    return res;
 
5474
}
 
5475
 
 
5476
 
 
5477
/* --- read_bor() --- */
 
5478
 
 
5479
 
 
5480
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(read_bor)(ethr_atomic_t *var, ethr_sint_t val)
 
5481
{
 
5482
    ethr_sint_t res;
 
5483
#if defined(ETHR_HAVE_NATMC_OR_RETOLD)
 
5484
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold)(var, (ETHR_NAINT_T__) val);
 
5485
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_RB)
 
5486
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_rb)(var, (ETHR_NAINT_T__) val);
 
5487
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_WB)
 
5488
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_wb)(var, (ETHR_NAINT_T__) val);
 
5489
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_ACQB)
 
5490
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_acqb)(var, (ETHR_NAINT_T__) val);
 
5491
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_RELB)
 
5492
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_relb)(var, (ETHR_NAINT_T__) val);
 
5493
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_MB)
 
5494
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_mb)(var, (ETHR_NAINT_T__) val);
 
5495
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
5496
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, res = aval; aval |= val);
 
5497
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
5498
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, res = aval; aval |= val);
 
5499
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
5500
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, res = aval; aval |= val);
 
5501
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
5502
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval |= val);
 
5503
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
5504
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, res = aval; aval |= val);
 
5505
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
5506
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, res = aval; aval |= val);
 
5507
#else
 
5508
#error "Missing implementation of ethr_atomic_read_bor()!"
 
5509
#endif
 
5510
    return res;
 
5511
}
 
5512
 
 
5513
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(read_bor_rb)(ethr_atomic_t *var, ethr_sint_t val)
 
5514
{
 
5515
    ethr_sint_t res;
 
5516
#if defined(ETHR_HAVE_NATMC_OR_RETOLD_RB)
 
5517
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_rb)(var, (ETHR_NAINT_T__) val);
 
5518
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD)
 
5519
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold)(var, (ETHR_NAINT_T__) val);
 
5520
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5521
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_MB)
 
5522
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_mb)(var, (ETHR_NAINT_T__) val);
 
5523
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_WB)
 
5524
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_wb)(var, (ETHR_NAINT_T__) val);
 
5525
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5526
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_ACQB)
 
5527
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_acqb)(var, (ETHR_NAINT_T__) val);
 
5528
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5529
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_RELB)
 
5530
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_relb)(var, (ETHR_NAINT_T__) val);
 
5531
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5532
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
5533
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, res = aval; aval |= val);
 
5534
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
5535
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, res = aval; aval |= val);
 
5536
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5537
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
5538
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, res = aval; aval |= val);
 
5539
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
5540
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, res = aval; aval |= val);
 
5541
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5542
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
5543
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval |= val);
 
5544
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5545
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
5546
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, res = aval; aval |= val);
 
5547
    ETHR_MEMBAR(ETHR_LoadLoad);
 
5548
#else
 
5549
#error "Missing implementation of ethr_atomic_read_bor_rb()!"
 
5550
#endif
 
5551
    return res;
 
5552
}
 
5553
 
 
5554
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(read_bor_wb)(ethr_atomic_t *var, ethr_sint_t val)
 
5555
{
 
5556
    ethr_sint_t res;
 
5557
#if defined(ETHR_HAVE_NATMC_OR_RETOLD_WB)
 
5558
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_wb)(var, (ETHR_NAINT_T__) val);
 
5559
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD)
 
5560
    ETHR_MEMBAR(ETHR_StoreStore);
 
5561
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold)(var, (ETHR_NAINT_T__) val);
 
5562
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_MB)
 
5563
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_mb)(var, (ETHR_NAINT_T__) val);
 
5564
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_RB)
 
5565
    ETHR_MEMBAR(ETHR_StoreStore);
 
5566
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_rb)(var, (ETHR_NAINT_T__) val);
 
5567
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_ACQB)
 
5568
    ETHR_MEMBAR(ETHR_StoreStore);
 
5569
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_acqb)(var, (ETHR_NAINT_T__) val);
 
5570
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_RELB)
 
5571
    ETHR_MEMBAR(ETHR_StoreStore);
 
5572
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_relb)(var, (ETHR_NAINT_T__) val);
 
5573
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
5574
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, res = aval; aval |= val);
 
5575
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
5576
    ETHR_MEMBAR(ETHR_StoreStore);
 
5577
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, res = aval; aval |= val);
 
5578
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
5579
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, res = aval; aval |= val);
 
5580
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
5581
    ETHR_MEMBAR(ETHR_StoreStore);
 
5582
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, res = aval; aval |= val);
 
5583
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
5584
    ETHR_MEMBAR(ETHR_StoreStore);
 
5585
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval |= val);
 
5586
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
5587
    ETHR_MEMBAR(ETHR_StoreStore);
 
5588
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, res = aval; aval |= val);
 
5589
#else
 
5590
#error "Missing implementation of ethr_atomic_read_bor_wb()!"
 
5591
#endif
 
5592
    return res;
 
5593
}
 
5594
 
 
5595
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(read_bor_acqb)(ethr_atomic_t *var, ethr_sint_t val)
 
5596
{
 
5597
    ethr_sint_t res;
 
5598
#if defined(ETHR_HAVE_NATMC_OR_RETOLD_ACQB)
 
5599
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_acqb)(var, (ETHR_NAINT_T__) val);
 
5600
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_RB)
 
5601
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_rb)(var, (ETHR_NAINT_T__) val);
 
5602
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5603
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD)
 
5604
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold)(var, (ETHR_NAINT_T__) val);
 
5605
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5606
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_MB)
 
5607
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_mb)(var, (ETHR_NAINT_T__) val);
 
5608
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_WB)
 
5609
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_wb)(var, (ETHR_NAINT_T__) val);
 
5610
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5611
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_RELB)
 
5612
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_relb)(var, (ETHR_NAINT_T__) val);
 
5613
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5614
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
5615
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval |= val);
 
5616
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
5617
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, res = aval; aval |= val);
 
5618
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5619
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
5620
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, res = aval; aval |= val);
 
5621
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5622
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
5623
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, res = aval; aval |= val);
 
5624
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
5625
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, res = aval; aval |= val);
 
5626
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5627
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
5628
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, res = aval; aval |= val);
 
5629
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5630
#else
 
5631
#error "Missing implementation of ethr_atomic_read_bor_acqb()!"
 
5632
#endif
 
5633
    return res;
 
5634
}
 
5635
 
 
5636
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(read_bor_relb)(ethr_atomic_t *var, ethr_sint_t val)
 
5637
{
 
5638
    ethr_sint_t res;
 
5639
#if defined(ETHR_HAVE_NATMC_OR_RETOLD_RELB)
 
5640
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_relb)(var, (ETHR_NAINT_T__) val);
 
5641
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_WB)
 
5642
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5643
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_wb)(var, (ETHR_NAINT_T__) val);
 
5644
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD)
 
5645
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5646
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold)(var, (ETHR_NAINT_T__) val);
 
5647
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_MB)
 
5648
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_mb)(var, (ETHR_NAINT_T__) val);
 
5649
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_RB)
 
5650
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5651
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_rb)(var, (ETHR_NAINT_T__) val);
 
5652
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_ACQB)
 
5653
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5654
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_acqb)(var, (ETHR_NAINT_T__) val);
 
5655
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
5656
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, res = aval; aval |= val);
 
5657
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
5658
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5659
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, res = aval; aval |= val);
 
5660
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
5661
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5662
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, res = aval; aval |= val);
 
5663
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
5664
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, res = aval; aval |= val);
 
5665
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
5666
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5667
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, res = aval; aval |= val);
 
5668
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
5669
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5670
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval |= val);
 
5671
#else
 
5672
#error "Missing implementation of ethr_atomic_read_bor_relb()!"
 
5673
#endif
 
5674
    return res;
 
5675
}
 
5676
 
 
5677
static ETHR_INLINE ethr_sint_t ETHR_ATMC_FUNC__(read_bor_mb)(ethr_atomic_t *var, ethr_sint_t val)
 
5678
{
 
5679
    ethr_sint_t res;
 
5680
#if defined(ETHR_HAVE_NATMC_OR_RETOLD_MB)
 
5681
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_mb)(var, (ETHR_NAINT_T__) val);
 
5682
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_RELB)
 
5683
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_relb)(var, (ETHR_NAINT_T__) val);
 
5684
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5685
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_ACQB)
 
5686
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5687
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_acqb)(var, (ETHR_NAINT_T__) val);
 
5688
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_WB)
 
5689
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5690
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_wb)(var, (ETHR_NAINT_T__) val);
 
5691
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5692
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD_RB)
 
5693
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5694
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold_rb)(var, (ETHR_NAINT_T__) val);
 
5695
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5696
#elif defined(ETHR_HAVE_NATMC_OR_RETOLD)
 
5697
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5698
    res = (ethr_sint_t) ETHR_NATMC_FUNC__(or_retold)(var, (ETHR_NAINT_T__) val);
 
5699
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5700
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_MB)
 
5701
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_mb), var, aval, res = aval; aval |= val);
 
5702
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RELB)
 
5703
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_relb), var, aval, res = aval; aval |= val);
 
5704
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5705
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_ACQB)
 
5706
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5707
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval |= val);
 
5708
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_WB)
 
5709
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5710
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_wb), var, aval, res = aval; aval |= val);
 
5711
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5712
#elif defined(ETHR_HAVE_NATMC_CMPXCHG_RB)
 
5713
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5714
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg_rb), var, aval, res = aval; aval |= val);
 
5715
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5716
#elif defined(ETHR_HAVE_NATMC_CMPXCHG)
 
5717
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
5718
    ETHR_NATMC_CMPXCHG_FALLBACK__(ETHR_NATMC_FUNC__(cmpxchg), var, aval, res = aval; aval |= val);
 
5719
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
5720
#else
 
5721
#error "Missing implementation of ethr_atomic_read_bor_mb()!"
 
5722
#endif
 
5723
    return res;
 
5724
}
 
5725
 
 
5726
#endif /* ETHR_ATMC_INLINE__ */
 
5727
 
 
5728
 
 
5729
/* ---------- 32-bit atomic implementation ---------- */
 
5730
 
 
5731
 
 
5732
#ifdef ETHR_NEED_ATMC32_PROTOTYPES__
 
5733
ethr_sint32_t *ethr_atomic32_addr(ethr_atomic32_t *var);
 
5734
ethr_sint32_t ethr_atomic32_cmpxchg(ethr_atomic32_t *var, ethr_sint32_t val, ethr_sint32_t old_val);
 
5735
ethr_sint32_t ethr_atomic32_cmpxchg_rb(ethr_atomic32_t *var, ethr_sint32_t val, ethr_sint32_t old_val);
 
5736
ethr_sint32_t ethr_atomic32_cmpxchg_wb(ethr_atomic32_t *var, ethr_sint32_t val, ethr_sint32_t old_val);
 
5737
ethr_sint32_t ethr_atomic32_cmpxchg_acqb(ethr_atomic32_t *var, ethr_sint32_t val, ethr_sint32_t old_val);
 
5738
ethr_sint32_t ethr_atomic32_cmpxchg_relb(ethr_atomic32_t *var, ethr_sint32_t val, ethr_sint32_t old_val);
 
5739
ethr_sint32_t ethr_atomic32_cmpxchg_mb(ethr_atomic32_t *var, ethr_sint32_t val, ethr_sint32_t old_val);
 
5740
ethr_sint32_t ethr_atomic32_xchg(ethr_atomic32_t *var, ethr_sint32_t val);
 
5741
ethr_sint32_t ethr_atomic32_xchg_rb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5742
ethr_sint32_t ethr_atomic32_xchg_wb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5743
ethr_sint32_t ethr_atomic32_xchg_acqb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5744
ethr_sint32_t ethr_atomic32_xchg_relb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5745
ethr_sint32_t ethr_atomic32_xchg_mb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5746
void ethr_atomic32_set(ethr_atomic32_t *var, ethr_sint32_t val);
 
5747
void ethr_atomic32_set_rb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5748
void ethr_atomic32_set_wb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5749
void ethr_atomic32_set_acqb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5750
void ethr_atomic32_set_relb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5751
void ethr_atomic32_set_mb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5752
void ethr_atomic32_init(ethr_atomic32_t *var, ethr_sint32_t val);
 
5753
void ethr_atomic32_init_rb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5754
void ethr_atomic32_init_wb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5755
void ethr_atomic32_init_acqb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5756
void ethr_atomic32_init_relb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5757
void ethr_atomic32_init_mb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5758
ethr_sint32_t ethr_atomic32_add_read(ethr_atomic32_t *var, ethr_sint32_t val);
 
5759
ethr_sint32_t ethr_atomic32_add_read_rb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5760
ethr_sint32_t ethr_atomic32_add_read_wb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5761
ethr_sint32_t ethr_atomic32_add_read_acqb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5762
ethr_sint32_t ethr_atomic32_add_read_relb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5763
ethr_sint32_t ethr_atomic32_add_read_mb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5764
ethr_sint32_t ethr_atomic32_read(ethr_atomic32_t *var);
 
5765
ethr_sint32_t ethr_atomic32_read_rb(ethr_atomic32_t *var);
 
5766
ethr_sint32_t ethr_atomic32_read_wb(ethr_atomic32_t *var);
 
5767
ethr_sint32_t ethr_atomic32_read_acqb(ethr_atomic32_t *var);
 
5768
ethr_sint32_t ethr_atomic32_read_relb(ethr_atomic32_t *var);
 
5769
ethr_sint32_t ethr_atomic32_read_mb(ethr_atomic32_t *var);
 
5770
ethr_sint32_t ethr_atomic32_inc_read(ethr_atomic32_t *var);
 
5771
ethr_sint32_t ethr_atomic32_inc_read_rb(ethr_atomic32_t *var);
 
5772
ethr_sint32_t ethr_atomic32_inc_read_wb(ethr_atomic32_t *var);
 
5773
ethr_sint32_t ethr_atomic32_inc_read_acqb(ethr_atomic32_t *var);
 
5774
ethr_sint32_t ethr_atomic32_inc_read_relb(ethr_atomic32_t *var);
 
5775
ethr_sint32_t ethr_atomic32_inc_read_mb(ethr_atomic32_t *var);
 
5776
ethr_sint32_t ethr_atomic32_dec_read(ethr_atomic32_t *var);
 
5777
ethr_sint32_t ethr_atomic32_dec_read_rb(ethr_atomic32_t *var);
 
5778
ethr_sint32_t ethr_atomic32_dec_read_wb(ethr_atomic32_t *var);
 
5779
ethr_sint32_t ethr_atomic32_dec_read_acqb(ethr_atomic32_t *var);
 
5780
ethr_sint32_t ethr_atomic32_dec_read_relb(ethr_atomic32_t *var);
 
5781
ethr_sint32_t ethr_atomic32_dec_read_mb(ethr_atomic32_t *var);
 
5782
void ethr_atomic32_add(ethr_atomic32_t *var, ethr_sint32_t val);
 
5783
void ethr_atomic32_add_rb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5784
void ethr_atomic32_add_wb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5785
void ethr_atomic32_add_acqb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5786
void ethr_atomic32_add_relb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5787
void ethr_atomic32_add_mb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5788
void ethr_atomic32_inc(ethr_atomic32_t *var);
 
5789
void ethr_atomic32_inc_rb(ethr_atomic32_t *var);
 
5790
void ethr_atomic32_inc_wb(ethr_atomic32_t *var);
 
5791
void ethr_atomic32_inc_acqb(ethr_atomic32_t *var);
 
5792
void ethr_atomic32_inc_relb(ethr_atomic32_t *var);
 
5793
void ethr_atomic32_inc_mb(ethr_atomic32_t *var);
 
5794
void ethr_atomic32_dec(ethr_atomic32_t *var);
 
5795
void ethr_atomic32_dec_rb(ethr_atomic32_t *var);
 
5796
void ethr_atomic32_dec_wb(ethr_atomic32_t *var);
 
5797
void ethr_atomic32_dec_acqb(ethr_atomic32_t *var);
 
5798
void ethr_atomic32_dec_relb(ethr_atomic32_t *var);
 
5799
void ethr_atomic32_dec_mb(ethr_atomic32_t *var);
 
5800
ethr_sint32_t ethr_atomic32_read_band(ethr_atomic32_t *var, ethr_sint32_t val);
 
5801
ethr_sint32_t ethr_atomic32_read_band_rb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5802
ethr_sint32_t ethr_atomic32_read_band_wb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5803
ethr_sint32_t ethr_atomic32_read_band_acqb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5804
ethr_sint32_t ethr_atomic32_read_band_relb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5805
ethr_sint32_t ethr_atomic32_read_band_mb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5806
ethr_sint32_t ethr_atomic32_read_bor(ethr_atomic32_t *var, ethr_sint32_t val);
 
5807
ethr_sint32_t ethr_atomic32_read_bor_rb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5808
ethr_sint32_t ethr_atomic32_read_bor_wb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5809
ethr_sint32_t ethr_atomic32_read_bor_acqb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5810
ethr_sint32_t ethr_atomic32_read_bor_relb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5811
ethr_sint32_t ethr_atomic32_read_bor_mb(ethr_atomic32_t *var, ethr_sint32_t val);
 
5812
#endif /* ETHR_NEED_ATMC32_PROTOTYPES__ */
 
5813
 
 
5814
#if (defined(ETHR_HAVE_32BIT_NATIVE_ATOMIC_OPS) \
 
5815
     && (defined(ETHR_ATMC32_INLINE__) || defined(ETHR_ATOMIC_IMPL__)))
 
5816
 
 
5817
#if !defined(ETHR_NATMC32_BITS__)
 
5818
#  error "Missing native atomic implementation"
 
5819
#elif ETHR_NATMC32_BITS__ == 64
 
5820
#  undef ETHR_HAVE_NATMC32_CMPXCHG
 
5821
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_CMPXCHG
 
5822
#    define ETHR_HAVE_NATMC32_CMPXCHG 1
 
5823
#  endif
 
5824
#  undef ETHR_HAVE_NATMC32_CMPXCHG_RB
 
5825
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_CMPXCHG_RB
 
5826
#    define ETHR_HAVE_NATMC32_CMPXCHG_RB 1
 
5827
#  endif
 
5828
#  undef ETHR_HAVE_NATMC32_CMPXCHG_WB
 
5829
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_CMPXCHG_WB
 
5830
#    define ETHR_HAVE_NATMC32_CMPXCHG_WB 1
 
5831
#  endif
 
5832
#  undef ETHR_HAVE_NATMC32_CMPXCHG_ACQB
 
5833
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_CMPXCHG_ACQB
 
5834
#    define ETHR_HAVE_NATMC32_CMPXCHG_ACQB 1
 
5835
#  endif
 
5836
#  undef ETHR_HAVE_NATMC32_CMPXCHG_RELB
 
5837
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_CMPXCHG_RELB
 
5838
#    define ETHR_HAVE_NATMC32_CMPXCHG_RELB 1
 
5839
#  endif
 
5840
#  undef ETHR_HAVE_NATMC32_CMPXCHG_MB
 
5841
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_CMPXCHG_MB
 
5842
#    define ETHR_HAVE_NATMC32_CMPXCHG_MB 1
 
5843
#  endif
 
5844
#  undef ETHR_HAVE_NATMC32_XCHG
 
5845
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_XCHG
 
5846
#    define ETHR_HAVE_NATMC32_XCHG 1
 
5847
#  endif
 
5848
#  undef ETHR_HAVE_NATMC32_XCHG_RB
 
5849
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_XCHG_RB
 
5850
#    define ETHR_HAVE_NATMC32_XCHG_RB 1
 
5851
#  endif
 
5852
#  undef ETHR_HAVE_NATMC32_XCHG_WB
 
5853
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_XCHG_WB
 
5854
#    define ETHR_HAVE_NATMC32_XCHG_WB 1
 
5855
#  endif
 
5856
#  undef ETHR_HAVE_NATMC32_XCHG_ACQB
 
5857
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_XCHG_ACQB
 
5858
#    define ETHR_HAVE_NATMC32_XCHG_ACQB 1
 
5859
#  endif
 
5860
#  undef ETHR_HAVE_NATMC32_XCHG_RELB
 
5861
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_XCHG_RELB
 
5862
#    define ETHR_HAVE_NATMC32_XCHG_RELB 1
 
5863
#  endif
 
5864
#  undef ETHR_HAVE_NATMC32_XCHG_MB
 
5865
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_XCHG_MB
 
5866
#    define ETHR_HAVE_NATMC32_XCHG_MB 1
 
5867
#  endif
 
5868
#  undef ETHR_HAVE_NATMC32_SET
 
5869
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_SET
 
5870
#    define ETHR_HAVE_NATMC32_SET 1
 
5871
#  endif
 
5872
#  undef ETHR_HAVE_NATMC32_SET_RB
 
5873
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_SET_RB
 
5874
#    define ETHR_HAVE_NATMC32_SET_RB 1
 
5875
#  endif
 
5876
#  undef ETHR_HAVE_NATMC32_SET_WB
 
5877
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_SET_WB
 
5878
#    define ETHR_HAVE_NATMC32_SET_WB 1
 
5879
#  endif
 
5880
#  undef ETHR_HAVE_NATMC32_SET_ACQB
 
5881
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_SET_ACQB
 
5882
#    define ETHR_HAVE_NATMC32_SET_ACQB 1
 
5883
#  endif
 
5884
#  undef ETHR_HAVE_NATMC32_SET_RELB
 
5885
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_SET_RELB
 
5886
#    define ETHR_HAVE_NATMC32_SET_RELB 1
 
5887
#  endif
 
5888
#  undef ETHR_HAVE_NATMC32_SET_MB
 
5889
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_SET_MB
 
5890
#    define ETHR_HAVE_NATMC32_SET_MB 1
 
5891
#  endif
 
5892
#  undef ETHR_HAVE_NATMC32_INIT
 
5893
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INIT
 
5894
#    define ETHR_HAVE_NATMC32_INIT 1
 
5895
#  endif
 
5896
#  undef ETHR_HAVE_NATMC32_INIT_RB
 
5897
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INIT_RB
 
5898
#    define ETHR_HAVE_NATMC32_INIT_RB 1
 
5899
#  endif
 
5900
#  undef ETHR_HAVE_NATMC32_INIT_WB
 
5901
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INIT_WB
 
5902
#    define ETHR_HAVE_NATMC32_INIT_WB 1
 
5903
#  endif
 
5904
#  undef ETHR_HAVE_NATMC32_INIT_ACQB
 
5905
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INIT_ACQB
 
5906
#    define ETHR_HAVE_NATMC32_INIT_ACQB 1
 
5907
#  endif
 
5908
#  undef ETHR_HAVE_NATMC32_INIT_RELB
 
5909
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INIT_RELB
 
5910
#    define ETHR_HAVE_NATMC32_INIT_RELB 1
 
5911
#  endif
 
5912
#  undef ETHR_HAVE_NATMC32_INIT_MB
 
5913
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INIT_MB
 
5914
#    define ETHR_HAVE_NATMC32_INIT_MB 1
 
5915
#  endif
 
5916
#  undef ETHR_HAVE_NATMC32_ADD_RETURN
 
5917
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_RETURN
 
5918
#    define ETHR_HAVE_NATMC32_ADD_RETURN 1
 
5919
#  endif
 
5920
#  undef ETHR_HAVE_NATMC32_ADD_RETURN_RB
 
5921
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_RETURN_RB
 
5922
#    define ETHR_HAVE_NATMC32_ADD_RETURN_RB 1
 
5923
#  endif
 
5924
#  undef ETHR_HAVE_NATMC32_ADD_RETURN_WB
 
5925
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_RETURN_WB
 
5926
#    define ETHR_HAVE_NATMC32_ADD_RETURN_WB 1
 
5927
#  endif
 
5928
#  undef ETHR_HAVE_NATMC32_ADD_RETURN_ACQB
 
5929
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_RETURN_ACQB
 
5930
#    define ETHR_HAVE_NATMC32_ADD_RETURN_ACQB 1
 
5931
#  endif
 
5932
#  undef ETHR_HAVE_NATMC32_ADD_RETURN_RELB
 
5933
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_RETURN_RELB
 
5934
#    define ETHR_HAVE_NATMC32_ADD_RETURN_RELB 1
 
5935
#  endif
 
5936
#  undef ETHR_HAVE_NATMC32_ADD_RETURN_MB
 
5937
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_RETURN_MB
 
5938
#    define ETHR_HAVE_NATMC32_ADD_RETURN_MB 1
 
5939
#  endif
 
5940
#  undef ETHR_HAVE_NATMC32_READ
 
5941
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_READ
 
5942
#    define ETHR_HAVE_NATMC32_READ 1
 
5943
#  endif
 
5944
#  undef ETHR_HAVE_NATMC32_READ_RB
 
5945
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_READ_RB
 
5946
#    define ETHR_HAVE_NATMC32_READ_RB 1
 
5947
#  endif
 
5948
#  undef ETHR_HAVE_NATMC32_READ_WB
 
5949
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_READ_WB
 
5950
#    define ETHR_HAVE_NATMC32_READ_WB 1
 
5951
#  endif
 
5952
#  undef ETHR_HAVE_NATMC32_READ_ACQB
 
5953
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_READ_ACQB
 
5954
#    define ETHR_HAVE_NATMC32_READ_ACQB 1
 
5955
#  endif
 
5956
#  undef ETHR_HAVE_NATMC32_READ_RELB
 
5957
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_READ_RELB
 
5958
#    define ETHR_HAVE_NATMC32_READ_RELB 1
 
5959
#  endif
 
5960
#  undef ETHR_HAVE_NATMC32_READ_MB
 
5961
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_READ_MB
 
5962
#    define ETHR_HAVE_NATMC32_READ_MB 1
 
5963
#  endif
 
5964
#  undef ETHR_HAVE_NATMC32_INC_RETURN
 
5965
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_RETURN
 
5966
#    define ETHR_HAVE_NATMC32_INC_RETURN 1
 
5967
#  endif
 
5968
#  undef ETHR_HAVE_NATMC32_INC_RETURN_RB
 
5969
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_RETURN_RB
 
5970
#    define ETHR_HAVE_NATMC32_INC_RETURN_RB 1
 
5971
#  endif
 
5972
#  undef ETHR_HAVE_NATMC32_INC_RETURN_WB
 
5973
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_RETURN_WB
 
5974
#    define ETHR_HAVE_NATMC32_INC_RETURN_WB 1
 
5975
#  endif
 
5976
#  undef ETHR_HAVE_NATMC32_INC_RETURN_ACQB
 
5977
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_RETURN_ACQB
 
5978
#    define ETHR_HAVE_NATMC32_INC_RETURN_ACQB 1
 
5979
#  endif
 
5980
#  undef ETHR_HAVE_NATMC32_INC_RETURN_RELB
 
5981
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_RETURN_RELB
 
5982
#    define ETHR_HAVE_NATMC32_INC_RETURN_RELB 1
 
5983
#  endif
 
5984
#  undef ETHR_HAVE_NATMC32_INC_RETURN_MB
 
5985
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_RETURN_MB
 
5986
#    define ETHR_HAVE_NATMC32_INC_RETURN_MB 1
 
5987
#  endif
 
5988
#  undef ETHR_HAVE_NATMC32_DEC_RETURN
 
5989
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_RETURN
 
5990
#    define ETHR_HAVE_NATMC32_DEC_RETURN 1
 
5991
#  endif
 
5992
#  undef ETHR_HAVE_NATMC32_DEC_RETURN_RB
 
5993
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_RETURN_RB
 
5994
#    define ETHR_HAVE_NATMC32_DEC_RETURN_RB 1
 
5995
#  endif
 
5996
#  undef ETHR_HAVE_NATMC32_DEC_RETURN_WB
 
5997
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_RETURN_WB
 
5998
#    define ETHR_HAVE_NATMC32_DEC_RETURN_WB 1
 
5999
#  endif
 
6000
#  undef ETHR_HAVE_NATMC32_DEC_RETURN_ACQB
 
6001
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_RETURN_ACQB
 
6002
#    define ETHR_HAVE_NATMC32_DEC_RETURN_ACQB 1
 
6003
#  endif
 
6004
#  undef ETHR_HAVE_NATMC32_DEC_RETURN_RELB
 
6005
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_RETURN_RELB
 
6006
#    define ETHR_HAVE_NATMC32_DEC_RETURN_RELB 1
 
6007
#  endif
 
6008
#  undef ETHR_HAVE_NATMC32_DEC_RETURN_MB
 
6009
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_RETURN_MB
 
6010
#    define ETHR_HAVE_NATMC32_DEC_RETURN_MB 1
 
6011
#  endif
 
6012
#  undef ETHR_HAVE_NATMC32_ADD
 
6013
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD
 
6014
#    define ETHR_HAVE_NATMC32_ADD 1
 
6015
#  endif
 
6016
#  undef ETHR_HAVE_NATMC32_ADD_RB
 
6017
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_RB
 
6018
#    define ETHR_HAVE_NATMC32_ADD_RB 1
 
6019
#  endif
 
6020
#  undef ETHR_HAVE_NATMC32_ADD_WB
 
6021
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_WB
 
6022
#    define ETHR_HAVE_NATMC32_ADD_WB 1
 
6023
#  endif
 
6024
#  undef ETHR_HAVE_NATMC32_ADD_ACQB
 
6025
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_ACQB
 
6026
#    define ETHR_HAVE_NATMC32_ADD_ACQB 1
 
6027
#  endif
 
6028
#  undef ETHR_HAVE_NATMC32_ADD_RELB
 
6029
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_RELB
 
6030
#    define ETHR_HAVE_NATMC32_ADD_RELB 1
 
6031
#  endif
 
6032
#  undef ETHR_HAVE_NATMC32_ADD_MB
 
6033
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_ADD_MB
 
6034
#    define ETHR_HAVE_NATMC32_ADD_MB 1
 
6035
#  endif
 
6036
#  undef ETHR_HAVE_NATMC32_INC
 
6037
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC
 
6038
#    define ETHR_HAVE_NATMC32_INC 1
 
6039
#  endif
 
6040
#  undef ETHR_HAVE_NATMC32_INC_RB
 
6041
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_RB
 
6042
#    define ETHR_HAVE_NATMC32_INC_RB 1
 
6043
#  endif
 
6044
#  undef ETHR_HAVE_NATMC32_INC_WB
 
6045
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_WB
 
6046
#    define ETHR_HAVE_NATMC32_INC_WB 1
 
6047
#  endif
 
6048
#  undef ETHR_HAVE_NATMC32_INC_ACQB
 
6049
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_ACQB
 
6050
#    define ETHR_HAVE_NATMC32_INC_ACQB 1
 
6051
#  endif
 
6052
#  undef ETHR_HAVE_NATMC32_INC_RELB
 
6053
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_RELB
 
6054
#    define ETHR_HAVE_NATMC32_INC_RELB 1
 
6055
#  endif
 
6056
#  undef ETHR_HAVE_NATMC32_INC_MB
 
6057
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_INC_MB
 
6058
#    define ETHR_HAVE_NATMC32_INC_MB 1
 
6059
#  endif
 
6060
#  undef ETHR_HAVE_NATMC32_DEC
 
6061
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC
 
6062
#    define ETHR_HAVE_NATMC32_DEC 1
 
6063
#  endif
 
6064
#  undef ETHR_HAVE_NATMC32_DEC_RB
 
6065
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_RB
 
6066
#    define ETHR_HAVE_NATMC32_DEC_RB 1
 
6067
#  endif
 
6068
#  undef ETHR_HAVE_NATMC32_DEC_WB
 
6069
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_WB
 
6070
#    define ETHR_HAVE_NATMC32_DEC_WB 1
 
6071
#  endif
 
6072
#  undef ETHR_HAVE_NATMC32_DEC_ACQB
 
6073
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_ACQB
 
6074
#    define ETHR_HAVE_NATMC32_DEC_ACQB 1
 
6075
#  endif
 
6076
#  undef ETHR_HAVE_NATMC32_DEC_RELB
 
6077
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_RELB
 
6078
#    define ETHR_HAVE_NATMC32_DEC_RELB 1
 
6079
#  endif
 
6080
#  undef ETHR_HAVE_NATMC32_DEC_MB
 
6081
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_DEC_MB
 
6082
#    define ETHR_HAVE_NATMC32_DEC_MB 1
 
6083
#  endif
 
6084
#  undef ETHR_HAVE_NATMC32_AND_RETOLD
 
6085
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_AND_RETOLD
 
6086
#    define ETHR_HAVE_NATMC32_AND_RETOLD 1
 
6087
#  endif
 
6088
#  undef ETHR_HAVE_NATMC32_AND_RETOLD_RB
 
6089
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_AND_RETOLD_RB
 
6090
#    define ETHR_HAVE_NATMC32_AND_RETOLD_RB 1
 
6091
#  endif
 
6092
#  undef ETHR_HAVE_NATMC32_AND_RETOLD_WB
 
6093
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_AND_RETOLD_WB
 
6094
#    define ETHR_HAVE_NATMC32_AND_RETOLD_WB 1
 
6095
#  endif
 
6096
#  undef ETHR_HAVE_NATMC32_AND_RETOLD_ACQB
 
6097
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_AND_RETOLD_ACQB
 
6098
#    define ETHR_HAVE_NATMC32_AND_RETOLD_ACQB 1
 
6099
#  endif
 
6100
#  undef ETHR_HAVE_NATMC32_AND_RETOLD_RELB
 
6101
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_AND_RETOLD_RELB
 
6102
#    define ETHR_HAVE_NATMC32_AND_RETOLD_RELB 1
 
6103
#  endif
 
6104
#  undef ETHR_HAVE_NATMC32_AND_RETOLD_MB
 
6105
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_AND_RETOLD_MB
 
6106
#    define ETHR_HAVE_NATMC32_AND_RETOLD_MB 1
 
6107
#  endif
 
6108
#  undef ETHR_HAVE_NATMC32_OR_RETOLD
 
6109
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_OR_RETOLD
 
6110
#    define ETHR_HAVE_NATMC32_OR_RETOLD 1
 
6111
#  endif
 
6112
#  undef ETHR_HAVE_NATMC32_OR_RETOLD_RB
 
6113
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_OR_RETOLD_RB
 
6114
#    define ETHR_HAVE_NATMC32_OR_RETOLD_RB 1
 
6115
#  endif
 
6116
#  undef ETHR_HAVE_NATMC32_OR_RETOLD_WB
 
6117
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_OR_RETOLD_WB
 
6118
#    define ETHR_HAVE_NATMC32_OR_RETOLD_WB 1
 
6119
#  endif
 
6120
#  undef ETHR_HAVE_NATMC32_OR_RETOLD_ACQB
 
6121
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_OR_RETOLD_ACQB
 
6122
#    define ETHR_HAVE_NATMC32_OR_RETOLD_ACQB 1
 
6123
#  endif
 
6124
#  undef ETHR_HAVE_NATMC32_OR_RETOLD_RELB
 
6125
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_OR_RETOLD_RELB
 
6126
#    define ETHR_HAVE_NATMC32_OR_RETOLD_RELB 1
 
6127
#  endif
 
6128
#  undef ETHR_HAVE_NATMC32_OR_RETOLD_MB
 
6129
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC64_OR_RETOLD_MB
 
6130
#    define ETHR_HAVE_NATMC32_OR_RETOLD_MB 1
 
6131
#  endif
 
6132
#elif ETHR_NATMC32_BITS__ == 32
 
6133
#  undef ETHR_HAVE_NATMC32_CMPXCHG
 
6134
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_CMPXCHG
 
6135
#    define ETHR_HAVE_NATMC32_CMPXCHG 1
 
6136
#  endif
 
6137
#  undef ETHR_HAVE_NATMC32_CMPXCHG_RB
 
6138
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_CMPXCHG_RB
 
6139
#    define ETHR_HAVE_NATMC32_CMPXCHG_RB 1
 
6140
#  endif
 
6141
#  undef ETHR_HAVE_NATMC32_CMPXCHG_WB
 
6142
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_CMPXCHG_WB
 
6143
#    define ETHR_HAVE_NATMC32_CMPXCHG_WB 1
 
6144
#  endif
 
6145
#  undef ETHR_HAVE_NATMC32_CMPXCHG_ACQB
 
6146
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_CMPXCHG_ACQB
 
6147
#    define ETHR_HAVE_NATMC32_CMPXCHG_ACQB 1
 
6148
#  endif
 
6149
#  undef ETHR_HAVE_NATMC32_CMPXCHG_RELB
 
6150
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_CMPXCHG_RELB
 
6151
#    define ETHR_HAVE_NATMC32_CMPXCHG_RELB 1
 
6152
#  endif
 
6153
#  undef ETHR_HAVE_NATMC32_CMPXCHG_MB
 
6154
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_CMPXCHG_MB
 
6155
#    define ETHR_HAVE_NATMC32_CMPXCHG_MB 1
 
6156
#  endif
 
6157
#  undef ETHR_HAVE_NATMC32_XCHG
 
6158
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_XCHG
 
6159
#    define ETHR_HAVE_NATMC32_XCHG 1
 
6160
#  endif
 
6161
#  undef ETHR_HAVE_NATMC32_XCHG_RB
 
6162
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_XCHG_RB
 
6163
#    define ETHR_HAVE_NATMC32_XCHG_RB 1
 
6164
#  endif
 
6165
#  undef ETHR_HAVE_NATMC32_XCHG_WB
 
6166
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_XCHG_WB
 
6167
#    define ETHR_HAVE_NATMC32_XCHG_WB 1
 
6168
#  endif
 
6169
#  undef ETHR_HAVE_NATMC32_XCHG_ACQB
 
6170
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_XCHG_ACQB
 
6171
#    define ETHR_HAVE_NATMC32_XCHG_ACQB 1
 
6172
#  endif
 
6173
#  undef ETHR_HAVE_NATMC32_XCHG_RELB
 
6174
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_XCHG_RELB
 
6175
#    define ETHR_HAVE_NATMC32_XCHG_RELB 1
 
6176
#  endif
 
6177
#  undef ETHR_HAVE_NATMC32_XCHG_MB
 
6178
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_XCHG_MB
 
6179
#    define ETHR_HAVE_NATMC32_XCHG_MB 1
 
6180
#  endif
 
6181
#  undef ETHR_HAVE_NATMC32_SET
 
6182
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_SET
 
6183
#    define ETHR_HAVE_NATMC32_SET 1
 
6184
#  endif
 
6185
#  undef ETHR_HAVE_NATMC32_SET_RB
 
6186
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_SET_RB
 
6187
#    define ETHR_HAVE_NATMC32_SET_RB 1
 
6188
#  endif
 
6189
#  undef ETHR_HAVE_NATMC32_SET_WB
 
6190
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_SET_WB
 
6191
#    define ETHR_HAVE_NATMC32_SET_WB 1
 
6192
#  endif
 
6193
#  undef ETHR_HAVE_NATMC32_SET_ACQB
 
6194
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_SET_ACQB
 
6195
#    define ETHR_HAVE_NATMC32_SET_ACQB 1
 
6196
#  endif
 
6197
#  undef ETHR_HAVE_NATMC32_SET_RELB
 
6198
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_SET_RELB
 
6199
#    define ETHR_HAVE_NATMC32_SET_RELB 1
 
6200
#  endif
 
6201
#  undef ETHR_HAVE_NATMC32_SET_MB
 
6202
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_SET_MB
 
6203
#    define ETHR_HAVE_NATMC32_SET_MB 1
 
6204
#  endif
 
6205
#  undef ETHR_HAVE_NATMC32_INIT
 
6206
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INIT
 
6207
#    define ETHR_HAVE_NATMC32_INIT 1
 
6208
#  endif
 
6209
#  undef ETHR_HAVE_NATMC32_INIT_RB
 
6210
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INIT_RB
 
6211
#    define ETHR_HAVE_NATMC32_INIT_RB 1
 
6212
#  endif
 
6213
#  undef ETHR_HAVE_NATMC32_INIT_WB
 
6214
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INIT_WB
 
6215
#    define ETHR_HAVE_NATMC32_INIT_WB 1
 
6216
#  endif
 
6217
#  undef ETHR_HAVE_NATMC32_INIT_ACQB
 
6218
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INIT_ACQB
 
6219
#    define ETHR_HAVE_NATMC32_INIT_ACQB 1
 
6220
#  endif
 
6221
#  undef ETHR_HAVE_NATMC32_INIT_RELB
 
6222
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INIT_RELB
 
6223
#    define ETHR_HAVE_NATMC32_INIT_RELB 1
 
6224
#  endif
 
6225
#  undef ETHR_HAVE_NATMC32_INIT_MB
 
6226
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INIT_MB
 
6227
#    define ETHR_HAVE_NATMC32_INIT_MB 1
 
6228
#  endif
 
6229
#  undef ETHR_HAVE_NATMC32_ADD_RETURN
 
6230
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_RETURN
 
6231
#    define ETHR_HAVE_NATMC32_ADD_RETURN 1
 
6232
#  endif
 
6233
#  undef ETHR_HAVE_NATMC32_ADD_RETURN_RB
 
6234
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_RETURN_RB
 
6235
#    define ETHR_HAVE_NATMC32_ADD_RETURN_RB 1
 
6236
#  endif
 
6237
#  undef ETHR_HAVE_NATMC32_ADD_RETURN_WB
 
6238
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_RETURN_WB
 
6239
#    define ETHR_HAVE_NATMC32_ADD_RETURN_WB 1
 
6240
#  endif
 
6241
#  undef ETHR_HAVE_NATMC32_ADD_RETURN_ACQB
 
6242
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_RETURN_ACQB
 
6243
#    define ETHR_HAVE_NATMC32_ADD_RETURN_ACQB 1
 
6244
#  endif
 
6245
#  undef ETHR_HAVE_NATMC32_ADD_RETURN_RELB
 
6246
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_RETURN_RELB
 
6247
#    define ETHR_HAVE_NATMC32_ADD_RETURN_RELB 1
 
6248
#  endif
 
6249
#  undef ETHR_HAVE_NATMC32_ADD_RETURN_MB
 
6250
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_RETURN_MB
 
6251
#    define ETHR_HAVE_NATMC32_ADD_RETURN_MB 1
 
6252
#  endif
 
6253
#  undef ETHR_HAVE_NATMC32_READ
 
6254
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_READ
 
6255
#    define ETHR_HAVE_NATMC32_READ 1
 
6256
#  endif
 
6257
#  undef ETHR_HAVE_NATMC32_READ_RB
 
6258
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_READ_RB
 
6259
#    define ETHR_HAVE_NATMC32_READ_RB 1
 
6260
#  endif
 
6261
#  undef ETHR_HAVE_NATMC32_READ_WB
 
6262
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_READ_WB
 
6263
#    define ETHR_HAVE_NATMC32_READ_WB 1
 
6264
#  endif
 
6265
#  undef ETHR_HAVE_NATMC32_READ_ACQB
 
6266
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_READ_ACQB
 
6267
#    define ETHR_HAVE_NATMC32_READ_ACQB 1
 
6268
#  endif
 
6269
#  undef ETHR_HAVE_NATMC32_READ_RELB
 
6270
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_READ_RELB
 
6271
#    define ETHR_HAVE_NATMC32_READ_RELB 1
 
6272
#  endif
 
6273
#  undef ETHR_HAVE_NATMC32_READ_MB
 
6274
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_READ_MB
 
6275
#    define ETHR_HAVE_NATMC32_READ_MB 1
 
6276
#  endif
 
6277
#  undef ETHR_HAVE_NATMC32_INC_RETURN
 
6278
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_RETURN
 
6279
#    define ETHR_HAVE_NATMC32_INC_RETURN 1
 
6280
#  endif
 
6281
#  undef ETHR_HAVE_NATMC32_INC_RETURN_RB
 
6282
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_RETURN_RB
 
6283
#    define ETHR_HAVE_NATMC32_INC_RETURN_RB 1
 
6284
#  endif
 
6285
#  undef ETHR_HAVE_NATMC32_INC_RETURN_WB
 
6286
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_RETURN_WB
 
6287
#    define ETHR_HAVE_NATMC32_INC_RETURN_WB 1
 
6288
#  endif
 
6289
#  undef ETHR_HAVE_NATMC32_INC_RETURN_ACQB
 
6290
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_RETURN_ACQB
 
6291
#    define ETHR_HAVE_NATMC32_INC_RETURN_ACQB 1
 
6292
#  endif
 
6293
#  undef ETHR_HAVE_NATMC32_INC_RETURN_RELB
 
6294
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_RETURN_RELB
 
6295
#    define ETHR_HAVE_NATMC32_INC_RETURN_RELB 1
 
6296
#  endif
 
6297
#  undef ETHR_HAVE_NATMC32_INC_RETURN_MB
 
6298
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_RETURN_MB
 
6299
#    define ETHR_HAVE_NATMC32_INC_RETURN_MB 1
 
6300
#  endif
 
6301
#  undef ETHR_HAVE_NATMC32_DEC_RETURN
 
6302
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_RETURN
 
6303
#    define ETHR_HAVE_NATMC32_DEC_RETURN 1
 
6304
#  endif
 
6305
#  undef ETHR_HAVE_NATMC32_DEC_RETURN_RB
 
6306
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_RETURN_RB
 
6307
#    define ETHR_HAVE_NATMC32_DEC_RETURN_RB 1
 
6308
#  endif
 
6309
#  undef ETHR_HAVE_NATMC32_DEC_RETURN_WB
 
6310
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_RETURN_WB
 
6311
#    define ETHR_HAVE_NATMC32_DEC_RETURN_WB 1
 
6312
#  endif
 
6313
#  undef ETHR_HAVE_NATMC32_DEC_RETURN_ACQB
 
6314
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_RETURN_ACQB
 
6315
#    define ETHR_HAVE_NATMC32_DEC_RETURN_ACQB 1
 
6316
#  endif
 
6317
#  undef ETHR_HAVE_NATMC32_DEC_RETURN_RELB
 
6318
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_RETURN_RELB
 
6319
#    define ETHR_HAVE_NATMC32_DEC_RETURN_RELB 1
 
6320
#  endif
 
6321
#  undef ETHR_HAVE_NATMC32_DEC_RETURN_MB
 
6322
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_RETURN_MB
 
6323
#    define ETHR_HAVE_NATMC32_DEC_RETURN_MB 1
 
6324
#  endif
 
6325
#  undef ETHR_HAVE_NATMC32_ADD
 
6326
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD
 
6327
#    define ETHR_HAVE_NATMC32_ADD 1
 
6328
#  endif
 
6329
#  undef ETHR_HAVE_NATMC32_ADD_RB
 
6330
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_RB
 
6331
#    define ETHR_HAVE_NATMC32_ADD_RB 1
 
6332
#  endif
 
6333
#  undef ETHR_HAVE_NATMC32_ADD_WB
 
6334
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_WB
 
6335
#    define ETHR_HAVE_NATMC32_ADD_WB 1
 
6336
#  endif
 
6337
#  undef ETHR_HAVE_NATMC32_ADD_ACQB
 
6338
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_ACQB
 
6339
#    define ETHR_HAVE_NATMC32_ADD_ACQB 1
 
6340
#  endif
 
6341
#  undef ETHR_HAVE_NATMC32_ADD_RELB
 
6342
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_RELB
 
6343
#    define ETHR_HAVE_NATMC32_ADD_RELB 1
 
6344
#  endif
 
6345
#  undef ETHR_HAVE_NATMC32_ADD_MB
 
6346
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_ADD_MB
 
6347
#    define ETHR_HAVE_NATMC32_ADD_MB 1
 
6348
#  endif
 
6349
#  undef ETHR_HAVE_NATMC32_INC
 
6350
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC
 
6351
#    define ETHR_HAVE_NATMC32_INC 1
 
6352
#  endif
 
6353
#  undef ETHR_HAVE_NATMC32_INC_RB
 
6354
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_RB
 
6355
#    define ETHR_HAVE_NATMC32_INC_RB 1
 
6356
#  endif
 
6357
#  undef ETHR_HAVE_NATMC32_INC_WB
 
6358
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_WB
 
6359
#    define ETHR_HAVE_NATMC32_INC_WB 1
 
6360
#  endif
 
6361
#  undef ETHR_HAVE_NATMC32_INC_ACQB
 
6362
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_ACQB
 
6363
#    define ETHR_HAVE_NATMC32_INC_ACQB 1
 
6364
#  endif
 
6365
#  undef ETHR_HAVE_NATMC32_INC_RELB
 
6366
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_RELB
 
6367
#    define ETHR_HAVE_NATMC32_INC_RELB 1
 
6368
#  endif
 
6369
#  undef ETHR_HAVE_NATMC32_INC_MB
 
6370
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_INC_MB
 
6371
#    define ETHR_HAVE_NATMC32_INC_MB 1
 
6372
#  endif
 
6373
#  undef ETHR_HAVE_NATMC32_DEC
 
6374
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC
 
6375
#    define ETHR_HAVE_NATMC32_DEC 1
 
6376
#  endif
 
6377
#  undef ETHR_HAVE_NATMC32_DEC_RB
 
6378
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_RB
 
6379
#    define ETHR_HAVE_NATMC32_DEC_RB 1
 
6380
#  endif
 
6381
#  undef ETHR_HAVE_NATMC32_DEC_WB
 
6382
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_WB
 
6383
#    define ETHR_HAVE_NATMC32_DEC_WB 1
 
6384
#  endif
 
6385
#  undef ETHR_HAVE_NATMC32_DEC_ACQB
 
6386
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_ACQB
 
6387
#    define ETHR_HAVE_NATMC32_DEC_ACQB 1
 
6388
#  endif
 
6389
#  undef ETHR_HAVE_NATMC32_DEC_RELB
 
6390
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_RELB
 
6391
#    define ETHR_HAVE_NATMC32_DEC_RELB 1
 
6392
#  endif
 
6393
#  undef ETHR_HAVE_NATMC32_DEC_MB
 
6394
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_DEC_MB
 
6395
#    define ETHR_HAVE_NATMC32_DEC_MB 1
 
6396
#  endif
 
6397
#  undef ETHR_HAVE_NATMC32_AND_RETOLD
 
6398
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_AND_RETOLD
 
6399
#    define ETHR_HAVE_NATMC32_AND_RETOLD 1
 
6400
#  endif
 
6401
#  undef ETHR_HAVE_NATMC32_AND_RETOLD_RB
 
6402
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_AND_RETOLD_RB
 
6403
#    define ETHR_HAVE_NATMC32_AND_RETOLD_RB 1
 
6404
#  endif
 
6405
#  undef ETHR_HAVE_NATMC32_AND_RETOLD_WB
 
6406
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_AND_RETOLD_WB
 
6407
#    define ETHR_HAVE_NATMC32_AND_RETOLD_WB 1
 
6408
#  endif
 
6409
#  undef ETHR_HAVE_NATMC32_AND_RETOLD_ACQB
 
6410
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_AND_RETOLD_ACQB
 
6411
#    define ETHR_HAVE_NATMC32_AND_RETOLD_ACQB 1
 
6412
#  endif
 
6413
#  undef ETHR_HAVE_NATMC32_AND_RETOLD_RELB
 
6414
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_AND_RETOLD_RELB
 
6415
#    define ETHR_HAVE_NATMC32_AND_RETOLD_RELB 1
 
6416
#  endif
 
6417
#  undef ETHR_HAVE_NATMC32_AND_RETOLD_MB
 
6418
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_AND_RETOLD_MB
 
6419
#    define ETHR_HAVE_NATMC32_AND_RETOLD_MB 1
 
6420
#  endif
 
6421
#  undef ETHR_HAVE_NATMC32_OR_RETOLD
 
6422
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_OR_RETOLD
 
6423
#    define ETHR_HAVE_NATMC32_OR_RETOLD 1
 
6424
#  endif
 
6425
#  undef ETHR_HAVE_NATMC32_OR_RETOLD_RB
 
6426
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_OR_RETOLD_RB
 
6427
#    define ETHR_HAVE_NATMC32_OR_RETOLD_RB 1
 
6428
#  endif
 
6429
#  undef ETHR_HAVE_NATMC32_OR_RETOLD_WB
 
6430
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_OR_RETOLD_WB
 
6431
#    define ETHR_HAVE_NATMC32_OR_RETOLD_WB 1
 
6432
#  endif
 
6433
#  undef ETHR_HAVE_NATMC32_OR_RETOLD_ACQB
 
6434
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_OR_RETOLD_ACQB
 
6435
#    define ETHR_HAVE_NATMC32_OR_RETOLD_ACQB 1
 
6436
#  endif
 
6437
#  undef ETHR_HAVE_NATMC32_OR_RETOLD_RELB
 
6438
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_OR_RETOLD_RELB
 
6439
#    define ETHR_HAVE_NATMC32_OR_RETOLD_RELB 1
 
6440
#  endif
 
6441
#  undef ETHR_HAVE_NATMC32_OR_RETOLD_MB
 
6442
#  ifdef ETHR_HAVE_ETHR_NATIVE_ATOMIC32_OR_RETOLD_MB
 
6443
#    define ETHR_HAVE_NATMC32_OR_RETOLD_MB 1
 
6444
#  endif
 
6445
#else
 
6446
#  error "Invalid native atomic size"
 
6447
#endif
 
6448
 
 
6449
#if (!defined(ETHR_HAVE_NATMC32_CMPXCHG) \
 
6450
     && !defined(ETHR_HAVE_NATMC32_CMPXCHG_RB) \
 
6451
     && !defined(ETHR_HAVE_NATMC32_CMPXCHG_WB) \
 
6452
     && !defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB) \
 
6453
     && !defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB) \
 
6454
     && !defined(ETHR_HAVE_NATMC32_CMPXCHG_MB))
 
6455
#  error "No native cmpxchg() op available"
 
6456
#endif
 
6457
 
 
6458
 
 
6459
/*
 
6460
 * Read op used together with cmpxchg() fallback when no native op present.
 
6461
 */
 
6462
#if defined(ETHR_HAVE_NATMC32_READ)
 
6463
#define ETHR_NATMC32_CMPXCHG_FALLBACK_READ__(VAR) \
 
6464
  ETHR_NATMC32_FUNC__(read)(VAR)
 
6465
#elif defined(ETHR_HAVE_NATMC32_READ_RB)
 
6466
#define ETHR_NATMC32_CMPXCHG_FALLBACK_READ__(VAR) \
 
6467
  ETHR_NATMC32_FUNC__(read_rb)(VAR)
 
6468
#elif defined(ETHR_HAVE_NATMC32_READ_WB)
 
6469
#define ETHR_NATMC32_CMPXCHG_FALLBACK_READ__(VAR) \
 
6470
  ETHR_NATMC32_FUNC__(read_wb)(VAR)
 
6471
#elif defined(ETHR_HAVE_NATMC32_READ_ACQB)
 
6472
#define ETHR_NATMC32_CMPXCHG_FALLBACK_READ__(VAR) \
 
6473
  ETHR_NATMC32_FUNC__(read_acqb)(VAR)
 
6474
#elif defined(ETHR_HAVE_NATMC32_READ_RELB)
 
6475
#define ETHR_NATMC32_CMPXCHG_FALLBACK_READ__(VAR) \
 
6476
  ETHR_NATMC32_FUNC__(read_relb)(VAR)
 
6477
#elif defined(ETHR_HAVE_NATMC32_READ_MB)
 
6478
#define ETHR_NATMC32_CMPXCHG_FALLBACK_READ__(VAR) \
 
6479
  ETHR_NATMC32_FUNC__(read_mb)(VAR)
 
6480
#else
 
6481
/*
 
6482
 * We have no native read() op; guess zero and then use the
 
6483
 * the atomics actual value returned from cmpxchg().
 
6484
 */
 
6485
#define ETHR_NATMC32_CMPXCHG_FALLBACK_READ__(VAR) \
 
6486
  ((ETHR_NAINT32_T__) 0)
 
6487
#endif
 
6488
 
 
6489
/*
 
6490
 * Native cmpxchg() fallback used when no native op present.
 
6491
 */
 
6492
#define ETHR_NATMC32_CMPXCHG_FALLBACK__(CMPXCHG, VAR, AVAL, OPS) \
 
6493
do { \
 
6494
    ethr_sint32_t AVAL; \
 
6495
    ETHR_NAINT32_T__ new__, act__, exp__; \
 
6496
    act__ = ETHR_NATMC32_CMPXCHG_FALLBACK_READ__(VAR); \
 
6497
    do { \
 
6498
        exp__ = act__; \
 
6499
        AVAL = (ethr_sint32_t) act__; \
 
6500
        { OPS; } \
 
6501
        new__ = (ETHR_NAINT32_T__) AVAL; \
 
6502
        act__ = CMPXCHG(VAR, new__, exp__); \
 
6503
    } while (__builtin_expect(act__ != exp__, 0)); \
 
6504
} while (0)
 
6505
 
 
6506
 
 
6507
 
 
6508
/* --- addr() --- */
 
6509
 
 
6510
static ETHR_INLINE ethr_sint32_t *ETHR_ATMC32_FUNC__(addr)(ethr_atomic32_t *var)
 
6511
{
 
6512
    return (ethr_sint32_t *) ETHR_NATMC32_ADDR_FUNC__(var);
 
6513
 
 
6514
}
 
6515
 
 
6516
 
 
6517
/* --- cmpxchg() --- */
 
6518
 
 
6519
 
 
6520
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(cmpxchg)(ethr_atomic32_t *var, ethr_sint32_t val, ethr_sint32_t old_val)
 
6521
{
 
6522
    ethr_sint32_t res;
 
6523
#if defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
6524
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6525
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
6526
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_rb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6527
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
6528
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_wb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6529
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
6530
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_acqb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6531
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
6532
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_relb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6533
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
6534
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_mb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6535
#else
 
6536
#error "Missing implementation of ethr_atomic32_cmpxchg()!"
 
6537
#endif
 
6538
    return res;
 
6539
}
 
6540
 
 
6541
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(cmpxchg_rb)(ethr_atomic32_t *var, ethr_sint32_t val, ethr_sint32_t old_val)
 
6542
{
 
6543
    ethr_sint32_t res;
 
6544
#if defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
6545
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_rb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6546
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
6547
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6548
    ETHR_MEMBAR(ETHR_LoadLoad);
 
6549
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
6550
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_mb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6551
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
6552
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_wb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6553
    ETHR_MEMBAR(ETHR_LoadLoad);
 
6554
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
6555
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_acqb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6556
    ETHR_MEMBAR(ETHR_LoadLoad);
 
6557
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
6558
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_relb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6559
    ETHR_MEMBAR(ETHR_LoadLoad);
 
6560
#else
 
6561
#error "Missing implementation of ethr_atomic32_cmpxchg_rb()!"
 
6562
#endif
 
6563
    return res;
 
6564
}
 
6565
 
 
6566
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(cmpxchg_wb)(ethr_atomic32_t *var, ethr_sint32_t val, ethr_sint32_t old_val)
 
6567
{
 
6568
    ethr_sint32_t res;
 
6569
#if defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
6570
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_wb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6571
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
6572
    ETHR_MEMBAR(ETHR_StoreStore);
 
6573
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6574
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
6575
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_mb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6576
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
6577
    ETHR_MEMBAR(ETHR_StoreStore);
 
6578
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_rb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6579
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
6580
    ETHR_MEMBAR(ETHR_StoreStore);
 
6581
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_acqb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6582
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
6583
    ETHR_MEMBAR(ETHR_StoreStore);
 
6584
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_relb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6585
#else
 
6586
#error "Missing implementation of ethr_atomic32_cmpxchg_wb()!"
 
6587
#endif
 
6588
    return res;
 
6589
}
 
6590
 
 
6591
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(cmpxchg_acqb)(ethr_atomic32_t *var, ethr_sint32_t val, ethr_sint32_t old_val)
 
6592
{
 
6593
    ethr_sint32_t res;
 
6594
#if defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
6595
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_acqb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6596
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
6597
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_rb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6598
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6599
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
6600
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6601
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6602
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
6603
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_mb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6604
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
6605
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_wb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6606
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6607
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
6608
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_relb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6609
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6610
#else
 
6611
#error "Missing implementation of ethr_atomic32_cmpxchg_acqb()!"
 
6612
#endif
 
6613
    return res;
 
6614
}
 
6615
 
 
6616
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(cmpxchg_relb)(ethr_atomic32_t *var, ethr_sint32_t val, ethr_sint32_t old_val)
 
6617
{
 
6618
    ethr_sint32_t res;
 
6619
#if defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
6620
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_relb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6621
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
6622
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6623
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_wb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6624
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
6625
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6626
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6627
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
6628
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_mb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6629
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
6630
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6631
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_rb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6632
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
6633
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6634
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_acqb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6635
#else
 
6636
#error "Missing implementation of ethr_atomic32_cmpxchg_relb()!"
 
6637
#endif
 
6638
    return res;
 
6639
}
 
6640
 
 
6641
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(cmpxchg_mb)(ethr_atomic32_t *var, ethr_sint32_t val, ethr_sint32_t old_val)
 
6642
{
 
6643
    ethr_sint32_t res;
 
6644
#if defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
6645
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_mb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6646
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
6647
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_relb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6648
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6649
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
6650
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6651
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_acqb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6652
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
6653
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6654
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_wb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6655
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6656
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
6657
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6658
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg_rb)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6659
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6660
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
6661
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6662
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(cmpxchg)(var, (ETHR_NAINT32_T__) val, (ETHR_NAINT32_T__) old_val);
 
6663
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6664
#else
 
6665
#error "Missing implementation of ethr_atomic32_cmpxchg_mb()!"
 
6666
#endif
 
6667
    return res;
 
6668
}
 
6669
 
 
6670
 
 
6671
/* --- xchg() --- */
 
6672
 
 
6673
 
 
6674
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(xchg)(ethr_atomic32_t *var, ethr_sint32_t val)
 
6675
{
 
6676
    ethr_sint32_t res;
 
6677
#if defined(ETHR_HAVE_NATMC32_XCHG)
 
6678
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg)(var, (ETHR_NAINT32_T__) val);
 
6679
#elif defined(ETHR_HAVE_NATMC32_XCHG_RB)
 
6680
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_rb)(var, (ETHR_NAINT32_T__) val);
 
6681
#elif defined(ETHR_HAVE_NATMC32_XCHG_WB)
 
6682
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_wb)(var, (ETHR_NAINT32_T__) val);
 
6683
#elif defined(ETHR_HAVE_NATMC32_XCHG_ACQB)
 
6684
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_acqb)(var, (ETHR_NAINT32_T__) val);
 
6685
#elif defined(ETHR_HAVE_NATMC32_XCHG_RELB)
 
6686
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_relb)(var, (ETHR_NAINT32_T__) val);
 
6687
#elif defined(ETHR_HAVE_NATMC32_XCHG_MB)
 
6688
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_mb)(var, (ETHR_NAINT32_T__) val);
 
6689
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
6690
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, res = aval; aval = val);
 
6691
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
6692
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, res = aval; aval = val);
 
6693
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
6694
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, res = aval; aval = val);
 
6695
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
6696
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval = val);
 
6697
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
6698
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, res = aval; aval = val);
 
6699
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
6700
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, res = aval; aval = val);
 
6701
#else
 
6702
#error "Missing implementation of ethr_atomic32_xchg()!"
 
6703
#endif
 
6704
    return res;
 
6705
}
 
6706
 
 
6707
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(xchg_rb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
6708
{
 
6709
    ethr_sint32_t res;
 
6710
#if defined(ETHR_HAVE_NATMC32_XCHG_RB)
 
6711
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_rb)(var, (ETHR_NAINT32_T__) val);
 
6712
#elif defined(ETHR_HAVE_NATMC32_XCHG)
 
6713
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg)(var, (ETHR_NAINT32_T__) val);
 
6714
    ETHR_MEMBAR(ETHR_LoadLoad);
 
6715
#elif defined(ETHR_HAVE_NATMC32_XCHG_MB)
 
6716
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_mb)(var, (ETHR_NAINT32_T__) val);
 
6717
#elif defined(ETHR_HAVE_NATMC32_XCHG_WB)
 
6718
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_wb)(var, (ETHR_NAINT32_T__) val);
 
6719
    ETHR_MEMBAR(ETHR_LoadLoad);
 
6720
#elif defined(ETHR_HAVE_NATMC32_XCHG_ACQB)
 
6721
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_acqb)(var, (ETHR_NAINT32_T__) val);
 
6722
    ETHR_MEMBAR(ETHR_LoadLoad);
 
6723
#elif defined(ETHR_HAVE_NATMC32_XCHG_RELB)
 
6724
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_relb)(var, (ETHR_NAINT32_T__) val);
 
6725
    ETHR_MEMBAR(ETHR_LoadLoad);
 
6726
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
6727
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, res = aval; aval = val);
 
6728
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
6729
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, res = aval; aval = val);
 
6730
    ETHR_MEMBAR(ETHR_LoadLoad);
 
6731
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
6732
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, res = aval; aval = val);
 
6733
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
6734
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, res = aval; aval = val);
 
6735
    ETHR_MEMBAR(ETHR_LoadLoad);
 
6736
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
6737
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval = val);
 
6738
    ETHR_MEMBAR(ETHR_LoadLoad);
 
6739
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
6740
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, res = aval; aval = val);
 
6741
    ETHR_MEMBAR(ETHR_LoadLoad);
 
6742
#else
 
6743
#error "Missing implementation of ethr_atomic32_xchg_rb()!"
 
6744
#endif
 
6745
    return res;
 
6746
}
 
6747
 
 
6748
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(xchg_wb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
6749
{
 
6750
    ethr_sint32_t res;
 
6751
#if defined(ETHR_HAVE_NATMC32_XCHG_WB)
 
6752
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_wb)(var, (ETHR_NAINT32_T__) val);
 
6753
#elif defined(ETHR_HAVE_NATMC32_XCHG)
 
6754
    ETHR_MEMBAR(ETHR_StoreStore);
 
6755
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg)(var, (ETHR_NAINT32_T__) val);
 
6756
#elif defined(ETHR_HAVE_NATMC32_XCHG_MB)
 
6757
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_mb)(var, (ETHR_NAINT32_T__) val);
 
6758
#elif defined(ETHR_HAVE_NATMC32_XCHG_RB)
 
6759
    ETHR_MEMBAR(ETHR_StoreStore);
 
6760
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_rb)(var, (ETHR_NAINT32_T__) val);
 
6761
#elif defined(ETHR_HAVE_NATMC32_XCHG_ACQB)
 
6762
    ETHR_MEMBAR(ETHR_StoreStore);
 
6763
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_acqb)(var, (ETHR_NAINT32_T__) val);
 
6764
#elif defined(ETHR_HAVE_NATMC32_XCHG_RELB)
 
6765
    ETHR_MEMBAR(ETHR_StoreStore);
 
6766
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_relb)(var, (ETHR_NAINT32_T__) val);
 
6767
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
6768
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, res = aval; aval = val);
 
6769
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
6770
    ETHR_MEMBAR(ETHR_StoreStore);
 
6771
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, res = aval; aval = val);
 
6772
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
6773
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, res = aval; aval = val);
 
6774
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
6775
    ETHR_MEMBAR(ETHR_StoreStore);
 
6776
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, res = aval; aval = val);
 
6777
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
6778
    ETHR_MEMBAR(ETHR_StoreStore);
 
6779
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval = val);
 
6780
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
6781
    ETHR_MEMBAR(ETHR_StoreStore);
 
6782
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, res = aval; aval = val);
 
6783
#else
 
6784
#error "Missing implementation of ethr_atomic32_xchg_wb()!"
 
6785
#endif
 
6786
    return res;
 
6787
}
 
6788
 
 
6789
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(xchg_acqb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
6790
{
 
6791
    ethr_sint32_t res;
 
6792
#if defined(ETHR_HAVE_NATMC32_XCHG_ACQB)
 
6793
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_acqb)(var, (ETHR_NAINT32_T__) val);
 
6794
#elif defined(ETHR_HAVE_NATMC32_XCHG_RB)
 
6795
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_rb)(var, (ETHR_NAINT32_T__) val);
 
6796
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6797
#elif defined(ETHR_HAVE_NATMC32_XCHG)
 
6798
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg)(var, (ETHR_NAINT32_T__) val);
 
6799
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6800
#elif defined(ETHR_HAVE_NATMC32_XCHG_MB)
 
6801
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_mb)(var, (ETHR_NAINT32_T__) val);
 
6802
#elif defined(ETHR_HAVE_NATMC32_XCHG_WB)
 
6803
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_wb)(var, (ETHR_NAINT32_T__) val);
 
6804
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6805
#elif defined(ETHR_HAVE_NATMC32_XCHG_RELB)
 
6806
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_relb)(var, (ETHR_NAINT32_T__) val);
 
6807
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6808
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
6809
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval = val);
 
6810
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
6811
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, res = aval; aval = val);
 
6812
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6813
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
6814
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, res = aval; aval = val);
 
6815
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6816
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
6817
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, res = aval; aval = val);
 
6818
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
6819
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, res = aval; aval = val);
 
6820
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6821
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
6822
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, res = aval; aval = val);
 
6823
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6824
#else
 
6825
#error "Missing implementation of ethr_atomic32_xchg_acqb()!"
 
6826
#endif
 
6827
    return res;
 
6828
}
 
6829
 
 
6830
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(xchg_relb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
6831
{
 
6832
    ethr_sint32_t res;
 
6833
#if defined(ETHR_HAVE_NATMC32_XCHG_RELB)
 
6834
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_relb)(var, (ETHR_NAINT32_T__) val);
 
6835
#elif defined(ETHR_HAVE_NATMC32_XCHG_WB)
 
6836
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6837
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_wb)(var, (ETHR_NAINT32_T__) val);
 
6838
#elif defined(ETHR_HAVE_NATMC32_XCHG)
 
6839
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6840
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg)(var, (ETHR_NAINT32_T__) val);
 
6841
#elif defined(ETHR_HAVE_NATMC32_XCHG_MB)
 
6842
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_mb)(var, (ETHR_NAINT32_T__) val);
 
6843
#elif defined(ETHR_HAVE_NATMC32_XCHG_RB)
 
6844
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6845
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_rb)(var, (ETHR_NAINT32_T__) val);
 
6846
#elif defined(ETHR_HAVE_NATMC32_XCHG_ACQB)
 
6847
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6848
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_acqb)(var, (ETHR_NAINT32_T__) val);
 
6849
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
6850
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, res = aval; aval = val);
 
6851
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
6852
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6853
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, res = aval; aval = val);
 
6854
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
6855
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6856
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, res = aval; aval = val);
 
6857
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
6858
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, res = aval; aval = val);
 
6859
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
6860
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6861
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, res = aval; aval = val);
 
6862
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
6863
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6864
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval = val);
 
6865
#else
 
6866
#error "Missing implementation of ethr_atomic32_xchg_relb()!"
 
6867
#endif
 
6868
    return res;
 
6869
}
 
6870
 
 
6871
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(xchg_mb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
6872
{
 
6873
    ethr_sint32_t res;
 
6874
#if defined(ETHR_HAVE_NATMC32_XCHG_MB)
 
6875
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_mb)(var, (ETHR_NAINT32_T__) val);
 
6876
#elif defined(ETHR_HAVE_NATMC32_XCHG_RELB)
 
6877
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_relb)(var, (ETHR_NAINT32_T__) val);
 
6878
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6879
#elif defined(ETHR_HAVE_NATMC32_XCHG_ACQB)
 
6880
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6881
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_acqb)(var, (ETHR_NAINT32_T__) val);
 
6882
#elif defined(ETHR_HAVE_NATMC32_XCHG_WB)
 
6883
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6884
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_wb)(var, (ETHR_NAINT32_T__) val);
 
6885
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6886
#elif defined(ETHR_HAVE_NATMC32_XCHG_RB)
 
6887
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6888
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg_rb)(var, (ETHR_NAINT32_T__) val);
 
6889
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6890
#elif defined(ETHR_HAVE_NATMC32_XCHG)
 
6891
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6892
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(xchg)(var, (ETHR_NAINT32_T__) val);
 
6893
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6894
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
6895
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, res = aval; aval = val);
 
6896
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
6897
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, res = aval; aval = val);
 
6898
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6899
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
6900
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6901
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval = val);
 
6902
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
6903
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6904
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, res = aval; aval = val);
 
6905
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6906
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
6907
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6908
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, res = aval; aval = val);
 
6909
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6910
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
6911
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
6912
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, res = aval; aval = val);
 
6913
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
6914
#else
 
6915
#error "Missing implementation of ethr_atomic32_xchg_mb()!"
 
6916
#endif
 
6917
    return res;
 
6918
}
 
6919
 
 
6920
 
 
6921
/* --- set() --- */
 
6922
 
 
6923
 
 
6924
static ETHR_INLINE void ETHR_ATMC32_FUNC__(set)(ethr_atomic32_t *var, ethr_sint32_t val)
 
6925
{
 
6926
#if defined(ETHR_HAVE_NATMC32_SET)
 
6927
    ETHR_NATMC32_FUNC__(set)(var, (ETHR_NAINT32_T__) val);
 
6928
#elif defined(ETHR_HAVE_NATMC32_SET_RB)
 
6929
    ETHR_NATMC32_FUNC__(set_rb)(var, (ETHR_NAINT32_T__) val);
 
6930
#elif defined(ETHR_HAVE_NATMC32_SET_WB)
 
6931
    ETHR_NATMC32_FUNC__(set_wb)(var, (ETHR_NAINT32_T__) val);
 
6932
#elif defined(ETHR_HAVE_NATMC32_SET_ACQB)
 
6933
    ETHR_NATMC32_FUNC__(set_acqb)(var, (ETHR_NAINT32_T__) val);
 
6934
#elif defined(ETHR_HAVE_NATMC32_SET_RELB)
 
6935
    ETHR_NATMC32_FUNC__(set_relb)(var, (ETHR_NAINT32_T__) val);
 
6936
#elif defined(ETHR_HAVE_NATMC32_SET_MB)
 
6937
    ETHR_NATMC32_FUNC__(set_mb)(var, (ETHR_NAINT32_T__) val);
 
6938
#else
 
6939
    (void) ETHR_ATMC32_FUNC__(xchg)(var, val);
 
6940
#endif
 
6941
}
 
6942
 
 
6943
static ETHR_INLINE void ETHR_ATMC32_FUNC__(set_rb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
6944
{
 
6945
#if defined(ETHR_HAVE_NATMC32_SET_RB)
 
6946
    ETHR_NATMC32_FUNC__(set_rb)(var, (ETHR_NAINT32_T__) val);
 
6947
#elif defined(ETHR_HAVE_NATMC32_SET)
 
6948
    ETHR_NATMC32_FUNC__(set)(var, (ETHR_NAINT32_T__) val);
 
6949
    ETHR_MEMBAR(ETHR_LoadLoad);
 
6950
#elif defined(ETHR_HAVE_NATMC32_SET_MB)
 
6951
    ETHR_NATMC32_FUNC__(set_mb)(var, (ETHR_NAINT32_T__) val);
 
6952
#elif defined(ETHR_HAVE_NATMC32_SET_WB)
 
6953
    ETHR_NATMC32_FUNC__(set_wb)(var, (ETHR_NAINT32_T__) val);
 
6954
    ETHR_MEMBAR(ETHR_LoadLoad);
 
6955
#elif defined(ETHR_HAVE_NATMC32_SET_ACQB)
 
6956
    ETHR_NATMC32_FUNC__(set_acqb)(var, (ETHR_NAINT32_T__) val);
 
6957
    ETHR_MEMBAR(ETHR_LoadLoad);
 
6958
#elif defined(ETHR_HAVE_NATMC32_SET_RELB)
 
6959
    ETHR_NATMC32_FUNC__(set_relb)(var, (ETHR_NAINT32_T__) val);
 
6960
    ETHR_MEMBAR(ETHR_LoadLoad);
 
6961
#else
 
6962
    (void) ETHR_ATMC32_FUNC__(xchg_rb)(var, val);
 
6963
#endif
 
6964
}
 
6965
 
 
6966
static ETHR_INLINE void ETHR_ATMC32_FUNC__(set_wb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
6967
{
 
6968
#if defined(ETHR_HAVE_NATMC32_SET_WB)
 
6969
    ETHR_NATMC32_FUNC__(set_wb)(var, (ETHR_NAINT32_T__) val);
 
6970
#elif defined(ETHR_HAVE_NATMC32_SET)
 
6971
    ETHR_MEMBAR(ETHR_StoreStore);
 
6972
    ETHR_NATMC32_FUNC__(set)(var, (ETHR_NAINT32_T__) val);
 
6973
#elif defined(ETHR_HAVE_NATMC32_SET_MB)
 
6974
    ETHR_NATMC32_FUNC__(set_mb)(var, (ETHR_NAINT32_T__) val);
 
6975
#elif defined(ETHR_HAVE_NATMC32_SET_RB)
 
6976
    ETHR_MEMBAR(ETHR_StoreStore);
 
6977
    ETHR_NATMC32_FUNC__(set_rb)(var, (ETHR_NAINT32_T__) val);
 
6978
#elif defined(ETHR_HAVE_NATMC32_SET_ACQB)
 
6979
    ETHR_MEMBAR(ETHR_StoreStore);
 
6980
    ETHR_NATMC32_FUNC__(set_acqb)(var, (ETHR_NAINT32_T__) val);
 
6981
#elif defined(ETHR_HAVE_NATMC32_SET_RELB)
 
6982
    ETHR_MEMBAR(ETHR_StoreStore);
 
6983
    ETHR_NATMC32_FUNC__(set_relb)(var, (ETHR_NAINT32_T__) val);
 
6984
#else
 
6985
    (void) ETHR_ATMC32_FUNC__(xchg_wb)(var, val);
 
6986
#endif
 
6987
}
 
6988
 
 
6989
static ETHR_INLINE void ETHR_ATMC32_FUNC__(set_acqb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
6990
{
 
6991
#if defined(ETHR_HAVE_NATMC32_SET_ACQB)
 
6992
    ETHR_NATMC32_FUNC__(set_acqb)(var, (ETHR_NAINT32_T__) val);
 
6993
#elif defined(ETHR_HAVE_NATMC32_SET_RB)
 
6994
    ETHR_NATMC32_FUNC__(set_rb)(var, (ETHR_NAINT32_T__) val);
 
6995
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
6996
#elif defined(ETHR_HAVE_NATMC32_SET)
 
6997
    ETHR_NATMC32_FUNC__(set)(var, (ETHR_NAINT32_T__) val);
 
6998
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
6999
#elif defined(ETHR_HAVE_NATMC32_SET_MB)
 
7000
    ETHR_NATMC32_FUNC__(set_mb)(var, (ETHR_NAINT32_T__) val);
 
7001
#elif defined(ETHR_HAVE_NATMC32_SET_WB)
 
7002
    ETHR_NATMC32_FUNC__(set_wb)(var, (ETHR_NAINT32_T__) val);
 
7003
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
7004
#elif defined(ETHR_HAVE_NATMC32_SET_RELB)
 
7005
    ETHR_NATMC32_FUNC__(set_relb)(var, (ETHR_NAINT32_T__) val);
 
7006
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
7007
#else
 
7008
    (void) ETHR_ATMC32_FUNC__(xchg_acqb)(var, val);
 
7009
#endif
 
7010
}
 
7011
 
 
7012
static ETHR_INLINE void ETHR_ATMC32_FUNC__(set_relb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
7013
{
 
7014
#if defined(ETHR_HAVE_NATMC32_SET_RELB)
 
7015
    ETHR_NATMC32_FUNC__(set_relb)(var, (ETHR_NAINT32_T__) val);
 
7016
#elif defined(ETHR_HAVE_NATMC32_SET_WB)
 
7017
    ETHR_MEMBAR(ETHR_LoadStore);
 
7018
    ETHR_NATMC32_FUNC__(set_wb)(var, (ETHR_NAINT32_T__) val);
 
7019
#elif defined(ETHR_HAVE_NATMC32_SET)
 
7020
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
7021
    ETHR_NATMC32_FUNC__(set)(var, (ETHR_NAINT32_T__) val);
 
7022
#elif defined(ETHR_HAVE_NATMC32_SET_MB)
 
7023
    ETHR_NATMC32_FUNC__(set_mb)(var, (ETHR_NAINT32_T__) val);
 
7024
#elif defined(ETHR_HAVE_NATMC32_SET_RB)
 
7025
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
7026
    ETHR_NATMC32_FUNC__(set_rb)(var, (ETHR_NAINT32_T__) val);
 
7027
#elif defined(ETHR_HAVE_NATMC32_SET_ACQB)
 
7028
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
7029
    ETHR_NATMC32_FUNC__(set_acqb)(var, (ETHR_NAINT32_T__) val);
 
7030
#else
 
7031
    (void) ETHR_ATMC32_FUNC__(xchg_relb)(var, val);
 
7032
#endif
 
7033
}
 
7034
 
 
7035
static ETHR_INLINE void ETHR_ATMC32_FUNC__(set_mb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
7036
{
 
7037
#if defined(ETHR_HAVE_NATMC32_SET_MB)
 
7038
    ETHR_NATMC32_FUNC__(set_mb)(var, (ETHR_NAINT32_T__) val);
 
7039
#elif defined(ETHR_HAVE_NATMC32_SET_RELB)
 
7040
    ETHR_NATMC32_FUNC__(set_relb)(var, (ETHR_NAINT32_T__) val);
 
7041
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
7042
#elif defined(ETHR_HAVE_NATMC32_SET_ACQB)
 
7043
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
7044
    ETHR_NATMC32_FUNC__(set_acqb)(var, (ETHR_NAINT32_T__) val);
 
7045
#elif defined(ETHR_HAVE_NATMC32_SET_WB)
 
7046
    ETHR_MEMBAR(ETHR_LoadStore);
 
7047
    ETHR_NATMC32_FUNC__(set_wb)(var, (ETHR_NAINT32_T__) val);
 
7048
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
7049
#elif defined(ETHR_HAVE_NATMC32_SET_RB)
 
7050
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
7051
    ETHR_NATMC32_FUNC__(set_rb)(var, (ETHR_NAINT32_T__) val);
 
7052
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
7053
#elif defined(ETHR_HAVE_NATMC32_SET)
 
7054
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
 
7055
    ETHR_NATMC32_FUNC__(set)(var, (ETHR_NAINT32_T__) val);
 
7056
    ETHR_MEMBAR(ETHR_StoreLoad|ETHR_StoreStore);
 
7057
#else
 
7058
    (void) ETHR_ATMC32_FUNC__(xchg_mb)(var, val);
 
7059
#endif
 
7060
}
 
7061
 
 
7062
 
 
7063
/* --- init() --- */
 
7064
 
 
7065
 
 
7066
static ETHR_INLINE void ETHR_ATMC32_FUNC__(init)(ethr_atomic32_t *var, ethr_sint32_t val)
 
7067
{
 
7068
#if defined(ETHR_HAVE_NATMC32_INIT)
 
7069
    ETHR_NATMC32_FUNC__(init)(var, (ETHR_NAINT32_T__) val);
 
7070
#elif defined(ETHR_HAVE_NATMC32_INIT_RB)
 
7071
    ETHR_NATMC32_FUNC__(init_rb)(var, (ETHR_NAINT32_T__) val);
 
7072
#elif defined(ETHR_HAVE_NATMC32_INIT_WB)
 
7073
    ETHR_NATMC32_FUNC__(init_wb)(var, (ETHR_NAINT32_T__) val);
 
7074
#elif defined(ETHR_HAVE_NATMC32_INIT_ACQB)
 
7075
    ETHR_NATMC32_FUNC__(init_acqb)(var, (ETHR_NAINT32_T__) val);
 
7076
#elif defined(ETHR_HAVE_NATMC32_INIT_RELB)
 
7077
    ETHR_NATMC32_FUNC__(init_relb)(var, (ETHR_NAINT32_T__) val);
 
7078
#elif defined(ETHR_HAVE_NATMC32_INIT_MB)
 
7079
    ETHR_NATMC32_FUNC__(init_mb)(var, (ETHR_NAINT32_T__) val);
 
7080
#else
 
7081
    ETHR_ATMC32_FUNC__(set)(var, val);
 
7082
#endif
 
7083
}
 
7084
 
 
7085
static ETHR_INLINE void ETHR_ATMC32_FUNC__(init_rb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
7086
{
 
7087
#if defined(ETHR_HAVE_NATMC32_INIT_RB)
 
7088
    ETHR_NATMC32_FUNC__(init_rb)(var, (ETHR_NAINT32_T__) val);
 
7089
#elif defined(ETHR_HAVE_NATMC32_INIT)
 
7090
    ETHR_NATMC32_FUNC__(init)(var, (ETHR_NAINT32_T__) val);
 
7091
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7092
#elif defined(ETHR_HAVE_NATMC32_INIT_MB)
 
7093
    ETHR_NATMC32_FUNC__(init_mb)(var, (ETHR_NAINT32_T__) val);
 
7094
#elif defined(ETHR_HAVE_NATMC32_INIT_WB)
 
7095
    ETHR_NATMC32_FUNC__(init_wb)(var, (ETHR_NAINT32_T__) val);
 
7096
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7097
#elif defined(ETHR_HAVE_NATMC32_INIT_ACQB)
 
7098
    ETHR_NATMC32_FUNC__(init_acqb)(var, (ETHR_NAINT32_T__) val);
 
7099
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7100
#elif defined(ETHR_HAVE_NATMC32_INIT_RELB)
 
7101
    ETHR_NATMC32_FUNC__(init_relb)(var, (ETHR_NAINT32_T__) val);
 
7102
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7103
#else
 
7104
    ETHR_ATMC32_FUNC__(set_rb)(var, val);
 
7105
#endif
 
7106
}
 
7107
 
 
7108
static ETHR_INLINE void ETHR_ATMC32_FUNC__(init_wb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
7109
{
 
7110
#if defined(ETHR_HAVE_NATMC32_INIT_WB)
 
7111
    ETHR_NATMC32_FUNC__(init_wb)(var, (ETHR_NAINT32_T__) val);
 
7112
#elif defined(ETHR_HAVE_NATMC32_INIT)
 
7113
    ETHR_MEMBAR(ETHR_StoreStore);
 
7114
    ETHR_NATMC32_FUNC__(init)(var, (ETHR_NAINT32_T__) val);
 
7115
#elif defined(ETHR_HAVE_NATMC32_INIT_MB)
 
7116
    ETHR_NATMC32_FUNC__(init_mb)(var, (ETHR_NAINT32_T__) val);
 
7117
#elif defined(ETHR_HAVE_NATMC32_INIT_RB)
 
7118
    ETHR_MEMBAR(ETHR_StoreStore);
 
7119
    ETHR_NATMC32_FUNC__(init_rb)(var, (ETHR_NAINT32_T__) val);
 
7120
#elif defined(ETHR_HAVE_NATMC32_INIT_ACQB)
 
7121
    ETHR_MEMBAR(ETHR_StoreStore);
 
7122
    ETHR_NATMC32_FUNC__(init_acqb)(var, (ETHR_NAINT32_T__) val);
 
7123
#elif defined(ETHR_HAVE_NATMC32_INIT_RELB)
 
7124
    ETHR_MEMBAR(ETHR_StoreStore);
 
7125
    ETHR_NATMC32_FUNC__(init_relb)(var, (ETHR_NAINT32_T__) val);
 
7126
#else
 
7127
    ETHR_ATMC32_FUNC__(set_wb)(var, val);
 
7128
#endif
 
7129
}
 
7130
 
 
7131
static ETHR_INLINE void ETHR_ATMC32_FUNC__(init_acqb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
7132
{
 
7133
#if defined(ETHR_HAVE_NATMC32_INIT_ACQB)
 
7134
    ETHR_NATMC32_FUNC__(init_acqb)(var, (ETHR_NAINT32_T__) val);
 
7135
#elif defined(ETHR_HAVE_NATMC32_INIT_RB)
 
7136
    ETHR_NATMC32_FUNC__(init_rb)(var, (ETHR_NAINT32_T__) val);
 
7137
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7138
#elif defined(ETHR_HAVE_NATMC32_INIT)
 
7139
    ETHR_NATMC32_FUNC__(init)(var, (ETHR_NAINT32_T__) val);
 
7140
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7141
#elif defined(ETHR_HAVE_NATMC32_INIT_MB)
 
7142
    ETHR_NATMC32_FUNC__(init_mb)(var, (ETHR_NAINT32_T__) val);
 
7143
#elif defined(ETHR_HAVE_NATMC32_INIT_WB)
 
7144
    ETHR_NATMC32_FUNC__(init_wb)(var, (ETHR_NAINT32_T__) val);
 
7145
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7146
#elif defined(ETHR_HAVE_NATMC32_INIT_RELB)
 
7147
    ETHR_NATMC32_FUNC__(init_relb)(var, (ETHR_NAINT32_T__) val);
 
7148
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7149
#else
 
7150
    ETHR_ATMC32_FUNC__(set_acqb)(var, val);
 
7151
#endif
 
7152
}
 
7153
 
 
7154
static ETHR_INLINE void ETHR_ATMC32_FUNC__(init_relb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
7155
{
 
7156
#if defined(ETHR_HAVE_NATMC32_INIT_RELB)
 
7157
    ETHR_NATMC32_FUNC__(init_relb)(var, (ETHR_NAINT32_T__) val);
 
7158
#elif defined(ETHR_HAVE_NATMC32_INIT_WB)
 
7159
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad);
 
7160
    ETHR_NATMC32_FUNC__(init_wb)(var, (ETHR_NAINT32_T__) val);
 
7161
#elif defined(ETHR_HAVE_NATMC32_INIT)
 
7162
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7163
    ETHR_NATMC32_FUNC__(init)(var, (ETHR_NAINT32_T__) val);
 
7164
#elif defined(ETHR_HAVE_NATMC32_INIT_MB)
 
7165
    ETHR_NATMC32_FUNC__(init_mb)(var, (ETHR_NAINT32_T__) val);
 
7166
#elif defined(ETHR_HAVE_NATMC32_INIT_RB)
 
7167
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7168
    ETHR_NATMC32_FUNC__(init_rb)(var, (ETHR_NAINT32_T__) val);
 
7169
#elif defined(ETHR_HAVE_NATMC32_INIT_ACQB)
 
7170
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7171
    ETHR_NATMC32_FUNC__(init_acqb)(var, (ETHR_NAINT32_T__) val);
 
7172
#else
 
7173
    ETHR_ATMC32_FUNC__(set_relb)(var, val);
 
7174
#endif
 
7175
}
 
7176
 
 
7177
static ETHR_INLINE void ETHR_ATMC32_FUNC__(init_mb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
7178
{
 
7179
#if defined(ETHR_HAVE_NATMC32_INIT_MB)
 
7180
    ETHR_NATMC32_FUNC__(init_mb)(var, (ETHR_NAINT32_T__) val);
 
7181
#elif defined(ETHR_HAVE_NATMC32_INIT_RELB)
 
7182
    ETHR_NATMC32_FUNC__(init_relb)(var, (ETHR_NAINT32_T__) val);
 
7183
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7184
#elif defined(ETHR_HAVE_NATMC32_INIT_ACQB)
 
7185
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7186
    ETHR_NATMC32_FUNC__(init_acqb)(var, (ETHR_NAINT32_T__) val);
 
7187
#elif defined(ETHR_HAVE_NATMC32_INIT_WB)
 
7188
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad);
 
7189
    ETHR_NATMC32_FUNC__(init_wb)(var, (ETHR_NAINT32_T__) val);
 
7190
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7191
#elif defined(ETHR_HAVE_NATMC32_INIT_RB)
 
7192
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7193
    ETHR_NATMC32_FUNC__(init_rb)(var, (ETHR_NAINT32_T__) val);
 
7194
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7195
#elif defined(ETHR_HAVE_NATMC32_INIT)
 
7196
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7197
    ETHR_NATMC32_FUNC__(init)(var, (ETHR_NAINT32_T__) val);
 
7198
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7199
#else
 
7200
    ETHR_ATMC32_FUNC__(set_mb)(var, val);
 
7201
#endif
 
7202
}
 
7203
 
 
7204
 
 
7205
/* --- add_read() --- */
 
7206
 
 
7207
 
 
7208
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(add_read)(ethr_atomic32_t *var, ethr_sint32_t val)
 
7209
{
 
7210
    ethr_sint32_t res;
 
7211
#if defined(ETHR_HAVE_NATMC32_ADD_RETURN)
 
7212
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return)(var, (ETHR_NAINT32_T__) val);
 
7213
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_RB)
 
7214
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_rb)(var, (ETHR_NAINT32_T__) val);
 
7215
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_WB)
 
7216
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_wb)(var, (ETHR_NAINT32_T__) val);
 
7217
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_ACQB)
 
7218
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_acqb)(var, (ETHR_NAINT32_T__) val);
 
7219
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_RELB)
 
7220
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_relb)(var, (ETHR_NAINT32_T__) val);
 
7221
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_MB)
 
7222
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_mb)(var, (ETHR_NAINT32_T__) val);
 
7223
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
7224
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, aval += val; res = aval);
 
7225
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
7226
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, aval += val; res = aval);
 
7227
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
7228
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, aval += val; res = aval);
 
7229
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
7230
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, aval += val; res = aval);
 
7231
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
7232
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, aval += val; res = aval);
 
7233
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
7234
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, aval += val; res = aval);
 
7235
#else
 
7236
#error "Missing implementation of ethr_atomic32_add_read()!"
 
7237
#endif
 
7238
    return res;
 
7239
}
 
7240
 
 
7241
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(add_read_rb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
7242
{
 
7243
    ethr_sint32_t res;
 
7244
#if defined(ETHR_HAVE_NATMC32_ADD_RETURN_RB)
 
7245
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_rb)(var, (ETHR_NAINT32_T__) val);
 
7246
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN)
 
7247
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return)(var, (ETHR_NAINT32_T__) val);
 
7248
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7249
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_MB)
 
7250
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_mb)(var, (ETHR_NAINT32_T__) val);
 
7251
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_WB)
 
7252
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_wb)(var, (ETHR_NAINT32_T__) val);
 
7253
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7254
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_ACQB)
 
7255
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_acqb)(var, (ETHR_NAINT32_T__) val);
 
7256
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7257
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_RELB)
 
7258
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_relb)(var, (ETHR_NAINT32_T__) val);
 
7259
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7260
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
7261
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, aval += val; res = aval);
 
7262
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
7263
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, aval += val; res = aval);
 
7264
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7265
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
7266
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, aval += val; res = aval);
 
7267
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
7268
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, aval += val; res = aval);
 
7269
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7270
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
7271
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, aval += val; res = aval);
 
7272
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7273
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
7274
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, aval += val; res = aval);
 
7275
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7276
#else
 
7277
#error "Missing implementation of ethr_atomic32_add_read_rb()!"
 
7278
#endif
 
7279
    return res;
 
7280
}
 
7281
 
 
7282
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(add_read_wb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
7283
{
 
7284
    ethr_sint32_t res;
 
7285
#if defined(ETHR_HAVE_NATMC32_ADD_RETURN_WB)
 
7286
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_wb)(var, (ETHR_NAINT32_T__) val);
 
7287
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN)
 
7288
    ETHR_MEMBAR(ETHR_StoreStore);
 
7289
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return)(var, (ETHR_NAINT32_T__) val);
 
7290
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_MB)
 
7291
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_mb)(var, (ETHR_NAINT32_T__) val);
 
7292
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_RB)
 
7293
    ETHR_MEMBAR(ETHR_StoreStore);
 
7294
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_rb)(var, (ETHR_NAINT32_T__) val);
 
7295
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_ACQB)
 
7296
    ETHR_MEMBAR(ETHR_StoreStore);
 
7297
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_acqb)(var, (ETHR_NAINT32_T__) val);
 
7298
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_RELB)
 
7299
    ETHR_MEMBAR(ETHR_StoreStore);
 
7300
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_relb)(var, (ETHR_NAINT32_T__) val);
 
7301
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
7302
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, aval += val; res = aval);
 
7303
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
7304
    ETHR_MEMBAR(ETHR_StoreStore);
 
7305
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, aval += val; res = aval);
 
7306
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
7307
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, aval += val; res = aval);
 
7308
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
7309
    ETHR_MEMBAR(ETHR_StoreStore);
 
7310
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, aval += val; res = aval);
 
7311
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
7312
    ETHR_MEMBAR(ETHR_StoreStore);
 
7313
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, aval += val; res = aval);
 
7314
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
7315
    ETHR_MEMBAR(ETHR_StoreStore);
 
7316
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, aval += val; res = aval);
 
7317
#else
 
7318
#error "Missing implementation of ethr_atomic32_add_read_wb()!"
 
7319
#endif
 
7320
    return res;
 
7321
}
 
7322
 
 
7323
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(add_read_acqb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
7324
{
 
7325
    ethr_sint32_t res;
 
7326
#if defined(ETHR_HAVE_NATMC32_ADD_RETURN_ACQB)
 
7327
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_acqb)(var, (ETHR_NAINT32_T__) val);
 
7328
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_RB)
 
7329
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_rb)(var, (ETHR_NAINT32_T__) val);
 
7330
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7331
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN)
 
7332
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return)(var, (ETHR_NAINT32_T__) val);
 
7333
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7334
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_MB)
 
7335
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_mb)(var, (ETHR_NAINT32_T__) val);
 
7336
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_WB)
 
7337
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_wb)(var, (ETHR_NAINT32_T__) val);
 
7338
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7339
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_RELB)
 
7340
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_relb)(var, (ETHR_NAINT32_T__) val);
 
7341
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7342
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
7343
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, aval += val; res = aval);
 
7344
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
7345
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, aval += val; res = aval);
 
7346
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7347
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
7348
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, aval += val; res = aval);
 
7349
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7350
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
7351
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, aval += val; res = aval);
 
7352
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
7353
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, aval += val; res = aval);
 
7354
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7355
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
7356
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, aval += val; res = aval);
 
7357
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7358
#else
 
7359
#error "Missing implementation of ethr_atomic32_add_read_acqb()!"
 
7360
#endif
 
7361
    return res;
 
7362
}
 
7363
 
 
7364
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(add_read_relb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
7365
{
 
7366
    ethr_sint32_t res;
 
7367
#if defined(ETHR_HAVE_NATMC32_ADD_RETURN_RELB)
 
7368
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_relb)(var, (ETHR_NAINT32_T__) val);
 
7369
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_WB)
 
7370
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7371
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_wb)(var, (ETHR_NAINT32_T__) val);
 
7372
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN)
 
7373
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7374
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return)(var, (ETHR_NAINT32_T__) val);
 
7375
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_MB)
 
7376
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_mb)(var, (ETHR_NAINT32_T__) val);
 
7377
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_RB)
 
7378
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7379
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_rb)(var, (ETHR_NAINT32_T__) val);
 
7380
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_ACQB)
 
7381
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7382
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_acqb)(var, (ETHR_NAINT32_T__) val);
 
7383
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
7384
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, aval += val; res = aval);
 
7385
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
7386
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7387
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, aval += val; res = aval);
 
7388
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
7389
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7390
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, aval += val; res = aval);
 
7391
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
7392
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, aval += val; res = aval);
 
7393
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
7394
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7395
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, aval += val; res = aval);
 
7396
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
7397
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7398
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, aval += val; res = aval);
 
7399
#else
 
7400
#error "Missing implementation of ethr_atomic32_add_read_relb()!"
 
7401
#endif
 
7402
    return res;
 
7403
}
 
7404
 
 
7405
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(add_read_mb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
7406
{
 
7407
    ethr_sint32_t res;
 
7408
#if defined(ETHR_HAVE_NATMC32_ADD_RETURN_MB)
 
7409
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_mb)(var, (ETHR_NAINT32_T__) val);
 
7410
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_RELB)
 
7411
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_relb)(var, (ETHR_NAINT32_T__) val);
 
7412
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7413
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_ACQB)
 
7414
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7415
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_acqb)(var, (ETHR_NAINT32_T__) val);
 
7416
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_WB)
 
7417
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7418
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_wb)(var, (ETHR_NAINT32_T__) val);
 
7419
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7420
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN_RB)
 
7421
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7422
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return_rb)(var, (ETHR_NAINT32_T__) val);
 
7423
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7424
#elif defined(ETHR_HAVE_NATMC32_ADD_RETURN)
 
7425
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7426
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(add_return)(var, (ETHR_NAINT32_T__) val);
 
7427
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7428
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
7429
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, aval += val; res = aval);
 
7430
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
7431
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, aval += val; res = aval);
 
7432
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7433
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
7434
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7435
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, aval += val; res = aval);
 
7436
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
7437
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7438
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, aval += val; res = aval);
 
7439
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7440
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
7441
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7442
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, aval += val; res = aval);
 
7443
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7444
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
7445
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7446
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, aval += val; res = aval);
 
7447
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7448
#else
 
7449
#error "Missing implementation of ethr_atomic32_add_read_mb()!"
 
7450
#endif
 
7451
    return res;
 
7452
}
 
7453
 
 
7454
 
 
7455
/* --- read() --- */
 
7456
 
 
7457
 
 
7458
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(read)(ethr_atomic32_t *var)
 
7459
{
 
7460
    ethr_sint32_t res;
 
7461
#if defined(ETHR_HAVE_NATMC32_READ)
 
7462
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read)(var);
 
7463
#elif defined(ETHR_HAVE_NATMC32_READ_RB)
 
7464
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_rb)(var);
 
7465
#elif defined(ETHR_HAVE_NATMC32_READ_WB)
 
7466
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_wb)(var);
 
7467
#elif defined(ETHR_HAVE_NATMC32_READ_ACQB)
 
7468
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_acqb)(var);
 
7469
#elif defined(ETHR_HAVE_NATMC32_READ_RELB)
 
7470
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_relb)(var);
 
7471
#elif defined(ETHR_HAVE_NATMC32_READ_MB)
 
7472
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_mb)(var);
 
7473
#else
 
7474
    res = ETHR_ATMC32_FUNC__(cmpxchg)(var, (ethr_sint32_t) ETHR_UNUSUAL_SINT32_VAL__, (ethr_sint32_t) ETHR_UNUSUAL_SINT32_VAL__);
 
7475
#endif
 
7476
    return res;
 
7477
}
 
7478
 
 
7479
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(read_rb)(ethr_atomic32_t *var)
 
7480
{
 
7481
    ethr_sint32_t res;
 
7482
#if defined(ETHR_HAVE_NATMC32_READ_RB)
 
7483
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_rb)(var);
 
7484
#elif defined(ETHR_HAVE_NATMC32_READ)
 
7485
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read)(var);
 
7486
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7487
#elif defined(ETHR_HAVE_NATMC32_READ_MB)
 
7488
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_mb)(var);
 
7489
#elif defined(ETHR_HAVE_NATMC32_READ_WB)
 
7490
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_wb)(var);
 
7491
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7492
#elif defined(ETHR_HAVE_NATMC32_READ_ACQB)
 
7493
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_acqb)(var);
 
7494
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7495
#elif defined(ETHR_HAVE_NATMC32_READ_RELB)
 
7496
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_relb)(var);
 
7497
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7498
#else
 
7499
    res = ETHR_ATMC32_FUNC__(cmpxchg_rb)(var, (ethr_sint32_t) ETHR_UNUSUAL_SINT32_VAL__, (ethr_sint32_t) ETHR_UNUSUAL_SINT32_VAL__);
 
7500
#endif
 
7501
    return res;
 
7502
}
 
7503
 
 
7504
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(read_wb)(ethr_atomic32_t *var)
 
7505
{
 
7506
    ethr_sint32_t res;
 
7507
#if defined(ETHR_HAVE_NATMC32_READ_WB)
 
7508
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_wb)(var);
 
7509
#elif defined(ETHR_HAVE_NATMC32_READ)
 
7510
    ETHR_MEMBAR(ETHR_StoreStore);
 
7511
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read)(var);
 
7512
#elif defined(ETHR_HAVE_NATMC32_READ_MB)
 
7513
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_mb)(var);
 
7514
#elif defined(ETHR_HAVE_NATMC32_READ_RB)
 
7515
    ETHR_MEMBAR(ETHR_StoreStore);
 
7516
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_rb)(var);
 
7517
#elif defined(ETHR_HAVE_NATMC32_READ_ACQB)
 
7518
    ETHR_MEMBAR(ETHR_StoreStore);
 
7519
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_acqb)(var);
 
7520
#elif defined(ETHR_HAVE_NATMC32_READ_RELB)
 
7521
    ETHR_MEMBAR(ETHR_StoreStore);
 
7522
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_relb)(var);
 
7523
#else
 
7524
    res = ETHR_ATMC32_FUNC__(cmpxchg_wb)(var, (ethr_sint32_t) ETHR_UNUSUAL_SINT32_VAL__, (ethr_sint32_t) ETHR_UNUSUAL_SINT32_VAL__);
 
7525
#endif
 
7526
    return res;
 
7527
}
 
7528
 
 
7529
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(read_acqb)(ethr_atomic32_t *var)
 
7530
{
 
7531
    ethr_sint32_t res;
 
7532
#if defined(ETHR_HAVE_NATMC32_READ_ACQB)
 
7533
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_acqb)(var);
 
7534
#elif defined(ETHR_HAVE_NATMC32_READ_RB)
 
7535
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_rb)(var);
 
7536
    ETHR_MEMBAR(ETHR_LoadStore);
 
7537
#elif defined(ETHR_HAVE_NATMC32_READ)
 
7538
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read)(var);
 
7539
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
7540
#elif defined(ETHR_HAVE_NATMC32_READ_MB)
 
7541
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_mb)(var);
 
7542
#elif defined(ETHR_HAVE_NATMC32_READ_WB)
 
7543
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_wb)(var);
 
7544
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
7545
#elif defined(ETHR_HAVE_NATMC32_READ_RELB)
 
7546
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_relb)(var);
 
7547
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
7548
#else
 
7549
    res = ETHR_ATMC32_FUNC__(cmpxchg_acqb)(var, (ethr_sint32_t) ETHR_UNUSUAL_SINT32_VAL__, (ethr_sint32_t) ETHR_UNUSUAL_SINT32_VAL__);
 
7550
#endif
 
7551
    return res;
 
7552
}
 
7553
 
 
7554
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(read_relb)(ethr_atomic32_t *var)
 
7555
{
 
7556
    ethr_sint32_t res;
 
7557
#if defined(ETHR_HAVE_NATMC32_READ_RELB)
 
7558
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_relb)(var);
 
7559
#elif defined(ETHR_HAVE_NATMC32_READ_WB)
 
7560
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7561
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_wb)(var);
 
7562
#elif defined(ETHR_HAVE_NATMC32_READ)
 
7563
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7564
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read)(var);
 
7565
#elif defined(ETHR_HAVE_NATMC32_READ_MB)
 
7566
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_mb)(var);
 
7567
#elif defined(ETHR_HAVE_NATMC32_READ_RB)
 
7568
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7569
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_rb)(var);
 
7570
#elif defined(ETHR_HAVE_NATMC32_READ_ACQB)
 
7571
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7572
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_acqb)(var);
 
7573
#else
 
7574
    res = ETHR_ATMC32_FUNC__(cmpxchg_relb)(var, (ethr_sint32_t) ETHR_UNUSUAL_SINT32_VAL__, (ethr_sint32_t) ETHR_UNUSUAL_SINT32_VAL__);
 
7575
#endif
 
7576
    return res;
 
7577
}
 
7578
 
 
7579
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(read_mb)(ethr_atomic32_t *var)
 
7580
{
 
7581
    ethr_sint32_t res;
 
7582
#if defined(ETHR_HAVE_NATMC32_READ_MB)
 
7583
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_mb)(var);
 
7584
#elif defined(ETHR_HAVE_NATMC32_READ_RELB)
 
7585
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_relb)(var);
 
7586
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
7587
#elif defined(ETHR_HAVE_NATMC32_READ_ACQB)
 
7588
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7589
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_acqb)(var);
 
7590
#elif defined(ETHR_HAVE_NATMC32_READ_WB)
 
7591
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7592
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_wb)(var);
 
7593
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
7594
#elif defined(ETHR_HAVE_NATMC32_READ_RB)
 
7595
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7596
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read_rb)(var);
 
7597
    ETHR_MEMBAR(ETHR_LoadStore);
 
7598
#elif defined(ETHR_HAVE_NATMC32_READ)
 
7599
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7600
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(read)(var);
 
7601
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore);
 
7602
#else
 
7603
    res = ETHR_ATMC32_FUNC__(cmpxchg_mb)(var, (ethr_sint32_t) ETHR_UNUSUAL_SINT32_VAL__, (ethr_sint32_t) ETHR_UNUSUAL_SINT32_VAL__);
 
7604
#endif
 
7605
    return res;
 
7606
}
 
7607
 
 
7608
 
 
7609
/* --- inc_read() --- */
 
7610
 
 
7611
 
 
7612
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(inc_read)(ethr_atomic32_t *var)
 
7613
{
 
7614
    ethr_sint32_t res;
 
7615
#if defined(ETHR_HAVE_NATMC32_INC_RETURN)
 
7616
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return)(var);
 
7617
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_RB)
 
7618
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_rb)(var);
 
7619
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_WB)
 
7620
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_wb)(var);
 
7621
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_ACQB)
 
7622
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_acqb)(var);
 
7623
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_RELB)
 
7624
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_relb)(var);
 
7625
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_MB)
 
7626
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_mb)(var);
 
7627
#else
 
7628
    res = ETHR_ATMC32_FUNC__(add_read)(var, (ethr_sint32_t) 1);
 
7629
#endif
 
7630
    return res;
 
7631
}
 
7632
 
 
7633
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(inc_read_rb)(ethr_atomic32_t *var)
 
7634
{
 
7635
    ethr_sint32_t res;
 
7636
#if defined(ETHR_HAVE_NATMC32_INC_RETURN_RB)
 
7637
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_rb)(var);
 
7638
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN)
 
7639
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return)(var);
 
7640
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7641
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_MB)
 
7642
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_mb)(var);
 
7643
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_WB)
 
7644
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_wb)(var);
 
7645
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7646
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_ACQB)
 
7647
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_acqb)(var);
 
7648
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7649
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_RELB)
 
7650
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_relb)(var);
 
7651
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7652
#else
 
7653
    res = ETHR_ATMC32_FUNC__(add_read_rb)(var, (ethr_sint32_t) 1);
 
7654
#endif
 
7655
    return res;
 
7656
}
 
7657
 
 
7658
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(inc_read_wb)(ethr_atomic32_t *var)
 
7659
{
 
7660
    ethr_sint32_t res;
 
7661
#if defined(ETHR_HAVE_NATMC32_INC_RETURN_WB)
 
7662
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_wb)(var);
 
7663
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN)
 
7664
    ETHR_MEMBAR(ETHR_StoreStore);
 
7665
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return)(var);
 
7666
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_MB)
 
7667
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_mb)(var);
 
7668
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_RB)
 
7669
    ETHR_MEMBAR(ETHR_StoreStore);
 
7670
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_rb)(var);
 
7671
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_ACQB)
 
7672
    ETHR_MEMBAR(ETHR_StoreStore);
 
7673
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_acqb)(var);
 
7674
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_RELB)
 
7675
    ETHR_MEMBAR(ETHR_StoreStore);
 
7676
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_relb)(var);
 
7677
#else
 
7678
    res = ETHR_ATMC32_FUNC__(add_read_wb)(var, (ethr_sint32_t) 1);
 
7679
#endif
 
7680
    return res;
 
7681
}
 
7682
 
 
7683
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(inc_read_acqb)(ethr_atomic32_t *var)
 
7684
{
 
7685
    ethr_sint32_t res;
 
7686
#if defined(ETHR_HAVE_NATMC32_INC_RETURN_ACQB)
 
7687
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_acqb)(var);
 
7688
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_RB)
 
7689
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_rb)(var);
 
7690
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7691
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN)
 
7692
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return)(var);
 
7693
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7694
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_MB)
 
7695
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_mb)(var);
 
7696
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_WB)
 
7697
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_wb)(var);
 
7698
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7699
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_RELB)
 
7700
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_relb)(var);
 
7701
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7702
#else
 
7703
    res = ETHR_ATMC32_FUNC__(add_read_acqb)(var, (ethr_sint32_t) 1);
 
7704
#endif
 
7705
    return res;
 
7706
}
 
7707
 
 
7708
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(inc_read_relb)(ethr_atomic32_t *var)
 
7709
{
 
7710
    ethr_sint32_t res;
 
7711
#if defined(ETHR_HAVE_NATMC32_INC_RETURN_RELB)
 
7712
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_relb)(var);
 
7713
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_WB)
 
7714
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7715
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_wb)(var);
 
7716
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN)
 
7717
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7718
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return)(var);
 
7719
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_MB)
 
7720
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_mb)(var);
 
7721
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_RB)
 
7722
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7723
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_rb)(var);
 
7724
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_ACQB)
 
7725
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7726
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_acqb)(var);
 
7727
#else
 
7728
    res = ETHR_ATMC32_FUNC__(add_read_relb)(var, (ethr_sint32_t) 1);
 
7729
#endif
 
7730
    return res;
 
7731
}
 
7732
 
 
7733
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(inc_read_mb)(ethr_atomic32_t *var)
 
7734
{
 
7735
    ethr_sint32_t res;
 
7736
#if defined(ETHR_HAVE_NATMC32_INC_RETURN_MB)
 
7737
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_mb)(var);
 
7738
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_RELB)
 
7739
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_relb)(var);
 
7740
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7741
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_ACQB)
 
7742
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7743
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_acqb)(var);
 
7744
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_WB)
 
7745
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7746
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_wb)(var);
 
7747
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7748
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN_RB)
 
7749
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7750
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return_rb)(var);
 
7751
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7752
#elif defined(ETHR_HAVE_NATMC32_INC_RETURN)
 
7753
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7754
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(inc_return)(var);
 
7755
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7756
#else
 
7757
    res = ETHR_ATMC32_FUNC__(add_read_mb)(var, (ethr_sint32_t) 1);
 
7758
#endif
 
7759
    return res;
 
7760
}
 
7761
 
 
7762
 
 
7763
/* --- dec_read() --- */
 
7764
 
 
7765
 
 
7766
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(dec_read)(ethr_atomic32_t *var)
 
7767
{
 
7768
    ethr_sint32_t res;
 
7769
#if defined(ETHR_HAVE_NATMC32_DEC_RETURN)
 
7770
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return)(var);
 
7771
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_RB)
 
7772
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_rb)(var);
 
7773
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_WB)
 
7774
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_wb)(var);
 
7775
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_ACQB)
 
7776
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_acqb)(var);
 
7777
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_RELB)
 
7778
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_relb)(var);
 
7779
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_MB)
 
7780
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_mb)(var);
 
7781
#else
 
7782
    res = ETHR_ATMC32_FUNC__(add_read)(var, (ethr_sint32_t) -1);
 
7783
#endif
 
7784
    return res;
 
7785
}
 
7786
 
 
7787
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(dec_read_rb)(ethr_atomic32_t *var)
 
7788
{
 
7789
    ethr_sint32_t res;
 
7790
#if defined(ETHR_HAVE_NATMC32_DEC_RETURN_RB)
 
7791
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_rb)(var);
 
7792
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN)
 
7793
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return)(var);
 
7794
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7795
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_MB)
 
7796
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_mb)(var);
 
7797
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_WB)
 
7798
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_wb)(var);
 
7799
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7800
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_ACQB)
 
7801
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_acqb)(var);
 
7802
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7803
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_RELB)
 
7804
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_relb)(var);
 
7805
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7806
#else
 
7807
    res = ETHR_ATMC32_FUNC__(add_read_rb)(var, (ethr_sint32_t) -1);
 
7808
#endif
 
7809
    return res;
 
7810
}
 
7811
 
 
7812
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(dec_read_wb)(ethr_atomic32_t *var)
 
7813
{
 
7814
    ethr_sint32_t res;
 
7815
#if defined(ETHR_HAVE_NATMC32_DEC_RETURN_WB)
 
7816
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_wb)(var);
 
7817
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN)
 
7818
    ETHR_MEMBAR(ETHR_StoreStore);
 
7819
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return)(var);
 
7820
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_MB)
 
7821
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_mb)(var);
 
7822
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_RB)
 
7823
    ETHR_MEMBAR(ETHR_StoreStore);
 
7824
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_rb)(var);
 
7825
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_ACQB)
 
7826
    ETHR_MEMBAR(ETHR_StoreStore);
 
7827
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_acqb)(var);
 
7828
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_RELB)
 
7829
    ETHR_MEMBAR(ETHR_StoreStore);
 
7830
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_relb)(var);
 
7831
#else
 
7832
    res = ETHR_ATMC32_FUNC__(add_read_wb)(var, (ethr_sint32_t) -1);
 
7833
#endif
 
7834
    return res;
 
7835
}
 
7836
 
 
7837
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(dec_read_acqb)(ethr_atomic32_t *var)
 
7838
{
 
7839
    ethr_sint32_t res;
 
7840
#if defined(ETHR_HAVE_NATMC32_DEC_RETURN_ACQB)
 
7841
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_acqb)(var);
 
7842
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_RB)
 
7843
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_rb)(var);
 
7844
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7845
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN)
 
7846
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return)(var);
 
7847
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7848
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_MB)
 
7849
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_mb)(var);
 
7850
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_WB)
 
7851
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_wb)(var);
 
7852
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7853
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_RELB)
 
7854
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_relb)(var);
 
7855
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7856
#else
 
7857
    res = ETHR_ATMC32_FUNC__(add_read_acqb)(var, (ethr_sint32_t) -1);
 
7858
#endif
 
7859
    return res;
 
7860
}
 
7861
 
 
7862
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(dec_read_relb)(ethr_atomic32_t *var)
 
7863
{
 
7864
    ethr_sint32_t res;
 
7865
#if defined(ETHR_HAVE_NATMC32_DEC_RETURN_RELB)
 
7866
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_relb)(var);
 
7867
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_WB)
 
7868
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7869
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_wb)(var);
 
7870
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN)
 
7871
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7872
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return)(var);
 
7873
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_MB)
 
7874
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_mb)(var);
 
7875
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_RB)
 
7876
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7877
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_rb)(var);
 
7878
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_ACQB)
 
7879
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7880
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_acqb)(var);
 
7881
#else
 
7882
    res = ETHR_ATMC32_FUNC__(add_read_relb)(var, (ethr_sint32_t) -1);
 
7883
#endif
 
7884
    return res;
 
7885
}
 
7886
 
 
7887
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(dec_read_mb)(ethr_atomic32_t *var)
 
7888
{
 
7889
    ethr_sint32_t res;
 
7890
#if defined(ETHR_HAVE_NATMC32_DEC_RETURN_MB)
 
7891
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_mb)(var);
 
7892
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_RELB)
 
7893
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_relb)(var);
 
7894
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7895
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_ACQB)
 
7896
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7897
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_acqb)(var);
 
7898
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_WB)
 
7899
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7900
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_wb)(var);
 
7901
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7902
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN_RB)
 
7903
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7904
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return_rb)(var);
 
7905
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7906
#elif defined(ETHR_HAVE_NATMC32_DEC_RETURN)
 
7907
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
7908
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(dec_return)(var);
 
7909
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7910
#else
 
7911
    res = ETHR_ATMC32_FUNC__(add_read_mb)(var, (ethr_sint32_t) -1);
 
7912
#endif
 
7913
    return res;
 
7914
}
 
7915
 
 
7916
 
 
7917
/* --- add() --- */
 
7918
 
 
7919
 
 
7920
static ETHR_INLINE void ETHR_ATMC32_FUNC__(add)(ethr_atomic32_t *var, ethr_sint32_t val)
 
7921
{
 
7922
#if defined(ETHR_HAVE_NATMC32_ADD)
 
7923
    ETHR_NATMC32_FUNC__(add)(var, (ETHR_NAINT32_T__) val);
 
7924
#elif defined(ETHR_HAVE_NATMC32_ADD_RB)
 
7925
    ETHR_NATMC32_FUNC__(add_rb)(var, (ETHR_NAINT32_T__) val);
 
7926
#elif defined(ETHR_HAVE_NATMC32_ADD_WB)
 
7927
    ETHR_NATMC32_FUNC__(add_wb)(var, (ETHR_NAINT32_T__) val);
 
7928
#elif defined(ETHR_HAVE_NATMC32_ADD_ACQB)
 
7929
    ETHR_NATMC32_FUNC__(add_acqb)(var, (ETHR_NAINT32_T__) val);
 
7930
#elif defined(ETHR_HAVE_NATMC32_ADD_RELB)
 
7931
    ETHR_NATMC32_FUNC__(add_relb)(var, (ETHR_NAINT32_T__) val);
 
7932
#elif defined(ETHR_HAVE_NATMC32_ADD_MB)
 
7933
    ETHR_NATMC32_FUNC__(add_mb)(var, (ETHR_NAINT32_T__) val);
 
7934
#else
 
7935
    (void) ETHR_ATMC32_FUNC__(add_read)(var, val);
 
7936
#endif
 
7937
}
 
7938
 
 
7939
static ETHR_INLINE void ETHR_ATMC32_FUNC__(add_rb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
7940
{
 
7941
#if defined(ETHR_HAVE_NATMC32_ADD_RB)
 
7942
    ETHR_NATMC32_FUNC__(add_rb)(var, (ETHR_NAINT32_T__) val);
 
7943
#elif defined(ETHR_HAVE_NATMC32_ADD)
 
7944
    ETHR_NATMC32_FUNC__(add)(var, (ETHR_NAINT32_T__) val);
 
7945
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7946
#elif defined(ETHR_HAVE_NATMC32_ADD_MB)
 
7947
    ETHR_NATMC32_FUNC__(add_mb)(var, (ETHR_NAINT32_T__) val);
 
7948
#elif defined(ETHR_HAVE_NATMC32_ADD_WB)
 
7949
    ETHR_NATMC32_FUNC__(add_wb)(var, (ETHR_NAINT32_T__) val);
 
7950
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7951
#elif defined(ETHR_HAVE_NATMC32_ADD_ACQB)
 
7952
    ETHR_NATMC32_FUNC__(add_acqb)(var, (ETHR_NAINT32_T__) val);
 
7953
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7954
#elif defined(ETHR_HAVE_NATMC32_ADD_RELB)
 
7955
    ETHR_NATMC32_FUNC__(add_relb)(var, (ETHR_NAINT32_T__) val);
 
7956
    ETHR_MEMBAR(ETHR_LoadLoad);
 
7957
#else
 
7958
    (void) ETHR_ATMC32_FUNC__(add_read_rb)(var, val);
 
7959
#endif
 
7960
}
 
7961
 
 
7962
static ETHR_INLINE void ETHR_ATMC32_FUNC__(add_wb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
7963
{
 
7964
#if defined(ETHR_HAVE_NATMC32_ADD_WB)
 
7965
    ETHR_NATMC32_FUNC__(add_wb)(var, (ETHR_NAINT32_T__) val);
 
7966
#elif defined(ETHR_HAVE_NATMC32_ADD)
 
7967
    ETHR_MEMBAR(ETHR_StoreStore);
 
7968
    ETHR_NATMC32_FUNC__(add)(var, (ETHR_NAINT32_T__) val);
 
7969
#elif defined(ETHR_HAVE_NATMC32_ADD_MB)
 
7970
    ETHR_NATMC32_FUNC__(add_mb)(var, (ETHR_NAINT32_T__) val);
 
7971
#elif defined(ETHR_HAVE_NATMC32_ADD_RB)
 
7972
    ETHR_MEMBAR(ETHR_StoreStore);
 
7973
    ETHR_NATMC32_FUNC__(add_rb)(var, (ETHR_NAINT32_T__) val);
 
7974
#elif defined(ETHR_HAVE_NATMC32_ADD_ACQB)
 
7975
    ETHR_MEMBAR(ETHR_StoreStore);
 
7976
    ETHR_NATMC32_FUNC__(add_acqb)(var, (ETHR_NAINT32_T__) val);
 
7977
#elif defined(ETHR_HAVE_NATMC32_ADD_RELB)
 
7978
    ETHR_MEMBAR(ETHR_StoreStore);
 
7979
    ETHR_NATMC32_FUNC__(add_relb)(var, (ETHR_NAINT32_T__) val);
 
7980
#else
 
7981
    (void) ETHR_ATMC32_FUNC__(add_read_wb)(var, val);
 
7982
#endif
 
7983
}
 
7984
 
 
7985
static ETHR_INLINE void ETHR_ATMC32_FUNC__(add_acqb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
7986
{
 
7987
#if defined(ETHR_HAVE_NATMC32_ADD_ACQB)
 
7988
    ETHR_NATMC32_FUNC__(add_acqb)(var, (ETHR_NAINT32_T__) val);
 
7989
#elif defined(ETHR_HAVE_NATMC32_ADD_RB)
 
7990
    ETHR_NATMC32_FUNC__(add_rb)(var, (ETHR_NAINT32_T__) val);
 
7991
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7992
#elif defined(ETHR_HAVE_NATMC32_ADD)
 
7993
    ETHR_NATMC32_FUNC__(add)(var, (ETHR_NAINT32_T__) val);
 
7994
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
7995
#elif defined(ETHR_HAVE_NATMC32_ADD_MB)
 
7996
    ETHR_NATMC32_FUNC__(add_mb)(var, (ETHR_NAINT32_T__) val);
 
7997
#elif defined(ETHR_HAVE_NATMC32_ADD_WB)
 
7998
    ETHR_NATMC32_FUNC__(add_wb)(var, (ETHR_NAINT32_T__) val);
 
7999
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8000
#elif defined(ETHR_HAVE_NATMC32_ADD_RELB)
 
8001
    ETHR_NATMC32_FUNC__(add_relb)(var, (ETHR_NAINT32_T__) val);
 
8002
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8003
#else
 
8004
    (void) ETHR_ATMC32_FUNC__(add_read_acqb)(var, val);
 
8005
#endif
 
8006
}
 
8007
 
 
8008
static ETHR_INLINE void ETHR_ATMC32_FUNC__(add_relb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
8009
{
 
8010
#if defined(ETHR_HAVE_NATMC32_ADD_RELB)
 
8011
    ETHR_NATMC32_FUNC__(add_relb)(var, (ETHR_NAINT32_T__) val);
 
8012
#elif defined(ETHR_HAVE_NATMC32_ADD_WB)
 
8013
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8014
    ETHR_NATMC32_FUNC__(add_wb)(var, (ETHR_NAINT32_T__) val);
 
8015
#elif defined(ETHR_HAVE_NATMC32_ADD)
 
8016
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8017
    ETHR_NATMC32_FUNC__(add)(var, (ETHR_NAINT32_T__) val);
 
8018
#elif defined(ETHR_HAVE_NATMC32_ADD_MB)
 
8019
    ETHR_NATMC32_FUNC__(add_mb)(var, (ETHR_NAINT32_T__) val);
 
8020
#elif defined(ETHR_HAVE_NATMC32_ADD_RB)
 
8021
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8022
    ETHR_NATMC32_FUNC__(add_rb)(var, (ETHR_NAINT32_T__) val);
 
8023
#elif defined(ETHR_HAVE_NATMC32_ADD_ACQB)
 
8024
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8025
    ETHR_NATMC32_FUNC__(add_acqb)(var, (ETHR_NAINT32_T__) val);
 
8026
#else
 
8027
    (void) ETHR_ATMC32_FUNC__(add_read_relb)(var, val);
 
8028
#endif
 
8029
}
 
8030
 
 
8031
static ETHR_INLINE void ETHR_ATMC32_FUNC__(add_mb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
8032
{
 
8033
#if defined(ETHR_HAVE_NATMC32_ADD_MB)
 
8034
    ETHR_NATMC32_FUNC__(add_mb)(var, (ETHR_NAINT32_T__) val);
 
8035
#elif defined(ETHR_HAVE_NATMC32_ADD_RELB)
 
8036
    ETHR_NATMC32_FUNC__(add_relb)(var, (ETHR_NAINT32_T__) val);
 
8037
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8038
#elif defined(ETHR_HAVE_NATMC32_ADD_ACQB)
 
8039
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8040
    ETHR_NATMC32_FUNC__(add_acqb)(var, (ETHR_NAINT32_T__) val);
 
8041
#elif defined(ETHR_HAVE_NATMC32_ADD_WB)
 
8042
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8043
    ETHR_NATMC32_FUNC__(add_wb)(var, (ETHR_NAINT32_T__) val);
 
8044
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8045
#elif defined(ETHR_HAVE_NATMC32_ADD_RB)
 
8046
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8047
    ETHR_NATMC32_FUNC__(add_rb)(var, (ETHR_NAINT32_T__) val);
 
8048
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8049
#elif defined(ETHR_HAVE_NATMC32_ADD)
 
8050
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8051
    ETHR_NATMC32_FUNC__(add)(var, (ETHR_NAINT32_T__) val);
 
8052
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8053
#else
 
8054
    (void) ETHR_ATMC32_FUNC__(add_read_mb)(var, val);
 
8055
#endif
 
8056
}
 
8057
 
 
8058
 
 
8059
/* --- inc() --- */
 
8060
 
 
8061
 
 
8062
static ETHR_INLINE void ETHR_ATMC32_FUNC__(inc)(ethr_atomic32_t *var)
 
8063
{
 
8064
#if defined(ETHR_HAVE_NATMC32_INC)
 
8065
    ETHR_NATMC32_FUNC__(inc)(var);
 
8066
#elif defined(ETHR_HAVE_NATMC32_INC_RB)
 
8067
    ETHR_NATMC32_FUNC__(inc_rb)(var);
 
8068
#elif defined(ETHR_HAVE_NATMC32_INC_WB)
 
8069
    ETHR_NATMC32_FUNC__(inc_wb)(var);
 
8070
#elif defined(ETHR_HAVE_NATMC32_INC_ACQB)
 
8071
    ETHR_NATMC32_FUNC__(inc_acqb)(var);
 
8072
#elif defined(ETHR_HAVE_NATMC32_INC_RELB)
 
8073
    ETHR_NATMC32_FUNC__(inc_relb)(var);
 
8074
#elif defined(ETHR_HAVE_NATMC32_INC_MB)
 
8075
    ETHR_NATMC32_FUNC__(inc_mb)(var);
 
8076
#else
 
8077
    (void) ETHR_ATMC32_FUNC__(inc_read)(var);
 
8078
#endif
 
8079
}
 
8080
 
 
8081
static ETHR_INLINE void ETHR_ATMC32_FUNC__(inc_rb)(ethr_atomic32_t *var)
 
8082
{
 
8083
#if defined(ETHR_HAVE_NATMC32_INC_RB)
 
8084
    ETHR_NATMC32_FUNC__(inc_rb)(var);
 
8085
#elif defined(ETHR_HAVE_NATMC32_INC)
 
8086
    ETHR_NATMC32_FUNC__(inc)(var);
 
8087
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8088
#elif defined(ETHR_HAVE_NATMC32_INC_MB)
 
8089
    ETHR_NATMC32_FUNC__(inc_mb)(var);
 
8090
#elif defined(ETHR_HAVE_NATMC32_INC_WB)
 
8091
    ETHR_NATMC32_FUNC__(inc_wb)(var);
 
8092
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8093
#elif defined(ETHR_HAVE_NATMC32_INC_ACQB)
 
8094
    ETHR_NATMC32_FUNC__(inc_acqb)(var);
 
8095
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8096
#elif defined(ETHR_HAVE_NATMC32_INC_RELB)
 
8097
    ETHR_NATMC32_FUNC__(inc_relb)(var);
 
8098
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8099
#else
 
8100
    (void) ETHR_ATMC32_FUNC__(inc_read_rb)(var);
 
8101
#endif
 
8102
}
 
8103
 
 
8104
static ETHR_INLINE void ETHR_ATMC32_FUNC__(inc_wb)(ethr_atomic32_t *var)
 
8105
{
 
8106
#if defined(ETHR_HAVE_NATMC32_INC_WB)
 
8107
    ETHR_NATMC32_FUNC__(inc_wb)(var);
 
8108
#elif defined(ETHR_HAVE_NATMC32_INC)
 
8109
    ETHR_MEMBAR(ETHR_StoreStore);
 
8110
    ETHR_NATMC32_FUNC__(inc)(var);
 
8111
#elif defined(ETHR_HAVE_NATMC32_INC_MB)
 
8112
    ETHR_NATMC32_FUNC__(inc_mb)(var);
 
8113
#elif defined(ETHR_HAVE_NATMC32_INC_RB)
 
8114
    ETHR_MEMBAR(ETHR_StoreStore);
 
8115
    ETHR_NATMC32_FUNC__(inc_rb)(var);
 
8116
#elif defined(ETHR_HAVE_NATMC32_INC_ACQB)
 
8117
    ETHR_MEMBAR(ETHR_StoreStore);
 
8118
    ETHR_NATMC32_FUNC__(inc_acqb)(var);
 
8119
#elif defined(ETHR_HAVE_NATMC32_INC_RELB)
 
8120
    ETHR_MEMBAR(ETHR_StoreStore);
 
8121
    ETHR_NATMC32_FUNC__(inc_relb)(var);
 
8122
#else
 
8123
    (void) ETHR_ATMC32_FUNC__(inc_read_wb)(var);
 
8124
#endif
 
8125
}
 
8126
 
 
8127
static ETHR_INLINE void ETHR_ATMC32_FUNC__(inc_acqb)(ethr_atomic32_t *var)
 
8128
{
 
8129
#if defined(ETHR_HAVE_NATMC32_INC_ACQB)
 
8130
    ETHR_NATMC32_FUNC__(inc_acqb)(var);
 
8131
#elif defined(ETHR_HAVE_NATMC32_INC_RB)
 
8132
    ETHR_NATMC32_FUNC__(inc_rb)(var);
 
8133
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8134
#elif defined(ETHR_HAVE_NATMC32_INC)
 
8135
    ETHR_NATMC32_FUNC__(inc)(var);
 
8136
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8137
#elif defined(ETHR_HAVE_NATMC32_INC_MB)
 
8138
    ETHR_NATMC32_FUNC__(inc_mb)(var);
 
8139
#elif defined(ETHR_HAVE_NATMC32_INC_WB)
 
8140
    ETHR_NATMC32_FUNC__(inc_wb)(var);
 
8141
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8142
#elif defined(ETHR_HAVE_NATMC32_INC_RELB)
 
8143
    ETHR_NATMC32_FUNC__(inc_relb)(var);
 
8144
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8145
#else
 
8146
    (void) ETHR_ATMC32_FUNC__(inc_read_acqb)(var);
 
8147
#endif
 
8148
}
 
8149
 
 
8150
static ETHR_INLINE void ETHR_ATMC32_FUNC__(inc_relb)(ethr_atomic32_t *var)
 
8151
{
 
8152
#if defined(ETHR_HAVE_NATMC32_INC_RELB)
 
8153
    ETHR_NATMC32_FUNC__(inc_relb)(var);
 
8154
#elif defined(ETHR_HAVE_NATMC32_INC_WB)
 
8155
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8156
    ETHR_NATMC32_FUNC__(inc_wb)(var);
 
8157
#elif defined(ETHR_HAVE_NATMC32_INC)
 
8158
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8159
    ETHR_NATMC32_FUNC__(inc)(var);
 
8160
#elif defined(ETHR_HAVE_NATMC32_INC_MB)
 
8161
    ETHR_NATMC32_FUNC__(inc_mb)(var);
 
8162
#elif defined(ETHR_HAVE_NATMC32_INC_RB)
 
8163
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8164
    ETHR_NATMC32_FUNC__(inc_rb)(var);
 
8165
#elif defined(ETHR_HAVE_NATMC32_INC_ACQB)
 
8166
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8167
    ETHR_NATMC32_FUNC__(inc_acqb)(var);
 
8168
#else
 
8169
    (void) ETHR_ATMC32_FUNC__(inc_read_relb)(var);
 
8170
#endif
 
8171
}
 
8172
 
 
8173
static ETHR_INLINE void ETHR_ATMC32_FUNC__(inc_mb)(ethr_atomic32_t *var)
 
8174
{
 
8175
#if defined(ETHR_HAVE_NATMC32_INC_MB)
 
8176
    ETHR_NATMC32_FUNC__(inc_mb)(var);
 
8177
#elif defined(ETHR_HAVE_NATMC32_INC_RELB)
 
8178
    ETHR_NATMC32_FUNC__(inc_relb)(var);
 
8179
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8180
#elif defined(ETHR_HAVE_NATMC32_INC_ACQB)
 
8181
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8182
    ETHR_NATMC32_FUNC__(inc_acqb)(var);
 
8183
#elif defined(ETHR_HAVE_NATMC32_INC_WB)
 
8184
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8185
    ETHR_NATMC32_FUNC__(inc_wb)(var);
 
8186
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8187
#elif defined(ETHR_HAVE_NATMC32_INC_RB)
 
8188
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8189
    ETHR_NATMC32_FUNC__(inc_rb)(var);
 
8190
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8191
#elif defined(ETHR_HAVE_NATMC32_INC)
 
8192
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8193
    ETHR_NATMC32_FUNC__(inc)(var);
 
8194
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8195
#else
 
8196
    (void) ETHR_ATMC32_FUNC__(inc_read_mb)(var);
 
8197
#endif
 
8198
}
 
8199
 
 
8200
 
 
8201
/* --- dec() --- */
 
8202
 
 
8203
 
 
8204
static ETHR_INLINE void ETHR_ATMC32_FUNC__(dec)(ethr_atomic32_t *var)
 
8205
{
 
8206
#if defined(ETHR_HAVE_NATMC32_DEC)
 
8207
    ETHR_NATMC32_FUNC__(dec)(var);
 
8208
#elif defined(ETHR_HAVE_NATMC32_DEC_RB)
 
8209
    ETHR_NATMC32_FUNC__(dec_rb)(var);
 
8210
#elif defined(ETHR_HAVE_NATMC32_DEC_WB)
 
8211
    ETHR_NATMC32_FUNC__(dec_wb)(var);
 
8212
#elif defined(ETHR_HAVE_NATMC32_DEC_ACQB)
 
8213
    ETHR_NATMC32_FUNC__(dec_acqb)(var);
 
8214
#elif defined(ETHR_HAVE_NATMC32_DEC_RELB)
 
8215
    ETHR_NATMC32_FUNC__(dec_relb)(var);
 
8216
#elif defined(ETHR_HAVE_NATMC32_DEC_MB)
 
8217
    ETHR_NATMC32_FUNC__(dec_mb)(var);
 
8218
#else
 
8219
    (void) ETHR_ATMC32_FUNC__(dec_read)(var);
 
8220
#endif
 
8221
}
 
8222
 
 
8223
static ETHR_INLINE void ETHR_ATMC32_FUNC__(dec_rb)(ethr_atomic32_t *var)
 
8224
{
 
8225
#if defined(ETHR_HAVE_NATMC32_DEC_RB)
 
8226
    ETHR_NATMC32_FUNC__(dec_rb)(var);
 
8227
#elif defined(ETHR_HAVE_NATMC32_DEC)
 
8228
    ETHR_NATMC32_FUNC__(dec)(var);
 
8229
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8230
#elif defined(ETHR_HAVE_NATMC32_DEC_MB)
 
8231
    ETHR_NATMC32_FUNC__(dec_mb)(var);
 
8232
#elif defined(ETHR_HAVE_NATMC32_DEC_WB)
 
8233
    ETHR_NATMC32_FUNC__(dec_wb)(var);
 
8234
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8235
#elif defined(ETHR_HAVE_NATMC32_DEC_ACQB)
 
8236
    ETHR_NATMC32_FUNC__(dec_acqb)(var);
 
8237
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8238
#elif defined(ETHR_HAVE_NATMC32_DEC_RELB)
 
8239
    ETHR_NATMC32_FUNC__(dec_relb)(var);
 
8240
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8241
#else
 
8242
    (void) ETHR_ATMC32_FUNC__(dec_read_rb)(var);
 
8243
#endif
 
8244
}
 
8245
 
 
8246
static ETHR_INLINE void ETHR_ATMC32_FUNC__(dec_wb)(ethr_atomic32_t *var)
 
8247
{
 
8248
#if defined(ETHR_HAVE_NATMC32_DEC_WB)
 
8249
    ETHR_NATMC32_FUNC__(dec_wb)(var);
 
8250
#elif defined(ETHR_HAVE_NATMC32_DEC)
 
8251
    ETHR_MEMBAR(ETHR_StoreStore);
 
8252
    ETHR_NATMC32_FUNC__(dec)(var);
 
8253
#elif defined(ETHR_HAVE_NATMC32_DEC_MB)
 
8254
    ETHR_NATMC32_FUNC__(dec_mb)(var);
 
8255
#elif defined(ETHR_HAVE_NATMC32_DEC_RB)
 
8256
    ETHR_MEMBAR(ETHR_StoreStore);
 
8257
    ETHR_NATMC32_FUNC__(dec_rb)(var);
 
8258
#elif defined(ETHR_HAVE_NATMC32_DEC_ACQB)
 
8259
    ETHR_MEMBAR(ETHR_StoreStore);
 
8260
    ETHR_NATMC32_FUNC__(dec_acqb)(var);
 
8261
#elif defined(ETHR_HAVE_NATMC32_DEC_RELB)
 
8262
    ETHR_MEMBAR(ETHR_StoreStore);
 
8263
    ETHR_NATMC32_FUNC__(dec_relb)(var);
 
8264
#else
 
8265
    (void) ETHR_ATMC32_FUNC__(dec_read_wb)(var);
 
8266
#endif
 
8267
}
 
8268
 
 
8269
static ETHR_INLINE void ETHR_ATMC32_FUNC__(dec_acqb)(ethr_atomic32_t *var)
 
8270
{
 
8271
#if defined(ETHR_HAVE_NATMC32_DEC_ACQB)
 
8272
    ETHR_NATMC32_FUNC__(dec_acqb)(var);
 
8273
#elif defined(ETHR_HAVE_NATMC32_DEC_RB)
 
8274
    ETHR_NATMC32_FUNC__(dec_rb)(var);
 
8275
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8276
#elif defined(ETHR_HAVE_NATMC32_DEC)
 
8277
    ETHR_NATMC32_FUNC__(dec)(var);
 
8278
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8279
#elif defined(ETHR_HAVE_NATMC32_DEC_MB)
 
8280
    ETHR_NATMC32_FUNC__(dec_mb)(var);
 
8281
#elif defined(ETHR_HAVE_NATMC32_DEC_WB)
 
8282
    ETHR_NATMC32_FUNC__(dec_wb)(var);
 
8283
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8284
#elif defined(ETHR_HAVE_NATMC32_DEC_RELB)
 
8285
    ETHR_NATMC32_FUNC__(dec_relb)(var);
 
8286
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8287
#else
 
8288
    (void) ETHR_ATMC32_FUNC__(dec_read_acqb)(var);
 
8289
#endif
 
8290
}
 
8291
 
 
8292
static ETHR_INLINE void ETHR_ATMC32_FUNC__(dec_relb)(ethr_atomic32_t *var)
 
8293
{
 
8294
#if defined(ETHR_HAVE_NATMC32_DEC_RELB)
 
8295
    ETHR_NATMC32_FUNC__(dec_relb)(var);
 
8296
#elif defined(ETHR_HAVE_NATMC32_DEC_WB)
 
8297
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8298
    ETHR_NATMC32_FUNC__(dec_wb)(var);
 
8299
#elif defined(ETHR_HAVE_NATMC32_DEC)
 
8300
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8301
    ETHR_NATMC32_FUNC__(dec)(var);
 
8302
#elif defined(ETHR_HAVE_NATMC32_DEC_MB)
 
8303
    ETHR_NATMC32_FUNC__(dec_mb)(var);
 
8304
#elif defined(ETHR_HAVE_NATMC32_DEC_RB)
 
8305
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8306
    ETHR_NATMC32_FUNC__(dec_rb)(var);
 
8307
#elif defined(ETHR_HAVE_NATMC32_DEC_ACQB)
 
8308
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8309
    ETHR_NATMC32_FUNC__(dec_acqb)(var);
 
8310
#else
 
8311
    (void) ETHR_ATMC32_FUNC__(dec_read_relb)(var);
 
8312
#endif
 
8313
}
 
8314
 
 
8315
static ETHR_INLINE void ETHR_ATMC32_FUNC__(dec_mb)(ethr_atomic32_t *var)
 
8316
{
 
8317
#if defined(ETHR_HAVE_NATMC32_DEC_MB)
 
8318
    ETHR_NATMC32_FUNC__(dec_mb)(var);
 
8319
#elif defined(ETHR_HAVE_NATMC32_DEC_RELB)
 
8320
    ETHR_NATMC32_FUNC__(dec_relb)(var);
 
8321
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8322
#elif defined(ETHR_HAVE_NATMC32_DEC_ACQB)
 
8323
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8324
    ETHR_NATMC32_FUNC__(dec_acqb)(var);
 
8325
#elif defined(ETHR_HAVE_NATMC32_DEC_WB)
 
8326
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8327
    ETHR_NATMC32_FUNC__(dec_wb)(var);
 
8328
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8329
#elif defined(ETHR_HAVE_NATMC32_DEC_RB)
 
8330
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8331
    ETHR_NATMC32_FUNC__(dec_rb)(var);
 
8332
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8333
#elif defined(ETHR_HAVE_NATMC32_DEC)
 
8334
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8335
    ETHR_NATMC32_FUNC__(dec)(var);
 
8336
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8337
#else
 
8338
    (void) ETHR_ATMC32_FUNC__(dec_read_mb)(var);
 
8339
#endif
 
8340
}
 
8341
 
 
8342
 
 
8343
/* --- read_band() --- */
 
8344
 
 
8345
 
 
8346
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(read_band)(ethr_atomic32_t *var, ethr_sint32_t val)
 
8347
{
 
8348
    ethr_sint32_t res;
 
8349
#if defined(ETHR_HAVE_NATMC32_AND_RETOLD)
 
8350
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold)(var, (ETHR_NAINT32_T__) val);
 
8351
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_RB)
 
8352
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_rb)(var, (ETHR_NAINT32_T__) val);
 
8353
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_WB)
 
8354
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_wb)(var, (ETHR_NAINT32_T__) val);
 
8355
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_ACQB)
 
8356
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_acqb)(var, (ETHR_NAINT32_T__) val);
 
8357
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_RELB)
 
8358
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_relb)(var, (ETHR_NAINT32_T__) val);
 
8359
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_MB)
 
8360
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_mb)(var, (ETHR_NAINT32_T__) val);
 
8361
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
8362
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, res = aval; aval &= val);
 
8363
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
8364
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, res = aval; aval &= val);
 
8365
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
8366
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, res = aval; aval &= val);
 
8367
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
8368
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval &= val);
 
8369
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
8370
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, res = aval; aval &= val);
 
8371
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
8372
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, res = aval; aval &= val);
 
8373
#else
 
8374
#error "Missing implementation of ethr_atomic32_read_band()!"
 
8375
#endif
 
8376
    return res;
 
8377
}
 
8378
 
 
8379
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(read_band_rb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
8380
{
 
8381
    ethr_sint32_t res;
 
8382
#if defined(ETHR_HAVE_NATMC32_AND_RETOLD_RB)
 
8383
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_rb)(var, (ETHR_NAINT32_T__) val);
 
8384
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD)
 
8385
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold)(var, (ETHR_NAINT32_T__) val);
 
8386
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8387
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_MB)
 
8388
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_mb)(var, (ETHR_NAINT32_T__) val);
 
8389
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_WB)
 
8390
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_wb)(var, (ETHR_NAINT32_T__) val);
 
8391
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8392
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_ACQB)
 
8393
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_acqb)(var, (ETHR_NAINT32_T__) val);
 
8394
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8395
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_RELB)
 
8396
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_relb)(var, (ETHR_NAINT32_T__) val);
 
8397
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8398
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
8399
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, res = aval; aval &= val);
 
8400
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
8401
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, res = aval; aval &= val);
 
8402
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8403
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
8404
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, res = aval; aval &= val);
 
8405
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
8406
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, res = aval; aval &= val);
 
8407
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8408
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
8409
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval &= val);
 
8410
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8411
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
8412
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, res = aval; aval &= val);
 
8413
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8414
#else
 
8415
#error "Missing implementation of ethr_atomic32_read_band_rb()!"
 
8416
#endif
 
8417
    return res;
 
8418
}
 
8419
 
 
8420
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(read_band_wb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
8421
{
 
8422
    ethr_sint32_t res;
 
8423
#if defined(ETHR_HAVE_NATMC32_AND_RETOLD_WB)
 
8424
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_wb)(var, (ETHR_NAINT32_T__) val);
 
8425
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD)
 
8426
    ETHR_MEMBAR(ETHR_StoreStore);
 
8427
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold)(var, (ETHR_NAINT32_T__) val);
 
8428
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_MB)
 
8429
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_mb)(var, (ETHR_NAINT32_T__) val);
 
8430
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_RB)
 
8431
    ETHR_MEMBAR(ETHR_StoreStore);
 
8432
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_rb)(var, (ETHR_NAINT32_T__) val);
 
8433
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_ACQB)
 
8434
    ETHR_MEMBAR(ETHR_StoreStore);
 
8435
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_acqb)(var, (ETHR_NAINT32_T__) val);
 
8436
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_RELB)
 
8437
    ETHR_MEMBAR(ETHR_StoreStore);
 
8438
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_relb)(var, (ETHR_NAINT32_T__) val);
 
8439
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
8440
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, res = aval; aval &= val);
 
8441
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
8442
    ETHR_MEMBAR(ETHR_StoreStore);
 
8443
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, res = aval; aval &= val);
 
8444
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
8445
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, res = aval; aval &= val);
 
8446
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
8447
    ETHR_MEMBAR(ETHR_StoreStore);
 
8448
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, res = aval; aval &= val);
 
8449
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
8450
    ETHR_MEMBAR(ETHR_StoreStore);
 
8451
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval &= val);
 
8452
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
8453
    ETHR_MEMBAR(ETHR_StoreStore);
 
8454
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, res = aval; aval &= val);
 
8455
#else
 
8456
#error "Missing implementation of ethr_atomic32_read_band_wb()!"
 
8457
#endif
 
8458
    return res;
 
8459
}
 
8460
 
 
8461
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(read_band_acqb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
8462
{
 
8463
    ethr_sint32_t res;
 
8464
#if defined(ETHR_HAVE_NATMC32_AND_RETOLD_ACQB)
 
8465
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_acqb)(var, (ETHR_NAINT32_T__) val);
 
8466
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_RB)
 
8467
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_rb)(var, (ETHR_NAINT32_T__) val);
 
8468
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8469
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD)
 
8470
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold)(var, (ETHR_NAINT32_T__) val);
 
8471
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8472
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_MB)
 
8473
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_mb)(var, (ETHR_NAINT32_T__) val);
 
8474
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_WB)
 
8475
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_wb)(var, (ETHR_NAINT32_T__) val);
 
8476
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8477
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_RELB)
 
8478
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_relb)(var, (ETHR_NAINT32_T__) val);
 
8479
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8480
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
8481
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval &= val);
 
8482
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
8483
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, res = aval; aval &= val);
 
8484
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8485
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
8486
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, res = aval; aval &= val);
 
8487
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8488
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
8489
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, res = aval; aval &= val);
 
8490
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
8491
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, res = aval; aval &= val);
 
8492
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8493
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
8494
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, res = aval; aval &= val);
 
8495
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8496
#else
 
8497
#error "Missing implementation of ethr_atomic32_read_band_acqb()!"
 
8498
#endif
 
8499
    return res;
 
8500
}
 
8501
 
 
8502
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(read_band_relb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
8503
{
 
8504
    ethr_sint32_t res;
 
8505
#if defined(ETHR_HAVE_NATMC32_AND_RETOLD_RELB)
 
8506
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_relb)(var, (ETHR_NAINT32_T__) val);
 
8507
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_WB)
 
8508
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8509
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_wb)(var, (ETHR_NAINT32_T__) val);
 
8510
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD)
 
8511
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8512
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold)(var, (ETHR_NAINT32_T__) val);
 
8513
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_MB)
 
8514
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_mb)(var, (ETHR_NAINT32_T__) val);
 
8515
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_RB)
 
8516
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8517
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_rb)(var, (ETHR_NAINT32_T__) val);
 
8518
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_ACQB)
 
8519
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8520
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_acqb)(var, (ETHR_NAINT32_T__) val);
 
8521
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
8522
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, res = aval; aval &= val);
 
8523
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
8524
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8525
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, res = aval; aval &= val);
 
8526
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
8527
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8528
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, res = aval; aval &= val);
 
8529
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
8530
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, res = aval; aval &= val);
 
8531
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
8532
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8533
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, res = aval; aval &= val);
 
8534
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
8535
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8536
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval &= val);
 
8537
#else
 
8538
#error "Missing implementation of ethr_atomic32_read_band_relb()!"
 
8539
#endif
 
8540
    return res;
 
8541
}
 
8542
 
 
8543
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(read_band_mb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
8544
{
 
8545
    ethr_sint32_t res;
 
8546
#if defined(ETHR_HAVE_NATMC32_AND_RETOLD_MB)
 
8547
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_mb)(var, (ETHR_NAINT32_T__) val);
 
8548
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_RELB)
 
8549
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_relb)(var, (ETHR_NAINT32_T__) val);
 
8550
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8551
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_ACQB)
 
8552
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8553
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_acqb)(var, (ETHR_NAINT32_T__) val);
 
8554
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_WB)
 
8555
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8556
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_wb)(var, (ETHR_NAINT32_T__) val);
 
8557
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8558
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD_RB)
 
8559
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8560
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold_rb)(var, (ETHR_NAINT32_T__) val);
 
8561
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8562
#elif defined(ETHR_HAVE_NATMC32_AND_RETOLD)
 
8563
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8564
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(and_retold)(var, (ETHR_NAINT32_T__) val);
 
8565
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8566
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
8567
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, res = aval; aval &= val);
 
8568
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
8569
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, res = aval; aval &= val);
 
8570
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8571
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
8572
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8573
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval &= val);
 
8574
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
8575
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8576
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, res = aval; aval &= val);
 
8577
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8578
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
8579
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8580
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, res = aval; aval &= val);
 
8581
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8582
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
8583
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8584
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, res = aval; aval &= val);
 
8585
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8586
#else
 
8587
#error "Missing implementation of ethr_atomic32_read_band_mb()!"
 
8588
#endif
 
8589
    return res;
 
8590
}
 
8591
 
 
8592
 
 
8593
/* --- read_bor() --- */
 
8594
 
 
8595
 
 
8596
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(read_bor)(ethr_atomic32_t *var, ethr_sint32_t val)
 
8597
{
 
8598
    ethr_sint32_t res;
 
8599
#if defined(ETHR_HAVE_NATMC32_OR_RETOLD)
 
8600
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold)(var, (ETHR_NAINT32_T__) val);
 
8601
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_RB)
 
8602
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_rb)(var, (ETHR_NAINT32_T__) val);
 
8603
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_WB)
 
8604
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_wb)(var, (ETHR_NAINT32_T__) val);
 
8605
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_ACQB)
 
8606
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_acqb)(var, (ETHR_NAINT32_T__) val);
 
8607
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_RELB)
 
8608
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_relb)(var, (ETHR_NAINT32_T__) val);
 
8609
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_MB)
 
8610
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_mb)(var, (ETHR_NAINT32_T__) val);
 
8611
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
8612
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, res = aval; aval |= val);
 
8613
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
8614
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, res = aval; aval |= val);
 
8615
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
8616
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, res = aval; aval |= val);
 
8617
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
8618
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval |= val);
 
8619
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
8620
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, res = aval; aval |= val);
 
8621
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
8622
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, res = aval; aval |= val);
 
8623
#else
 
8624
#error "Missing implementation of ethr_atomic32_read_bor()!"
 
8625
#endif
 
8626
    return res;
 
8627
}
 
8628
 
 
8629
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(read_bor_rb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
8630
{
 
8631
    ethr_sint32_t res;
 
8632
#if defined(ETHR_HAVE_NATMC32_OR_RETOLD_RB)
 
8633
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_rb)(var, (ETHR_NAINT32_T__) val);
 
8634
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD)
 
8635
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold)(var, (ETHR_NAINT32_T__) val);
 
8636
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8637
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_MB)
 
8638
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_mb)(var, (ETHR_NAINT32_T__) val);
 
8639
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_WB)
 
8640
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_wb)(var, (ETHR_NAINT32_T__) val);
 
8641
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8642
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_ACQB)
 
8643
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_acqb)(var, (ETHR_NAINT32_T__) val);
 
8644
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8645
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_RELB)
 
8646
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_relb)(var, (ETHR_NAINT32_T__) val);
 
8647
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8648
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
8649
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, res = aval; aval |= val);
 
8650
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
8651
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, res = aval; aval |= val);
 
8652
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8653
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
8654
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, res = aval; aval |= val);
 
8655
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
8656
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, res = aval; aval |= val);
 
8657
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8658
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
8659
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval |= val);
 
8660
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8661
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
8662
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, res = aval; aval |= val);
 
8663
    ETHR_MEMBAR(ETHR_LoadLoad);
 
8664
#else
 
8665
#error "Missing implementation of ethr_atomic32_read_bor_rb()!"
 
8666
#endif
 
8667
    return res;
 
8668
}
 
8669
 
 
8670
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(read_bor_wb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
8671
{
 
8672
    ethr_sint32_t res;
 
8673
#if defined(ETHR_HAVE_NATMC32_OR_RETOLD_WB)
 
8674
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_wb)(var, (ETHR_NAINT32_T__) val);
 
8675
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD)
 
8676
    ETHR_MEMBAR(ETHR_StoreStore);
 
8677
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold)(var, (ETHR_NAINT32_T__) val);
 
8678
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_MB)
 
8679
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_mb)(var, (ETHR_NAINT32_T__) val);
 
8680
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_RB)
 
8681
    ETHR_MEMBAR(ETHR_StoreStore);
 
8682
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_rb)(var, (ETHR_NAINT32_T__) val);
 
8683
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_ACQB)
 
8684
    ETHR_MEMBAR(ETHR_StoreStore);
 
8685
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_acqb)(var, (ETHR_NAINT32_T__) val);
 
8686
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_RELB)
 
8687
    ETHR_MEMBAR(ETHR_StoreStore);
 
8688
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_relb)(var, (ETHR_NAINT32_T__) val);
 
8689
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
8690
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, res = aval; aval |= val);
 
8691
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
8692
    ETHR_MEMBAR(ETHR_StoreStore);
 
8693
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, res = aval; aval |= val);
 
8694
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
8695
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, res = aval; aval |= val);
 
8696
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
8697
    ETHR_MEMBAR(ETHR_StoreStore);
 
8698
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, res = aval; aval |= val);
 
8699
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
8700
    ETHR_MEMBAR(ETHR_StoreStore);
 
8701
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval |= val);
 
8702
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
8703
    ETHR_MEMBAR(ETHR_StoreStore);
 
8704
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, res = aval; aval |= val);
 
8705
#else
 
8706
#error "Missing implementation of ethr_atomic32_read_bor_wb()!"
 
8707
#endif
 
8708
    return res;
 
8709
}
 
8710
 
 
8711
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(read_bor_acqb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
8712
{
 
8713
    ethr_sint32_t res;
 
8714
#if defined(ETHR_HAVE_NATMC32_OR_RETOLD_ACQB)
 
8715
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_acqb)(var, (ETHR_NAINT32_T__) val);
 
8716
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_RB)
 
8717
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_rb)(var, (ETHR_NAINT32_T__) val);
 
8718
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8719
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD)
 
8720
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold)(var, (ETHR_NAINT32_T__) val);
 
8721
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8722
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_MB)
 
8723
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_mb)(var, (ETHR_NAINT32_T__) val);
 
8724
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_WB)
 
8725
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_wb)(var, (ETHR_NAINT32_T__) val);
 
8726
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8727
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_RELB)
 
8728
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_relb)(var, (ETHR_NAINT32_T__) val);
 
8729
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8730
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
8731
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval |= val);
 
8732
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
8733
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, res = aval; aval |= val);
 
8734
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8735
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
8736
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, res = aval; aval |= val);
 
8737
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8738
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
8739
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, res = aval; aval |= val);
 
8740
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
8741
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, res = aval; aval |= val);
 
8742
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8743
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
8744
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, res = aval; aval |= val);
 
8745
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8746
#else
 
8747
#error "Missing implementation of ethr_atomic32_read_bor_acqb()!"
 
8748
#endif
 
8749
    return res;
 
8750
}
 
8751
 
 
8752
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(read_bor_relb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
8753
{
 
8754
    ethr_sint32_t res;
 
8755
#if defined(ETHR_HAVE_NATMC32_OR_RETOLD_RELB)
 
8756
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_relb)(var, (ETHR_NAINT32_T__) val);
 
8757
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_WB)
 
8758
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8759
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_wb)(var, (ETHR_NAINT32_T__) val);
 
8760
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD)
 
8761
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8762
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold)(var, (ETHR_NAINT32_T__) val);
 
8763
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_MB)
 
8764
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_mb)(var, (ETHR_NAINT32_T__) val);
 
8765
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_RB)
 
8766
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8767
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_rb)(var, (ETHR_NAINT32_T__) val);
 
8768
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_ACQB)
 
8769
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8770
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_acqb)(var, (ETHR_NAINT32_T__) val);
 
8771
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
8772
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, res = aval; aval |= val);
 
8773
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
8774
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8775
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, res = aval; aval |= val);
 
8776
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
8777
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8778
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, res = aval; aval |= val);
 
8779
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
8780
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, res = aval; aval |= val);
 
8781
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
8782
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8783
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, res = aval; aval |= val);
 
8784
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
8785
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8786
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval |= val);
 
8787
#else
 
8788
#error "Missing implementation of ethr_atomic32_read_bor_relb()!"
 
8789
#endif
 
8790
    return res;
 
8791
}
 
8792
 
 
8793
static ETHR_INLINE ethr_sint32_t ETHR_ATMC32_FUNC__(read_bor_mb)(ethr_atomic32_t *var, ethr_sint32_t val)
 
8794
{
 
8795
    ethr_sint32_t res;
 
8796
#if defined(ETHR_HAVE_NATMC32_OR_RETOLD_MB)
 
8797
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_mb)(var, (ETHR_NAINT32_T__) val);
 
8798
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_RELB)
 
8799
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_relb)(var, (ETHR_NAINT32_T__) val);
 
8800
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8801
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_ACQB)
 
8802
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8803
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_acqb)(var, (ETHR_NAINT32_T__) val);
 
8804
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_WB)
 
8805
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8806
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_wb)(var, (ETHR_NAINT32_T__) val);
 
8807
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8808
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD_RB)
 
8809
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8810
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold_rb)(var, (ETHR_NAINT32_T__) val);
 
8811
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8812
#elif defined(ETHR_HAVE_NATMC32_OR_RETOLD)
 
8813
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8814
    res = (ethr_sint32_t) ETHR_NATMC32_FUNC__(or_retold)(var, (ETHR_NAINT32_T__) val);
 
8815
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8816
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_MB)
 
8817
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_mb), var, aval, res = aval; aval |= val);
 
8818
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RELB)
 
8819
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_relb), var, aval, res = aval; aval |= val);
 
8820
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8821
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_ACQB)
 
8822
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8823
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_acqb), var, aval, res = aval; aval |= val);
 
8824
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_WB)
 
8825
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8826
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_wb), var, aval, res = aval; aval |= val);
 
8827
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8828
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG_RB)
 
8829
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8830
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg_rb), var, aval, res = aval; aval |= val);
 
8831
    ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8832
#elif defined(ETHR_HAVE_NATMC32_CMPXCHG)
 
8833
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_StoreLoad);
 
8834
    ETHR_NATMC32_CMPXCHG_FALLBACK__(ETHR_NATMC32_FUNC__(cmpxchg), var, aval, res = aval; aval |= val);
 
8835
    ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreLoad|ETHR_StoreStore);
 
8836
#else
 
8837
#error "Missing implementation of ethr_atomic32_read_bor_mb()!"
 
8838
#endif
 
8839
    return res;
 
8840
}
 
8841
 
 
8842
#endif /* ETHR_ATMC32_INLINE__ */
 
8843
 
 
8844
#endif /* ETHR_ATOMICS_H__ */