Author: marius
Date: Sat Jan 28 23:25:31 2012
New Revision: 230676
URL: http://svn.freebsd.org/changeset/base/230676

Log:
  MFC: r225890
  
  - Add protective parentheses to macros as far as possible.
  - Move {r,w,}mb() to the top of this file where they live on most of the
    other architectures.

Modified:
  stable/8/sys/sparc64/include/atomic.h
Directory Properties:
  stable/8/sys/   (props changed)
  stable/8/sys/amd64/include/xen/   (props changed)
  stable/8/sys/cddl/contrib/opensolaris/   (props changed)
  stable/8/sys/contrib/dev/acpica/   (props changed)
  stable/8/sys/contrib/pf/   (props changed)

Modified: stable/8/sys/sparc64/include/atomic.h
==============================================================================
--- stable/8/sys/sparc64/include/atomic.h       Sat Jan 28 23:25:28 2012        
(r230675)
+++ stable/8/sys/sparc64/include/atomic.h       Sat Jan 28 23:25:31 2012        
(r230676)
@@ -33,6 +33,10 @@
 
 #include <machine/cpufunc.h>
 
+#define        mb()    __asm__ __volatile__ ("membar #MemIssue": : :"memory")
+#define        wmb()   mb()
+#define        rmb()   mb()
+
 /* Userland needs different ASI's. */
 #ifdef _KERNEL
 #define        __ASI_ATOMIC    ASI_N
@@ -40,10 +44,6 @@
 #define        __ASI_ATOMIC    ASI_P
 #endif
 
