Changeset 4c96372 in rtems


Ignore:
Timestamp:
Jan 25, 2013, 4:34:57 PM (7 years ago)
Author:
WeiY <wei.a.yang@…>
Branches:
4.11, master
Children:
5de9e8d
Parents:
7e02305
git-author:
WeiY <wei.a.yang@…> (01/25/13 16:34:57)
git-committer:
Gedare Bloom <gedare@…> (02/07/13 22:02:12)
Message:

score: atomic support for RTEMS. Cleanup.

Location:
cpukit/score
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • cpukit/score/cpu/i386/rtems/score/cpuatomic.h

    r7e02305 r4c96372  
    6868 */
    6969#define ATOMIC_STORE_LOAD(NAME, TYPE, LOP, SOP)               \
    70 static inline Atomic_##TYPE                           \
    71 _CPU_Atomic_Load_##NAME(volatile Atomic_##TYPE *p)      \
    72 {                                                       \
    73   Atomic_##TYPE tmp;                                    \
    74                                                         \
    75   tmp = *p;                                             \
    76   __asm __volatile("" : : : "memory");                  \
    77   return (tmp);                                         \
    78 }                                                       \
    79                                                         \
     70static inline Atomic_##TYPE                                   \
     71_CPU_Atomic_Load_##NAME(volatile Atomic_##TYPE *p)            \
     72{                                                             \
     73  Atomic_##TYPE tmp;                                          \
     74                                                              \
     75  tmp = *p;                                                   \
     76  __asm __volatile("" : : : "memory");                        \
     77  return (tmp);                                               \
     78}                                                             \
     79                                                              \
    8080static inline _CPU_Atomic_Load_acq_##NAME(volatile Atomic_##TYPE *p)  \
    81 {                                                       \
    82   Atomic_##TYPE tmp;                                    \
    83                                                         \
    84   tmp = *p;                                             \
    85   __asm __volatile("" : : : "memory");                  \
    86   return (tmp);                                         \
    87 }                                                       \
    88                                                         \
    89 static inline void                                    \
     81{                                                             \
     82  Atomic_##TYPE tmp;                                          \
     83                                                              \
     84  tmp = *p;                                                   \
     85  __asm __volatile("" : : : "memory");                        \
     86  return (tmp);                                               \
     87}                                                             \
     88                                                              \
     89static inline void                                            \
    9090_CPU_Atomic_Store_##NAME(volatile Atomic_##TYPE *p, Atomic_##TYPE v) \
    91 {                                                                    \
    92   __asm __volatile("" : : : "memory");                               \
    93   *p = v;                                                            \
    94 }                                                                    \
    95                                                         \
    96 static inline void                                    \
     91{                                                             \
     92  __asm __volatile("" : : : "memory");                        \
     93  *p = v;                                                     \
     94}                                                             \
     95                                                              \
     96static inline void                                            \
    9797_CPU_Atomic_Store_rel_##NAME(volatile Atomic_##TYPE *p, Atomic_##TYPE v) \
    98 {                                                                        \
    99   __asm __volatile("" : : : "memory");                                   \
    100   *p = v;                                                                \
    101 }                                                                        \
     98{                                                             \
     99  __asm __volatile("" : : : "memory");                        \
     100  *p = v;                                                     \
     101}                                                             \
    102102
    103103#else /* !(!SMP) */
    104104
    105105#define ATOMIC_STORE_LOAD(NAME, TYPE, LOP, SOP)               \
    106 static inline Atomic_##TYPE                           \
    107 _CPU_Atomic_Load_##NAME(volatile Atomic_##TYPE *p)      \
    108 {                                                       \
    109   Atomic_##TYPE res;                                    \
    110                                                         \
    111   __asm __volatile(MPLOCKED LOP                         \
    112   : "=a" (res),                 /* 0 */                 \
    113   "=m" (*p)                     /* 1 */                 \
    114   : "m" (*p)                    /* 2 */                 \
    115   : "memory", "cc");                                    \
    116                                                         \
    117   return (res);                                         \
    118 }                                                       \
    119                                                         \
    120 static inline Atomic_##TYPE                           \
    121 _CPU_Atomic_Load_acq_##NAME(volatile Atomic_##TYPE *p)  \
    122 {                                                       \
    123   Atomic_##TYPE res;                                    \
    124                                                         \
    125   __asm __volatile(MPLOCKED LOP                         \
    126   : "=a" (res),                 /* 0 */                 \
    127   "=m" (*p)                     /* 1 */                 \
    128   : "m" (*p)                    /* 2 */                 \
    129   : "memory", "cc");                                    \
    130                                                         \
    131   return (res);                                         \
    132 }                                                       \
    133                                                         \
    134 /*                                                      \
    135  * The XCHG instruction asserts LOCK automagically.     \
    136  */                                                     \
    137 static inline void                                    \
     106static inline Atomic_##TYPE                                   \
     107_CPU_Atomic_Load_##NAME(volatile Atomic_##TYPE *p)            \
     108{                                                             \
     109  Atomic_##TYPE res;                                          \
     110                                                              \
     111  __asm __volatile(MPLOCKED LOP                               \
     112  : "=a" (res),                 /* 0 */                       \
     113  "=m" (*p)                     /* 1 */                       \
     114  : "m" (*p)                    /* 2 */                       \
     115  : "memory", "cc");                                          \
     116                                                              \
     117  return (res);                                               \
     118}                                                             \
     119                                                              \
     120static inline Atomic_##TYPE                                   \
     121_CPU_Atomic_Load_acq_##NAME(volatile Atomic_##TYPE *p)        \
     122{                                                             \
     123  Atomic_##TYPE res;                                          \
     124                                                              \
     125  __asm __volatile(MPLOCKED LOP                               \
     126  : "=a" (res),                 /* 0 */                       \
     127  "=m" (*p)                     /* 1 */                       \
     128  : "m" (*p)                    /* 2 */                       \
     129  : "memory", "cc");                                          \
     130                                                              \
     131  return (res);                                               \
     132}                                                             \
     133                                                              \
     134/*                                                            \
     135 * The XCHG instruction asserts LOCK automagically.           \
     136 */                                                           \
     137static inline void                                            \
    138138_CPU_Atomic_Store_##NAME(volatile Atomic_##TYPE *p, Atomic_##TYPE v) \
    139 {                                                                    \
    140   __asm __volatile(SOP                                               \
    141   : "=m" (*p),                  /* 0 */                              \
    142   "+r" (v)                      /* 1 */                              \
    143   : "m" (*p)                    /* 2 */                              \
    144   : "memory");                                                       \
    145 }                                                                    \
    146 static inline void                                                   \
     139{                                                             \
     140  __asm __volatile(SOP                                        \
     141  : "=m" (*p),                  /* 0 */                       \
     142  "+r" (v)                      /* 1 */                       \
     143  : "m" (*p)                    /* 2 */                       \
     144  : "memory");                                                \
     145}                                                             \
     146static inline void                                            \
    147147_CPU_Atomic_Store_rel_##NAME(volatile Atomic_##TYPE *p, Atomic_##TYPE v) \
    148 {                                                                        \
    149   __asm __volatile(SOP                                                   \
    150   : "=m" (*p),                  /* 0 */                                  \
    151   "+r" (v)                      /* 1 */                                  \
    152   : "m" (*p)                    /* 2 */                                  \
    153   : "memory");                                                           \
    154 }                                                                        \
     148{                                                             \
     149  __asm __volatile(SOP                                        \
     150  : "=m" (*p),                  /* 0 */                       \
     151  "+r" (v)                      /* 1 */                       \
     152  : "m" (*p)                    /* 2 */                       \
     153  : "memory");                                                \
     154}                                                             \
    155155
    156156#endif /* !SMP */
     
    161161 * in order to avoid that for memory barriers.
    162162 */
    163 #define ATOMIC_FETCH_GENERIC(NAME, TYPENAME, TYPE, OP, CONS, V)                         \
    164 static inline void                                                                      \
     163#define ATOMIC_FETCH_GENERIC(NAME, TYPENAME, TYPE, OP, CONS, V)               \
     164static inline void                                                            \
    165165_CPU_Atomic_Fetch_##NAME##_##TYPENAME(volatile Atomic_##TYPE *p, Atomic_##TYPE v) \
    166166{                                                                             \
     
    252252
    253253/* Operations on 32-bit double words. */
    254 #define _CPU_Atomic_Fetch_or_32(p, v)  \
     254#define _CPU_Atomic_Fetch_or_32(p, v)      \
    255255    _CPU_Atomic_Fetch_or_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    256256#define _CPU_Atomic_Fetch_or_acq_32(p, v)  \
     
    258258#define _CPU_Atomic_Fetch_or_rel_32(p, v)  \
    259259    _CPU_Atomic_Fetch_or_rel_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    260 #define _CPU_Atomic_Fetch_and_32(p, v)  \
     260#define _CPU_Atomic_Fetch_and_32(p, v)     \
    261261    _CPU_Atomic_Fetch_and_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    262 #define _CPU_Atomic_Fetch_and_acq_32(p, v)  \
     262#define _CPU_Atomic_Fetch_and_acq_32(p, v) \
    263263    _CPU_Atomic_Fetch_and_acq_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    264 #define _CPU_Atomic_Fetch_and_rel_32(p, v)  \
     264#define _CPU_Atomic_Fetch_and_rel_32(p, v) \
    265265    _CPU_Atomic_Fetch_and_rel_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    266 #define _CPU_Atomic_Fetch_add_32(p, v)  \
     266#define _CPU_Atomic_Fetch_add_32(p, v)     \
    267267    _CPU_Atomic_Fetch_add_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    268 #define _CPU_Atomic_Fetch_add_acq_32(p, v)  \
     268#define _CPU_Atomic_Fetch_add_acq_32(p, v) \
    269269    _CPU_Atomic_Fetch_add_acq_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    270 #define _CPU_Atomic_Fetch_add_rel_32(p, v)  \
     270#define _CPU_Atomic_Fetch_add_rel_32(p, v) \
    271271    _CPU_Atomic_Fetch_add_rel_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    272 #define _CPU_Atomic_Fetch_sub_32(p, v)  \
     272#define _CPU_Atomic_Fetch_sub_32(p, v)     \
    273273    _CPU_Atomic_Fetch_sub_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    274 #define _CPU_Atomic_Fetch_sub_acq_32(p, v)  \
     274#define _CPU_Atomic_Fetch_sub_acq_32(p, v) \
    275275    _CPU_Atomic_Fetch_sub_acq_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    276 #define _CPU_Atomic_Fetch_sub_rel_32(p, v)  \
     276#define _CPU_Atomic_Fetch_sub_rel_32(p, v) \
    277277    _CPU_Atomic_Fetch_sub_rel_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    278 #define _CPU_Atomic_Load_32(p)  \
     278#define _CPU_Atomic_Load_32(p)             \
    279279    _CPU_Atomic_Load_int((volatile Atomic_Int *)(p))
    280 #define _CPU_Atomic_Load_acq_32(p)  \
     280#define _CPU_Atomic_Load_acq_32(p)         \
    281281    _CPU_Atomic_Load_acq_int((volatile Atomic_Int *)(p))
    282 #define _CPU_Atomic_Store_32(p, v)  \
     282#define _CPU_Atomic_Store_32(p, v)         \
    283283    _CPU_Atomic_Store_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    284 #define _CPU_Atomic_Store_rel_32(p, v)  \
     284#define _CPU_Atomic_Store_rel_32(p, v)     \
    285285    _CPU_Atomic_Store_rel_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    286286#define _CPU_Atomic_Compare_exchange_32(dst, old, new)  \
     
    292292
    293293/* Operations on pointers. */
    294 #define _CPU_Atomic_Fetch_or_ptr(p, v) \
     294#define _CPU_Atomic_Fetch_or_ptr(p, v)     \
    295295    _CPU_Atomic_Fetch_or_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    296296#define _CPU_Atomic_Fetch_or_acq_ptr(p, v) \
     
    298298#define _CPU_Atomic_Fetch_or_rel_ptr(p, v) \
    299299    _CPU_Atomic_Fetch_or_rel_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    300 #define _CPU_Atomic_Fetch_and_ptr(p, v) \
     300#define _CPU_Atomic_Fetch_and_ptr(p, v)    \
    301301    _CPU_Atomic_Fetch_and_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    302 #define _CPU_Atomic_Fetch_and_acq_ptr(p, v) \
     302#define _CPU_Atomic_Fetch_and_acq_ptr(p, v)\
    303303    _CPU_Atomic_Fetch_and_acq_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    304 #define _CPU_Atomic_Fetch_and_rel_ptr(p, v) \
     304#define _CPU_Atomic_Fetch_and_rel_ptr(p, v)\
    305305    _CPU_Atomic_Fetch_and_rel_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    306 #define _CPU_Atomic_Fetch_add_ptr(p, v) \
     306#define _CPU_Atomic_Fetch_add_ptr(p, v)    \
    307307    _CPU_Atomic_Fetch_add_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    308 #define _CPU_Atomic_Fetch_add_acq_ptr(p, v) \
     308#define _CPU_Atomic_Fetch_add_acq_ptr(p, v)\
    309309    _CPU_Atomic_Fetch_add_acq_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    310 #define _CPU_Atomic_Fetch_add_rel_ptr(p, v) \
     310#define _CPU_Atomic_Fetch_add_rel_ptr(p, v)\
    311311    _CPU_Atomic_Fetch_add_rel_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    312 #define _CPU_Atomic_Fetch_sub_ptr(p, v) \
     312#define _CPU_Atomic_Fetch_sub_ptr(p, v)    \
    313313    _CPU_Atomic_Fetch_sub_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    314 #define _CPU_Atomic_Fetch_sub_acq_ptr(p, v) \
     314#define _CPU_Atomic_Fetch_sub_acq_ptr(p, v)\
    315315    _CPU_Atomic_Fetch_sub_acq_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    316 #define _CPU_Atomic_Fetch_sub_rel_ptr(p, v) \
     316#define _CPU_Atomic_Fetch_sub_rel_ptr(p, v)\
    317317    _CPU_Atomic_Fetch_sub_rel_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    318 #define _CPU_Atomic_Load_ptr(p) \
     318#define _CPU_Atomic_Load_ptr(p)            \
    319319    _CPU_Atomic_Load_int((volatile Atomic_Int *)(p))
    320 #define _CPU_Atomic_Load_acq_ptr(p) \
     320#define _CPU_Atomic_Load_acq_ptr(p)        \
    321321    _CPU_Atomic_Load_acq_int((volatile Atomic_Int *)(p))
    322 #define _CPU_Atomic_Store_ptr(p, v) \
     322#define _CPU_Atomic_Store_ptr(p, v)        \
    323323    _CPU_Atomic_Store_int((volatile Atomic_Int *)(p), (v))
    324 #define _CPU_Atomic_Store_rel_ptr(p, v) \
     324#define _CPU_Atomic_Store_rel_ptr(p, v)    \
    325325    _CPU_Atomic_Store_rel_int((volatile Atomic_Int *)(p), (v))
    326326#define _CPU_Atomic_Compare_exchange_ptr(dst, old, new) \
  • cpukit/score/cpu/powerpc/rtems/score/cpuatomic.h

    r7e02305 r4c96372  
    8989     /* __CPU_Atomic_Fetch_add_long */
    9090
    91 #define _ATOMIC_ADD(typename, type)                           \
     91#define _ATOMIC_ADD(typename, type)                 \
    9292  static __inline void                              \
    9393  _CPU_Atomic_Fetch_add_##typename(volatile Atomic_##type *p, Atomic_##type v) {  \
    9494    Atomic_##type t;                                \
    95     __CPU_Atomic_Fetch_add_##typename(p, v, t);         \
     95    __CPU_Atomic_Fetch_add_##typename(p, v, t);     \
    9696  }                                                 \
    9797                                                    \
    9898  static __inline void                              \
    9999  _CPU_Atomic_Fetch_add_acq_##typename(volatile Atomic_##type *p, Atomic_##type v) { \
    100     Atomic_##type t;                                            \
    101    __CPU_Atomic_Fetch_add_##typename(p, v, t);                      \
    102    __ATOMIC_BARRIER;                                            \
    103   }                                                             \
    104                                                                 \
    105   static __inline void                                          \
     100    Atomic_##type t;                                \
     101   __CPU_Atomic_Fetch_add_##typename(p, v, t);      \
     102   __ATOMIC_BARRIER;                                \
     103  }                                                 \
     104                                                    \
     105  static __inline void                              \
    106106  _CPU_Atomic_Fetch_add_rel_##typename(volatile Atomic_##type *p, Atomic_##type v) { \
    107     Atomic_##type t;                                            \
    108     __ATOMIC_BARRIER;                                           \
    109     __CPU_Atomic_Fetch_add_##typename(p, v, t);                     \
    110   }                                                             \
     107    Atomic_##type t;                                \
     108    __ATOMIC_BARRIER;                               \
     109    __CPU_Atomic_Fetch_add_##typename(p, v, t);     \
     110  }                                                 \
    111111  /* _ATOMIC_ADD */
    112112
     
    114114_ATOMIC_ADD(long, Long)
    115115
    116 #define _CPU_Atomic_Fetch_add_32(p, v)  \
     116#define _CPU_Atomic_Fetch_add_32(p, v)      \
    117117    _CPU_Atomic_Fetch_add_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    118118#define _CPU_Atomic_Fetch_add_acq_32(p, v)  \
     
    121121    _CPU_Atomic_Fetch_add_rel_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    122122
    123 #define _CPU_Atomic_Fetch_add_ptr(p, v) \
     123#define _CPU_Atomic_Fetch_add_ptr(p, v)     \
    124124    _CPU_Atomic_Fetch_add_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    125125#define _CPU_Atomic_Fetch_add_acq_ptr(p, v) \
     
    159159  /* _CPU_Atomic_Fetch_and_long */
    160160
    161 #define _ATOMIC_AND(typename, type)                                       \
     161#define _ATOMIC_AND(typename, type)                             \
    162162  static __inline void                                          \
    163163  _CPU_Atomic_Fetch_and_##typename(volatile Atomic_##type *p, Atomic_##type v) {  \
    164164    Atomic_##type t;                                            \
    165     __CPU_Atomic_Fetch_and_##typename(p, v, t);                     \
     165    __CPU_Atomic_Fetch_and_##typename(p, v, t);                 \
    166166  }                                                             \
    167167                                                                \
     
    169169  _CPU_Atomic_Fetch_and_acq_##typename(volatile Atomic_##type *p, Atomic_##type v) {  \
    170170    Atomic_##type t;                                            \
    171     __CPU_Atomic_Fetch_and_##typename(p, v, t);                     \
     171    __CPU_Atomic_Fetch_and_##typename(p, v, t);                 \
    172172    __ATOMIC_BARRIER;                                           \
    173173  }                                                             \
     
    177177    Atomic_##type t;                                            \
    178178    __ATOMIC_BARRIER;                                           \
    179     __CPU_Atomic_Fetch_and_##typename(p, v, t);                     \
     179    __CPU_Atomic_Fetch_and_##typename(p, v, t);                 \
    180180  }                                                             \
    181181  /* _ATOMIC_AND */
     
    185185_ATOMIC_AND(long, Long)
    186186
    187 #define _CPU_Atomic_Fetch_and_32(p, v)  \
     187#define _CPU_Atomic_Fetch_and_32(p, v)      \
    188188    _CPU_Atomic_Fetch_and_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    189189#define _CPU_Atomic_Fetch_and_acq_32(p, v)  \
     
    192192    _CPU_Atomic_Fetch_and_rel_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    193193
    194 #define _CPU_Atomic_Fetch_and_ptr(p, v) \
     194#define _CPU_Atomic_Fetch_and_ptr(p, v)     \
    195195    _CPU_Atomic_Fetch_and_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    196196#define _CPU_Atomic_Fetch_and_acq_ptr(p, v) \
     
    231231  /* __CPU_Atomic_Fetch_or_long */
    232232
    233 #define _ATOMIC_OR(typename, type)                                \
     233#define _ATOMIC_OR(typename, type)                      \
    234234  static __inline void                                  \
    235235  _CPU_Atomic_Fetch_or_##typename(volatile Atomic_##type *p, Atomic_##type v) {  \
    236236    Atomic_##type t;                                    \
    237     __CPU_Atomic_Fetch_or_##typename(p, v, t);              \
     237    __CPU_Atomic_Fetch_or_##typename(p, v, t);          \
    238238  }                                                     \
    239239                                                        \
     
    241241  _CPU_Atomic_Fetch_or_acq_##typename(volatile Atomic_##type *p, Atomic_##type v) { \
    242242    Atomic_##type t;                                    \
    243     __CPU_Atomic_Fetch_or_##typename(p, v, t);              \
     243    __CPU_Atomic_Fetch_or_##typename(p, v, t);          \
    244244    __ATOMIC_BARRIER;                                   \
    245245  }                                                     \
     
    249249    Atomic_##type t;                                    \
    250250    __ATOMIC_BARRIER;                                   \
    251     __CPU_Atomic_Fetch_or_##typename(p, v, t);              \
     251    __CPU_Atomic_Fetch_or_##typename(p, v, t);          \
    252252  }                                                     \
    253253  /* _ATOMIC_OR */
     
    256256_ATOMIC_OR(long, Long)
    257257
    258 #define _CPU_Atomic_Fetch_or_32(p, v)  \
     258#define _CPU_Atomic_Fetch_or_32(p, v)      \
    259259    _CPU_Atomic_Fetch_or_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    260260#define _CPU_Atomic_Fetch_or_acq_32(p, v)  \
     
    263263    _CPU_Atomic_Fetch_or_rel_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    264264
    265 #define _CPU_Atomic_Fetch_or_ptr(p, v) \
     265#define _CPU_Atomic_Fetch_or_ptr(p, v)     \
    266266    _CPU_Atomic_Fetch_or_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    267267#define _CPU_Atomic_Fetch_or_acq_ptr(p, v) \
     
    301301  /* __CPU_Atomic_Fetch_sub_long */
    302302
    303 #define _ATOMIC_SUB(typename, type)                               \
     303#define _ATOMIC_SUB(typename, type)                     \
    304304  static __inline void                                  \
    305   _CPU_Atomic_Fetch_sub_##typename(volatile Atomic_##type *p, Atomic_##type v) { \
     305  _CPU_Atomic_Fetch_sub_##typename(volatile Atomic_##type *p, Atomic_##type v) {     \
    306306    Atomic_##type t;                                    \
    307     __CPU_Atomic_Fetch_sub_##typename(p, v, t);             \
     307    __CPU_Atomic_Fetch_sub_##typename(p, v, t);         \
    308308  }                                                     \
    309309                                                        \
     
    311311  _CPU_Atomic_Fetch_sub_acq_##typename(volatile Atomic_##type *p, Atomic_##type v) { \
    312312    Atomic_##type t;                                    \
    313     __CPU_Atomic_Fetch_sub_##typename(p, v, t);             \
     313    __CPU_Atomic_Fetch_sub_##typename(p, v, t);         \
    314314    __ATOMIC_BARRIER;                                   \
    315315  }                                                     \
     
    319319    Atomic_##type t;                                    \
    320320    __ATOMIC_BARRIER;                                   \
    321     __CPU_Atomic_Fetch_sub_##typename(p, v, t);             \
     321    __CPU_Atomic_Fetch_sub_##typename(p, v, t);         \
    322322  }                                                     \
    323323  /* _ATOMIC_SUB */
     
    327327_ATOMIC_SUB(long, Long)
    328328
    329 #define _CPU_Atomic_Fetch_sub_32(p, v)  \
     329#define _CPU_Atomic_Fetch_sub_32(p, v)      \
    330330    _CPU_Atomic_Fetch_sub_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    331331#define _CPU_Atomic_Fetch_sub_acq_32(p, v)  \
     
    334334    _CPU_Atomic_Fetch_sub_rel_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    335335
    336 #define _CPU_Atomic_Fetch_sub_ptr(p, v) \
     336#define _CPU_Atomic_Fetch_sub_ptr(p, v)     \
    337337    _CPU_Atomic_Fetch_sub_int((volatile Atomic_Int *)(p), (Atomic_Int)(v))
    338338#define _CPU_Atomic_Fetch_sub_acq_ptr(p, v) \
     
    368368                                                                \
    369369static __inline void                                            \
    370 _CPU_Atomic_Store_##TYPENAME(volatile Atomic_##TYPE *p, Atomic_##TYPE v)  \
     370_CPU_Atomic_Store_##TYPENAME(volatile Atomic_##TYPE *p, Atomic_##TYPE v)      \
    371371{                                                               \
    372372  *p = v;                                                       \
     
    381381ATOMIC_STORE_LOAD(int, Int)
    382382
    383 #define _CPU_Atomic_Load_32(p)  \
     383#define _CPU_Atomic_Load_32(p)      \
    384384    _CPU_Atomic_Load_int((volatile Atomic_Int *)(p))
    385385#define _CPU_Atomic_Load_acq_32(p)  \
     
    414414}
    415415
    416 #define _CPU_Atomic_Load_ptr(p) \
     416#define _CPU_Atomic_Load_ptr(p)     \
    417417    _CPU_Atomic_Load_int((volatile Atomic_Int *)(p))
    418418#define _CPU_Atomic_Load_acq_ptr(p) \
     
    512512}
    513513
    514 #define _CPU_Atomic_Compare_exchange_32(dst, old, new)  \
     514#define _CPU_Atomic_Compare_exchange_32(dst, old, new)      \
    515515    _CPU_Atomic_Compare_exchange_int((volatile Atomic_Int *)(dst), (Atomic_Int)(old), (Atomic_Int)(new))
    516516#define _CPU_Atomic_Compare_exchange_acq_32(dst, old, new)  \
     
    519519    _CPU_Atomic_Compare_exchange_rel_int((volatile Atomic_Int *)(dst), (Atomic_Int)(old), (Atomic_Int)(new))
    520520
    521 #define _CPU_Atomic_Compare_exchange_ptr(dst, old, new) \
     521#define _CPU_Atomic_Compare_exchange_ptr(dst, old, new)     \
    522522                _CPU_Atomic_Compare_exchange_int((volatile Atomic_Int *)(dst), (Atomic_Int)(old), (Atomic_Int)(new))
    523523#define _CPU_Atomic_Compare_exchange_acq_ptr(dst, old, new) \
  • cpukit/score/inline/rtems/score/atomic.inl

    r7e02305 r4c96372  
    77 *  found in the file LICENSE in this distribution or at
    88 *  http://www.rtems.com/license/LICENSE.
    9  *
     9 */
     10
     11/*
    1012 *
    1113 *  The functions in this file implement the API to the RTEMS Atomic Manager and
     
    1719 *  rtems/cpukit/score/cpu/xxx/rtems/score/cpuatomic.h
    1820 *
    19  *  In the event that a CPU does not support a specific atomic function it has, the
    20  *  CPU dependent routine does nothing (but does exist).
     21 *  In the event that a CPU does not support a specific atomic function it has,
     22 *  the CPU dependent routine does nothing (but does exist).
    2123 */
    2224
     
    3739  if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    3840    return _CPU_Atomic_Load_acq_int(address);
    39   else
    40     return _CPU_Atomic_Load_int(address);
     41  return _CPU_Atomic_Load_int(address);
    4142}
    4243
     
    4647)
    4748{
    48   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     49  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    4950    return _CPU_Atomic_Load_acq_long(address);
    50   else
    51     return _CPU_Atomic_Load_long(address);
     51  return _CPU_Atomic_Load_long(address);
    5252}
    5353
     
    5757)
    5858{
    59   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     59  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    6060    return _CPU_Atomic_Load_acq_ptr(address);
    61   else
    62     return _CPU_Atomic_Load_ptr(address);
     61  return _CPU_Atomic_Load_ptr(address);
    6362}
    6463
     
    6867)
    6968{
    70   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     69  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    7170    return _CPU_Atomic_Load_acq_32(address);
    72   else
    73     return _CPU_Atomic_Load_32(address);
     71  return _CPU_Atomic_Load_32(address);
    7472}
    7573
     
    7977)
    8078{
    81   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     79  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    8280    return _CPU_Atomic_Load_acq_64(address);
    83   else
    84     return _CPU_Atomic_Load_64(address);
     81  return _CPU_Atomic_Load_64(address);
    8582}
    8683
     
    9289)
    9390{
    94   if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     91  if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    9592    return _CPU_Atomic_Store_rel_int(address, value);
    96   else
    97     return _CPU_Atomic_Store_int(address, value);
     93  return _CPU_Atomic_Store_int(address, value);
    9894}
    9995
     
    104100)
    105101{
    106   if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     102  if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    107103    return _CPU_Atomic_Store_rel_long(address, value);
    108   else
    109     return _CPU_Atomic_Store_long(address, value);
     104  return _CPU_Atomic_Store_long(address, value);
    110105}
    111106
     
    116111)
    117112{
    118   if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     113  if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    119114    return _CPU_Atomic_Store_rel_ptr(address, value);
    120   else
    121     return _CPU_Atomic_Store_ptr(address, value);
     115  return _CPU_Atomic_Store_ptr(address, value);
    122116}
    123117
     
    128122)
    129123{
    130   if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     124  if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    131125    return _CPU_Atomic_Store_rel_32(address, value);
    132   else
    133     return _CPU_Atomic_Store_32(address, value);
     126  return _CPU_Atomic_Store_32(address, value);
    134127}
    135128
     
    140133)
    141134{
    142   if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     135  if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    143136    return _CPU_Atomic_Store_rel_64(address, value);
    144   else
    145     return _CPU_Atomic_Store_64(address, value);
     137  return _CPU_Atomic_Store_64(address, value);
    146138}
    147139
     
    152144)
    153145{
    154   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     146  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    155147    return _CPU_Atomic_Fetch_add_acq_int(address, value);
    156   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     148  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    157149    return _CPU_Atomic_Fetch_add_rel_int(address, value);
    158150  else
     
    166158)
    167159{
    168   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     160  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    169161    return _CPU_Atomic_Fetch_add_acq_long(address, value);
    170   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     162  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    171163    return _CPU_Atomic_Fetch_add_rel_long(address, value);
    172164  else
     
    180172)
    181173{
    182   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     174  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    183175    return _CPU_Atomic_Fetch_add_acq_ptr(address, value);
    184   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     176  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    185177    return _CPU_Atomic_Fetch_add_rel_ptr(address, value);
    186178  else
     
    194186)
    195187{
    196   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     188  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    197189    return _CPU_Atomic_Fetch_add_acq_32(address, value);
    198   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     190  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    199191    return _CPU_Atomic_Fetch_add_rel_32(address, value);
    200192  else
     
    208200)
    209201{
    210   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     202  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    211203    return _CPU_Atomic_Fetch_add_acq_64(address, value);
    212   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     204  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    213205    return _CPU_Atomic_Fetch_add_rel_64(address, value);
    214206  else
     
    222214)
    223215{
    224   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     216  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    225217    return _CPU_Atomic_Fetch_sub_acq_int(address, value);
    226   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     218  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    227219    return _CPU_Atomic_Fetch_sub_rel_int(address, value);
    228220  else
     
    236228)
    237229{
    238   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     230  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    239231    return _CPU_Atomic_Fetch_sub_acq_long(address, value);
    240   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     232  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    241233    return _CPU_Atomic_Fetch_sub_rel_long(address, value);
    242234  else
     
    250242)
    251243{
    252   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     244  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    253245    return _CPU_Atomic_Fetch_sub_acq_ptr(address, value);
    254   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     246  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    255247    return _CPU_Atomic_Fetch_sub_rel_ptr(address, value);
    256248  else
     
    264256)
    265257{
    266   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     258  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    267259    return _CPU_Atomic_Fetch_sub_acq_32(address, value);
    268   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     260  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    269261    return _CPU_Atomic_Fetch_sub_rel_32(address, value);
    270262  else
     
    278270)
    279271{
    280   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     272  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    281273    return _CPU_Atomic_Fetch_sub_acq_64(address, value);
    282   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     274  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    283275    return _CPU_Atomic_Fetch_sub_rel_64(address, value);
    284276  else
     
    292284)
    293285{
    294   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     286  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    295287    return _CPU_Atomic_Fetch_or_acq_int(address, value);
    296   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     288  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    297289    return _CPU_Atomic_Fetch_or_rel_int(address, value);
    298290  else
     
    306298)
    307299{
    308   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     300  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    309301    return _CPU_Atomic_Fetch_or_acq_long(address, value);
    310   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     302  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    311303    return _CPU_Atomic_Fetch_or_rel_long(address, value);
    312304  else
     
    320312)
    321313{
    322   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     314  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    323315    return _CPU_Atomic_Fetch_or_acq_ptr(address, value);
    324   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     316  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    325317    return _CPU_Atomic_Fetch_or_rel_ptr(address, value);
    326318  else
     
    334326)
    335327{
    336   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     328  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    337329    return _CPU_Atomic_Fetch_or_acq_32(address, value);
    338   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     330  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    339331    return _CPU_Atomic_Fetch_or_rel_32(address, value);
    340332  else
     
    348340)
    349341{
    350   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     342  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    351343    return _CPU_Atomic_Fetch_or_acq_64(address, value);
    352   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     344  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    353345    return _CPU_Atomic_Fetch_or_rel_64(address, value);
    354346  else
     
    362354)
    363355{
    364   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     356  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    365357    return _CPU_Atomic_Fetch_and_acq_int(address, value);
    366   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     358  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    367359    return _CPU_Atomic_Fetch_and_rel_int(address, value);
    368360  else
     
    376368)
    377369{
    378   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     370  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    379371    return _CPU_Atomic_Fetch_and_acq_long(address, value);
    380   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     372  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    381373    return _CPU_Atomic_Fetch_and_rel_long(address, value);
    382374  else
     
    390382)
    391383{
    392   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     384  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    393385    return _CPU_Atomic_Fetch_and_acq_ptr(address, value);
    394   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     386  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    395387    return _CPU_Atomic_Fetch_and_rel_ptr(address, value);
    396388  else
     
    404396)
    405397{
    406   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     398  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    407399    return _CPU_Atomic_Fetch_and_acq_32(address, value);
    408   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     400  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    409401    return _CPU_Atomic_Fetch_and_rel_32(address, value);
    410402  else
     
    418410)
    419411{
    420   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     412  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    421413    return _CPU_Atomic_Fetch_and_acq_64(address, value);
    422   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     414  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    423415    return _CPU_Atomic_Fetch_and_rel_64(address, value);
    424416  else
     
    433425)
    434426{
    435   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     427  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    436428    return _CPU_Atomic_Compare_exchange_acq_int(address, old_value, new_value);
    437   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     429  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    438430    return _CPU_Atomic_Compare_exchange_rel_int(address, old_value, new_value);
    439431  else
     
    448440)
    449441{
    450   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     442  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    451443    return _CPU_Atomic_Compare_exchange_acq_long(address, old_value, new_value);
    452   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     444  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    453445    return _CPU_Atomic_Compare_exchange_rel_long(address, old_value, new_value);
    454446  else
     
    463455)
    464456{
    465   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     457  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    466458    return _CPU_Atomic_Compare_exchange_acq_ptr(address, old_value, new_value);
    467   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     459  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    468460    return _CPU_Atomic_Compare_exchange_rel_ptr(address, old_value, new_value);
    469461  else
     
    478470)
    479471{
    480   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     472  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    481473    return _CPU_Atomic_Compare_exchange_acq_32(address, old_value, new_value);
    482   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     474  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    483475    return _CPU_Atomic_Compare_exchange_rel_32(address, old_value, new_value);
    484476  else
     
    493485)
    494486{
    495   if(ATOMIC_ACQUIRE_BARRIER == memory_barrier)
     487  if (ATOMIC_ACQUIRE_BARRIER == memory_barrier)
    496488    return _CPU_Atomic_Compare_exchange_acq_64(address, old_value, new_value);
    497   else if(ATOMIC_RELEASE_BARRIER == memory_barrier)
     489  else if (ATOMIC_RELEASE_BARRIER == memory_barrier)
    498490    return _CPU_Atomic_Compare_exchange_rel_64(address, old_value, new_value);
    499491  else
Note: See TracChangeset for help on using the changeset viewer.