source: rtems/cpukit/score/include/rtems/score/cpustdatomic.h @ 7b4e81d

4.115
Last change on this file since 7b4e81d was 7b4e81d, checked in by Sebastian Huber <sebastian.huber@…>, on 03/09/15 at 07:51:55

score: Typo

Close #2286.

  • Property mode set to 100644
File size: 16.9 KB
Line 
1/**
2 * @file
3 *
4 * @brief Atomic Operations CPU API
5 */
6
7/*
8 * COPYRIGHT (c) 2013 Deng Hengyi.
9 * Copyright (c) 2015 embedded brains GmbH.
10 *
11 * The license and distribution terms for this file may be
12 * found in the file LICENSE in this distribution or at
13 * http://www.rtems.org/license/LICENSE.
14 */
15
16#ifndef _RTEMS_SCORE_CPUSTDATOMIC_H
17#define _RTEMS_SCORE_CPUSTDATOMIC_H
18
19#include <rtems/score/basedefs.h>
20
21#ifdef RTEMS_SMP
22  #if defined(__cplusplus) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 9
23    /*
24     * The GCC 4.9 ships its own <stdatomic.h> which is not C++ compatible.  The
25     * suggested solution was to include <atomic> in case C++ is used.  This works
26     * at least with GCC 4.9.  See also:
27     *
28     * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=60932
29     * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=60940
30     */
31    #include <atomic>
32    #define _RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC
33  #else
34    #include <stdatomic.h>
35    #define _RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC
36  #endif
37#else
38  #include <rtems/score/isrlevel.h>
39#endif
40
41#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
42
43typedef std::atomic_uint CPU_atomic_Uint;
44
45typedef std::atomic_ulong CPU_atomic_Ulong;
46
47typedef std::atomic_uintptr_t CPU_atomic_Pointer;
48
49typedef std::atomic_flag CPU_atomic_Flag;
50
51typedef std::memory_order CPU_atomic_Order;
52
53#define CPU_ATOMIC_ORDER_RELAXED std::memory_order_relaxed
54
55#define CPU_ATOMIC_ORDER_ACQUIRE std::memory_order_acquire
56
57#define CPU_ATOMIC_ORDER_RELEASE std::memory_order_release
58
59#define CPU_ATOMIC_ORDER_ACQ_REL std::memory_order_acq_rel
60
61#define CPU_ATOMIC_ORDER_SEQ_CST std::memory_order_seq_cst
62
63#define CPU_ATOMIC_INITIALIZER_UINT( value ) ATOMIC_VAR_INIT( value )
64
65#define CPU_ATOMIC_INITIALIZER_ULONG( value ) ATOMIC_VAR_INIT( value )
66
67#define CPU_ATOMIC_INITIALIZER_PTR( value ) \
68  ATOMIC_VAR_INIT( (uintptr_t) (value) )
69
70#define CPU_ATOMIC_INITIALIZER_FLAG ATOMIC_FLAG_INIT
71
72#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
73
74typedef atomic_uint CPU_atomic_Uint;
75
76typedef atomic_ulong CPU_atomic_Ulong;
77
78typedef atomic_uintptr_t CPU_atomic_Pointer;
79
80typedef atomic_flag CPU_atomic_Flag;
81
82typedef memory_order CPU_atomic_Order;
83
84#define CPU_ATOMIC_ORDER_RELAXED memory_order_relaxed
85
86#define CPU_ATOMIC_ORDER_ACQUIRE memory_order_acquire
87
88#define CPU_ATOMIC_ORDER_RELEASE memory_order_release
89
90#define CPU_ATOMIC_ORDER_ACQ_REL memory_order_acq_rel
91
92#define CPU_ATOMIC_ORDER_SEQ_CST memory_order_seq_cst
93
94#define CPU_ATOMIC_INITIALIZER_UINT( value ) ATOMIC_VAR_INIT( value )
95
96#define CPU_ATOMIC_INITIALIZER_ULONG( value ) ATOMIC_VAR_INIT( value )
97
98#define CPU_ATOMIC_INITIALIZER_PTR( value ) \
99  ATOMIC_VAR_INIT( (uintptr_t) (value) )
100
101#define CPU_ATOMIC_INITIALIZER_FLAG ATOMIC_FLAG_INIT
102
103#else
104
105typedef unsigned int CPU_atomic_Uint;
106
107typedef unsigned long CPU_atomic_Ulong;
108
109typedef uintptr_t CPU_atomic_Pointer;
110
111typedef bool CPU_atomic_Flag;
112
113typedef int CPU_atomic_Order;
114
115#define CPU_ATOMIC_ORDER_RELAXED 0
116
117#define CPU_ATOMIC_ORDER_ACQUIRE 2
118
119#define CPU_ATOMIC_ORDER_RELEASE 3
120
121#define CPU_ATOMIC_ORDER_ACQ_REL 4
122
123#define CPU_ATOMIC_ORDER_SEQ_CST 5
124
125#define CPU_ATOMIC_INITIALIZER_UINT( value ) ( value )
126
127#define CPU_ATOMIC_INITIALIZER_ULONG( value ) ( value )
128
129#define CPU_ATOMIC_INITIALIZER_PTR( value ) ( (uintptr_t) (value) )
130
131#define CPU_ATOMIC_INITIALIZER_FLAG false
132
133#endif
134
135static inline void _CPU_atomic_Fence( CPU_atomic_Order order )
136{
137#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
138  std::atomic_thread_fence( order );
139#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
140  atomic_thread_fence( order );
141#else
142  (void) order;
143  RTEMS_COMPILER_MEMORY_BARRIER();
144#endif
145}
146
147static inline void _CPU_atomic_Init_uint( CPU_atomic_Uint *obj, unsigned int desired )
148{
149#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
150  obj->store( desired );
151#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
152  atomic_init( obj, desired );
153#else
154  *obj = desired;
155#endif
156}
157
158static inline void _CPU_atomic_Init_ulong( CPU_atomic_Ulong *obj, unsigned long desired )
159{
160#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
161  obj->store( desired );
162#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
163  atomic_init( obj, desired );
164#else
165  *obj = desired;
166#endif
167}
168
169static inline void _CPU_atomic_Init_ptr( CPU_atomic_Pointer *obj, void *desired )
170{
171#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
172  obj->store( (uintptr_t) desired );
173#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
174  atomic_init( obj, (uintptr_t) desired );
175#else
176  *obj = (uintptr_t) desired;
177#endif
178}
179
180static inline unsigned int _CPU_atomic_Load_uint( const CPU_atomic_Uint *obj, CPU_atomic_Order order )
181{
182#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
183  return obj->load( order );
184#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
185  return atomic_load_explicit( obj, order );
186#else
187  (void) order;
188  RTEMS_COMPILER_MEMORY_BARRIER();
189  return *obj;
190#endif
191}
192
193static inline unsigned long _CPU_atomic_Load_ulong( const CPU_atomic_Ulong *obj, CPU_atomic_Order order )
194{
195#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
196  return obj->load( order );
197#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
198  return atomic_load_explicit( obj, order );
199#else
200  (void) order;
201  RTEMS_COMPILER_MEMORY_BARRIER();
202  return *obj;
203#endif
204}
205
206static inline void *_CPU_atomic_Load_ptr( const CPU_atomic_Pointer *obj, CPU_atomic_Order order )
207{
208#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
209  return (void *) obj->load( order );
210#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
211  return (void *) atomic_load_explicit( obj, order );
212#else
213  (void) order;
214  RTEMS_COMPILER_MEMORY_BARRIER();
215  return (void *) *obj;
216#endif
217}
218
219static inline void _CPU_atomic_Store_uint( CPU_atomic_Uint *obj, unsigned int desired, CPU_atomic_Order order )
220{
221#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
222  obj->store( desired );
223#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
224  atomic_store_explicit( obj, desired, order );
225#else
226  (void) order;
227  *obj = desired;
228  RTEMS_COMPILER_MEMORY_BARRIER();
229#endif
230}
231
232static inline void _CPU_atomic_Store_ulong( CPU_atomic_Ulong *obj, unsigned long desired, CPU_atomic_Order order )
233{
234#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
235  obj->store( desired );
236#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
237  atomic_store_explicit( obj, desired, order );
238#else
239  (void) order;
240  *obj = desired;
241  RTEMS_COMPILER_MEMORY_BARRIER();
242#endif
243}
244
245static inline void _CPU_atomic_Store_ptr( CPU_atomic_Pointer *obj, void *desired, CPU_atomic_Order order )
246{
247#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
248  obj->store( (uintptr_t) desired );
249#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
250  atomic_store_explicit( obj, (uintptr_t) desired, order );
251#else
252  (void) order;
253  *obj = (uintptr_t) desired;
254  RTEMS_COMPILER_MEMORY_BARRIER();
255#endif
256}
257
258static inline unsigned int _CPU_atomic_Fetch_add_uint( CPU_atomic_Uint *obj, unsigned int arg, CPU_atomic_Order order )
259{
260#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
261  return obj->fetch_add( arg, order );
262#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
263  return atomic_fetch_add_explicit( obj, arg, order );
264#else
265  unsigned int val;
266  ISR_Level level;
267
268  (void) order;
269  _ISR_Disable( level );
270  val = *obj;
271  *obj = val + arg;
272  _ISR_Enable( level );
273
274  return val;
275#endif
276}
277
278static inline unsigned long _CPU_atomic_Fetch_add_ulong( CPU_atomic_Ulong *obj, unsigned long arg, CPU_atomic_Order order )
279{
280#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
281  return obj->fetch_add( arg, order );
282#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
283  return atomic_fetch_add_explicit( obj, arg, order );
284#else
285  unsigned long val;
286  ISR_Level level;
287
288  (void) order;
289  _ISR_Disable( level );
290  val = *obj;
291  *obj = val + arg;
292  _ISR_Enable( level );
293
294  return val;
295#endif
296}
297
298static inline void *_CPU_atomic_Fetch_add_ptr( CPU_atomic_Pointer *obj, void *arg, CPU_atomic_Order order )
299{
300#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
301  return (void *) obj->fetch_add( (uintptr_t) arg, order );
302#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
303  return (void *) atomic_fetch_add_explicit( obj, (uintptr_t) arg, order );
304#else
305  uintptr_t val;
306  ISR_Level level;
307
308  (void) order;
309  _ISR_Disable( level );
310  val = *obj;
311  *obj = val + (uintptr_t) arg;
312  _ISR_Enable( level );
313
314  return (void *) val;
315#endif
316}
317
318static inline unsigned int _CPU_atomic_Fetch_sub_uint( CPU_atomic_Uint *obj, unsigned int arg, CPU_atomic_Order order )
319{
320#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
321  return obj->fetch_sub( arg, order );
322#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
323  return atomic_fetch_sub_explicit( obj, arg, order );
324#else
325  unsigned int val;
326  ISR_Level level;
327
328  (void) order;
329  _ISR_Disable( level );
330  val = *obj;
331  *obj = val - arg;
332  _ISR_Enable( level );
333
334  return val;
335#endif
336}
337
338static inline unsigned long _CPU_atomic_Fetch_sub_ulong( CPU_atomic_Ulong *obj, unsigned long arg, CPU_atomic_Order order )
339{
340#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
341  return obj->fetch_sub( arg, order );
342#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
343  return atomic_fetch_sub_explicit( obj, arg, order );
344#else
345  unsigned long val;
346  ISR_Level level;
347
348  (void) order;
349  _ISR_Disable( level );
350  val = *obj;
351  *obj = val - arg;
352  _ISR_Enable( level );
353
354  return val;
355#endif
356}
357
358static inline void *_CPU_atomic_Fetch_sub_ptr( CPU_atomic_Pointer *obj, void *arg, CPU_atomic_Order order )
359{
360#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
361  return (void *) obj->fetch_sub( (uintptr_t) arg, order );
362#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
363  return (void *) atomic_fetch_sub_explicit( obj, (uintptr_t) arg, order );
364#else
365  uintptr_t val;
366  ISR_Level level;
367
368  (void) order;
369  _ISR_Disable( level );
370  val = *obj;
371  *obj = val - (uintptr_t) arg;
372  _ISR_Enable( level );
373
374  return (void *) val;
375#endif
376}
377
378static inline unsigned int _CPU_atomic_Fetch_or_uint( CPU_atomic_Uint *obj, unsigned int arg, CPU_atomic_Order order )
379{
380#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
381  return obj->fetch_or( arg, order );
382#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
383  return atomic_fetch_or_explicit( obj, arg, order );
384#else
385  unsigned int val;
386  ISR_Level level;
387
388  (void) order;
389  _ISR_Disable( level );
390  val = *obj;
391  *obj = val | arg;
392  _ISR_Enable( level );
393
394  return val;
395#endif
396}
397
398static inline unsigned long _CPU_atomic_Fetch_or_ulong( CPU_atomic_Ulong *obj, unsigned long arg, CPU_atomic_Order order )
399{
400#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
401  return obj->fetch_or( arg, order );
402#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
403  return atomic_fetch_or_explicit( obj, arg, order );
404#else
405  unsigned long val;
406  ISR_Level level;
407
408  (void) order;
409  _ISR_Disable( level );
410  val = *obj;
411  *obj = val | arg;
412  _ISR_Enable( level );
413
414  return val;
415#endif
416}
417
418static inline void *_CPU_atomic_Fetch_or_ptr( CPU_atomic_Pointer *obj, void *arg, CPU_atomic_Order order )
419{
420#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
421  return (void *) obj->fetch_or( (uintptr_t) arg, order );
422#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
423  return (void *) atomic_fetch_or_explicit( obj, (uintptr_t) arg, order );
424#else
425  uintptr_t val;
426  ISR_Level level;
427
428  (void) order;
429  _ISR_Disable( level );
430  val = *obj;
431  *obj = val | (uintptr_t) arg;
432  _ISR_Enable( level );
433
434  return (void *) val;
435#endif
436}
437
438static inline unsigned int _CPU_atomic_Fetch_and_uint( CPU_atomic_Uint *obj, unsigned int arg, CPU_atomic_Order order )
439{
440#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
441  return obj->fetch_and( arg, order );
442#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
443  return atomic_fetch_and_explicit( obj, arg, order );
444#else
445  unsigned int val;
446  ISR_Level level;
447
448  (void) order;
449  _ISR_Disable( level );
450  val = *obj;
451  *obj = val & arg;
452  _ISR_Enable( level );
453
454  return val;
455#endif
456}
457
458static inline unsigned long _CPU_atomic_Fetch_and_ulong( CPU_atomic_Ulong *obj, unsigned long arg, CPU_atomic_Order order )
459{
460#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
461  return obj->fetch_and( arg, order );
462#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
463  return atomic_fetch_and_explicit( obj, arg, order );
464#else
465  unsigned long val;
466  ISR_Level level;
467
468  (void) order;
469  _ISR_Disable( level );
470  val = *obj;
471  *obj = val & arg;
472  _ISR_Enable( level );
473
474  return val;
475#endif
476}
477
478static inline void *_CPU_atomic_Fetch_and_ptr( CPU_atomic_Pointer *obj, void *arg, CPU_atomic_Order order )
479{
480#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
481  return (void *) obj->fetch_and( (uintptr_t) arg, order );
482#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
483  return (void *) atomic_fetch_and_explicit( obj, (uintptr_t) arg, order );
484#else
485  uintptr_t val;
486  ISR_Level level;
487
488  (void) order;
489  _ISR_Disable( level );
490  val = *obj;
491  *obj = val & (uintptr_t) arg;
492  _ISR_Enable( level );
493
494  return (void *) val;
495#endif
496}
497
498static inline unsigned int _CPU_atomic_Exchange_uint( CPU_atomic_Uint *obj, unsigned int desired, CPU_atomic_Order order )
499{
500#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
501  return obj->exchange( desired, order );
502#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
503  return atomic_exchange_explicit( obj, desired, order );
504#else
505  unsigned int val;
506  ISR_Level level;
507
508  (void) order;
509  _ISR_Disable( level );
510  val = *obj;
511  *obj = desired;
512  _ISR_Enable( level );
513
514  return val;
515#endif
516}
517
518static inline unsigned long _CPU_atomic_Exchange_ulong( CPU_atomic_Ulong *obj, unsigned long desired, CPU_atomic_Order order )
519{
520#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
521  return obj->exchange( desired, order );
522#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
523  return atomic_exchange_explicit( obj, desired, order );
524#else
525  unsigned long val;
526  ISR_Level level;
527
528  (void) order;
529  _ISR_Disable( level );
530  val = *obj;
531  *obj = desired;
532  _ISR_Enable( level );
533
534  return val;
535#endif
536}
537
538static inline void *_CPU_atomic_Exchange_ptr( CPU_atomic_Pointer *obj, void *desired, CPU_atomic_Order order )
539{
540#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
541  return (void *) obj->exchange( (uintptr_t) desired, order );
542#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
543  return (void *) atomic_exchange_explicit( obj, (uintptr_t) desired, order );
544#else
545  uintptr_t val;
546  ISR_Level level;
547
548  (void) order;
549  _ISR_Disable( level );
550  val = *obj;
551  *obj = (uintptr_t) desired;
552  _ISR_Enable( level );
553
554  return (void *) val;
555#endif
556}
557
558static inline bool _CPU_atomic_Compare_exchange_uint( CPU_atomic_Uint *obj, unsigned int *expected, unsigned int desired, CPU_atomic_Order succ, CPU_atomic_Order fail )
559{
560#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
561  return obj->compare_exchange_strong( *expected, desired, succ, fail );
562#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
563  return atomic_compare_exchange_strong_explicit( obj, expected, desired, succ, fail );
564#else
565  bool success;
566  ISR_Level level;
567
568  (void) succ;
569  (void) fail;
570  _ISR_Disable( level );
571  success = *obj == *expected;
572  if ( success ) {
573    *obj = desired;
574  }
575  _ISR_Enable( level );
576
577  return success;
578#endif
579}
580
581static inline bool _CPU_atomic_Compare_exchange_ulong( CPU_atomic_Ulong *obj, unsigned long *expected, unsigned long desired, CPU_atomic_Order succ, CPU_atomic_Order fail )
582{
583#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
584  return obj->compare_exchange_strong( *expected, desired, succ, fail );
585#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
586  return atomic_compare_exchange_strong_explicit( obj, expected, desired, succ, fail );
587#else
588  bool success;
589  ISR_Level level;
590
591  (void) succ;
592  (void) fail;
593  _ISR_Disable( level );
594  success = *obj == *expected;
595  if ( success ) {
596    *obj = desired;
597  }
598  _ISR_Enable( level );
599
600  return success;
601#endif
602}
603
604static inline bool _CPU_atomic_Compare_exchange_ptr( CPU_atomic_Pointer *obj, void **expected, void *desired, CPU_atomic_Order succ, CPU_atomic_Order fail )
605{
606#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
607  return obj->compare_exchange_strong( *(uintptr_t *) expected, (uintptr_t) desired, succ, fail );
608#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
609  return atomic_compare_exchange_strong_explicit( obj, (uintptr_t *) expected, (uintptr_t) desired, succ, fail );
610#else
611  bool success;
612  ISR_Level level;
613
614  (void) succ;
615  (void) fail;
616  _ISR_Disable( level );
617  success = *obj == (uintptr_t) *expected;
618  if ( success ) {
619    *obj = (uintptr_t) desired;
620  }
621  _ISR_Enable( level );
622
623  return success;
624#endif
625}
626
627static inline void _CPU_atomic_Flag_clear( CPU_atomic_Flag *obj, CPU_atomic_Order order )
628{
629#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
630  obj->clear( order );
631#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
632  atomic_flag_clear_explicit( obj, order );
633#else
634  (void) order;
635  *obj = false;
636#endif
637}
638
639static inline bool _CPU_atomic_Flag_test_and_set( CPU_atomic_Flag *obj, CPU_atomic_Order order )
640{
641#if defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_ATOMIC)
642  return obj->test_and_set( order );
643#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
644  return atomic_flag_test_and_set_explicit( obj, order );
645#else
646  bool flag;
647  ISR_Level level;
648
649  (void) order;
650  _ISR_Disable( level );
651  flag = *obj;
652  *obj = true;
653  _ISR_Enable( level );
654
655  return flag;
656#endif
657}
658
659#endif /* _RTEMS_SCORE_CPUSTDATOMIC_H */
Note: See TracBrowser for help on using the repository browser.