-#define mb()   __asm__ __volatile__ ("membar #MemIssue": : :"memory")
-#define wmb()  mb()
-#define rmb()  mb()
-
 /*
  * Various simple arithmetic on memory which is atomic in the presence
  * of interrupts and multiple processors.  See atomic(9) for details.
@@ -88,15 +88,15 @@
 
 #define        itype(sz)       uint ## sz ## _t
 
-#define        atomic_cas_32(p, e, s)  casa(p, e, s, __ASI_ATOMIC)
-#define        atomic_cas_64(p, e, s)  casxa(p, e, s, __ASI_ATOMIC)
+#define        atomic_cas_32(p, e, s)  casa((p), (e), (s), __ASI_ATOMIC)
+#define        atomic_cas_64(p, e, s)  casxa((p), (e), (s), __ASI_ATOMIC)
 
 #define        atomic_cas(p, e, s, sz)                                         
\
-       atomic_cas_ ## sz(p, e, s)
+       atomic_cas_ ## sz((p), (e), (s))
 
 #define        atomic_cas_acq(p, e, s, sz) ({                                  
\
        itype(sz) v;                                                    \
-       v = atomic_cas(p, e, s, sz);                                    \
+       v = atomic_cas((p), (e), (s), sz);                              \
        __asm __volatile("" : : : "memory");                            \
        v;                                                              \
 })
@@ -104,15 +104,15 @@
 #define        atomic_cas_rel(p, e, s, sz) ({                                  
\
        itype(sz) v;                                                    \
        membar(LoadStore | StoreStore);                                 \
-       v = atomic_cas(p, e, s, sz);                                    \
+       v = atomic_cas((p), (e), (s), sz);                              \
        v;                                                              \
 })
 
 #define        atomic_op(p, op, v, sz) ({                                      
\
        itype(sz) e, r, s;                                              \
-       for (e = *(volatile itype(sz) *)p;; e = r) {                    \
-               s = e op v;                                             \
-               r = atomic_cas_ ## sz(p, e, s);                         \
+       for (e = *(volatile itype(sz) *)(p);; e = r) {                  \
+               s = e op (v);                                           \
+               r = atomic_cas_ ## sz((p), e, s);                       \
                if (r == e)                                             \
                        break;                                          \
        }                                                               \
@@ -121,7 +121,7 @@
 
 #define        atomic_op_acq(p, op, v, sz) ({                                  
\
        itype(sz) t;                                                    \
-       t = atomic_op(p, op, v, sz);                                    \
+       t = atomic_op((p), op, (v), sz);                                \
        __asm __volatile("" : : : "memory");                            \
        t;                                                              \
 })
@@ -129,24 +129,24 @@
 #define        atomic_op_rel(p, op, v, sz) ({                                  
\
        itype(sz) t;                                                    \
        membar(LoadStore | StoreStore);                                 \
-       t = atomic_op(p, op, v, sz);                                    \
+       t = atomic_op((p), op, (v), sz);                                \
        t;                                                              \
 })
 
 #define        atomic_load(p, sz)                                              
\
-       atomic_cas(p, 0, 0, sz)
+       atomic_cas((p), 0, 0, sz)
 
 #define        atomic_load_acq(p, sz) ({                                       
\
        itype(sz) v;                                                    \
-       v = atomic_load(p, sz);                                         \
+       v = atomic_load((p), sz);                                       \
        __asm __volatile("" : : : "memory");                            \
        v;                                                              \
 })
 
 #define        atomic_load_clear(p, sz) ({                                     
\
        itype(sz) e, r;                                                 \
-       for (e = *(volatile itype(sz) *)p;; e = r) {                    \
-               r = atomic_cas(p, e, 0, sz);                            \
+       for (e = *(volatile itype(sz) *)(p);; e = r) {                  \
+               r = atomic_cas((p), e, 0, sz);                          \
                if (r == e)                                             \
                        break;                                          \
        }                                                               \
@@ -155,8 +155,8 @@
 
 #define        atomic_store(p, v, sz) do {                                     
\
        itype(sz) e, r;                                                 \
-       for (e = *(volatile itype(sz) *)p;; e = r) {                    \
-               r = atomic_cas(p, e, v, sz);                            \
+       for (e = *(volatile itype(sz) *)(p);; e = r) {                  \
+               r = atomic_cas((p), e, (v), sz);                        \
                if (r == e)                                             \
                        break;                                          \
        }                                                               \
@@ -164,7 +164,7 @@
 
 #define        atomic_store_rel(p, v, sz) do {                                 
\
        membar(LoadStore | StoreStore);                                 \
-       atomic_store(p, v, sz);                                         \
+       atomic_store((p), (v), sz);                                     \
 } while (0)
 
 #define        ATOMIC_GEN(name, ptype, vtype, atype, sz)                       
\
@@ -172,109 +172,109 @@
 static __inline vtype                                                  \
 atomic_add_ ## name(volatile ptype p, atype v)                         \
 {                                                                      \
-       return ((vtype)atomic_op(p, +, v, sz));                         \
+       return ((vtype)atomic_op((p), +, (v), sz));                     \
 }                                                                      \
 static __inline vtype                                                  \
 atomic_add_acq_ ## name(volatile ptype p, atype v)                     \
 {                                                                      \
-       return ((vtype)atomic_op_acq(p, +, v, sz));                     \
+       return ((vtype)atomic_op_acq((p), +, (v), sz));                 \
 }                                                                      \
 static __inline vtype                                                  \
 atomic_add_rel_ ## name(volatile ptype p, atype v)                     \
 {                                                                      \
-       return ((vtype)atomic_op_rel(p, +, v, sz));                     \
+       return ((vtype)atomic_op_rel((p), +, (v), sz));                 \
 }                                                                      \
                                                                        \
 static __inline vtype                                                  \
 atomic_clear_ ## name(volatile ptype p, atype v)                       \
 {                                                                      \
-       return ((vtype)atomic_op(p, &, ~v, sz));                        \
+       return ((vtype)atomic_op((p), &, ~(v), sz));                    \
 }                                                                      \
 static __inline vtype                                                  \
 atomic_clear_acq_ ## name(volatile ptype p, atype v)                   \
 {                                                                      \
-       return ((vtype)atomic_op_acq(p, &, ~v, sz));                    \
+       return ((vtype)atomic_op_acq((p), &, ~(v), sz));                \
 }                                                                      \
 static __inline vtype                                                  \
 atomic_clear_rel_ ## name(volatile ptype p, atype v)                   \
 {                                                                      \
-       return ((vtype)atomic_op_rel(p, &, ~v, sz));                    \
+       return ((vtype)atomic_op_rel((p), &, ~(v), sz));                \
 }                                                                      \
                                                                        \
 static __inline int                                                    \
 atomic_cmpset_ ## name(volatile ptype p, vtype e, vtype s)             \
 {                                                                      \
-       return (((vtype)atomic_cas(p, e, s, sz)) == e);                 \
+       return (((vtype)atomic_cas((p), (e), (s), sz)) == (e));         \
 }                                                                      \
 static __inline int                                                    \
 atomic_cmpset_acq_ ## name(volatile ptype p, vtype e, vtype s)         \
 {                                                                      \
-       return (((vtype)atomic_cas_acq(p, e, s, sz)) == e);             \
+       return (((vtype)atomic_cas_acq((p), (e), (s), sz)) == (e));     \
 }                                                                      \
 static __inline int                                                    \
 atomic_cmpset_rel_ ## name(volatile ptype p, vtype e, vtype s)         \
 {                                                                      \
-       return (((vtype)atomic_cas_rel(p, e, s, sz)) == e);             \
+       return (((vtype)atomic_cas_rel((p), (e), (s), sz)) == (e));     \
 }                                                                      \
                                                                        \
 static __inline vtype                                                  \
 atomic_load_ ## name(volatile ptype p)                                 \
 {                                                                      \
-       return ((vtype)atomic_cas(p, 0, 0, sz));                        \
+       return ((vtype)atomic_cas((p), 0, 0, sz));                      \
 }                                                                      \
 static __inline vtype                                                  \
 atomic_load_acq_ ## name(volatile ptype p)                             \
 {                                                                      \
-       return ((vtype)atomic_cas_acq(p, 0, 0, sz));                    \
+       return ((vtype)atomic_cas_acq((p), 0, 0, sz));                  \
 }                                                                      \
                                                                        \
 static __inline vtype                                                  \
 atomic_readandclear_ ## name(volatile ptype p)                         \
 {                                                                      \
-       return ((vtype)atomic_load_clear(p, sz));                       \
+       return ((vtype)atomic_load_clear((p), sz));                     \
 }                                                                      \
                                                                        \
 static __inline vtype                                                  \
 atomic_set_ ## name(volatile ptype p, atype v)                         \
 {                                                                      \
-       return ((vtype)atomic_op(p, |, v, sz));                         \
+       return ((vtype)atomic_op((p), |, (v), sz));                     \
 }                                                                      \
 static __inline vtype                                                  \
 atomic_set_acq_ ## name(volatile ptype p, atype v)                     \
 {                                                                      \
-       return ((vtype)atomic_op_acq(p, |, v, sz));                     \
+       return ((vtype)atomic_op_acq((p), |, (v), sz));                 \
 }                                                                      \
 static __inline vtype                                                  \
 atomic_set_rel_ ## name(volatile ptype p, atype v)                     \
 {                                                                      \
-       return ((vtype)atomic_op_rel(p, |, v, sz));                     \
+       return ((vtype)atomic_op_rel((p), |, (v), sz));                 \
 }                                                                      \
                                                                        \
 static __inline vtype                                                  \
 atomic_subtract_ ## name(volatile ptype p, atype v)                    \
 {                                                                      \
-       return ((vtype)atomic_op(p, -, v, sz));                         \
+       return ((vtype)atomic_op((p), -, (v), sz));                     \
 }                                                                      \
 static __inline vtype                                                  \
 atomic_subtract_acq_ ## name(volatile ptype p, atype v)                        
\
 {                                                                      \
-       return ((vtype)atomic_op_acq(p, -, v, sz));                     \
+       return ((vtype)atomic_op_acq((p), -, (v), sz));                 \
 }                                                                      \
 static __inline vtype                                                  \
 atomic_subtract_rel_ ## name(volatile ptype p, atype v)                        
\
 {                                                                      \
-       return ((vtype)atomic_op_rel(p, -, v, sz));                     \
+       return ((vtype)atomic_op_rel((p), -, (v), sz));                 \
 }                                                                      \
                                                                        \
 static __inline void                                                   \
 atomic_store_ ## name(volatile ptype p, vtype v)                       \
 {                                                                      \
-       atomic_store(p, v, sz);                                         \
+       atomic_store((p), (v), sz);                                     \
 }                                                                      \
 static __inline void                                                   \
 atomic_store_rel_ ## name(volatile ptype p, vtype v)                   \
 {                                                                      \
-       atomic_store_rel(p, v, sz);                                     \
+       atomic_store_rel((p), (v), sz);                                 \
 }
 
 ATOMIC_GEN(int, u_int *, u_int, u_int, 32);
_______________________________________________
[email protected] mailing list
http://lists.freebsd.org/mailman/listinfo/svn-src-all
To unsubscribe, send any mail to "[email protected]"

Reply via email to