_atomic.h

Go to the documentation of this file.

 
#ifndef _RWSTD_RW_ATOMIC_H_INCLUDED
#define _RWSTD_RW_ATOMIC_H_INCLUDED
 
 
#if __GNUG__ >= 3
#  pragma GCC system_header
#endif   // gcc >= 3
 
 
#ifndef _RWSTD_RW_DEFS_H_INCLUDED
#  include <rw/_defs.h>
#endif   // _RWSTD_RW_DEFS_H_INCLUDED
 
 
#ifdef _RWSTD_REENTRANT
 
#  if defined (_RWSTD_NO_ATOMIC_OPS)
     // do nothing
#  elif defined (__DECCXX)
#    include <rw/_atomic-deccxx.h>
#  elif defined (__sparc) && (defined (__SUNPRO_CC) || defined (__GNUG__))
#    include <rw/_atomic-sparc.h>
#  elif defined (_AIX43) && defined (__IBMCPP__)
#    include <rw/_atomic-xlc.h>
#  elif defined (__sgi) && defined (__host_mips)
#    include <rw/_atomic-mipspro.h>
#  elif defined (_PA_RISC2_0)
#    include <rw/_atomic-parisc.h>
#  elif defined (__GNUG__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 401) \
     && (defined (__i486__) || defined (__x86_64) || defined (__ia64)) \
     && !defined (__INTEL_COMPILER)                                    \
     || (defined (__INTEL_COMPILER) && defined (__ia64))
#    include <rw/_atomic-sync.h>
#  elif defined (__i386__) && (defined (__GNUG__) \
     || defined (__INTEL_COMPILER)) || defined (_M_IX86)
#    include <rw/_atomic-x86.h>
#  elif defined (__ia64) || defined (__x86_64) || defined (_M_X64)
#    include <rw/_atomic-x64.h>
#  else
#    define _RWSTD_NO_ATOMIC_OPS
#  endif
 
#  ifndef _RWSTD_NO_ATOMIC_OPS
 
 
#    ifndef _RWSTD_NO_BOOL
 
#      if   _RWSTD_BOOL_SIZE == _RWSTD_CHAR_SIZE  \
         && !defined (_RWSTD_NO_CHAR_ATOMIC_OPS)
#        define _RWSTD_BOOL_TYPE char
#      elif _RWSTD_BOOL_SIZE == _RWSTD_SHORT_SIZE \
         && !defined (_RWSTD_NO_SHORT_ATOMIC_OPS)
#        define _RWSTD_BOOL_TYPE short
#      elif _RWSTD_BOOL_SIZE == _RWSTD_INT_SIZE   \
         && !defined (_RWSTD_NO_INT_ATOMIC_OPS)
#        define _RWSTD_BOOL_TYPE int
#      endif
 
#      ifdef _RWSTD_BOOL_TYPE
 
_RWSTD_NAMESPACE (__rw) {
 
inline bool
__rw_atomic_exchange (bool &__x, bool __y, bool)
{
    return 0 != __rw_atomic_exchange (
                    _RWSTD_REINTERPRET_CAST (_RWSTD_BOOL_TYPE&, __x),
                    _RWSTD_STATIC_CAST (_RWSTD_BOOL_TYPE, __y),
                    false);
}
 
}   // namespace __rw
 
#        undef _RWSTD_BOOL_TYPE
#      endif   // _RWSTD_BOOL_TYPE
 
#    endif   // _RWSTD_NO_BOOL
 
 
 
#    if   _RWSTD_LONG_SIZE == _RWSTD_INT_SIZE \
       && defined (_RWSTD_NO_LONG_ATOMIC_OPS) \
       && !defined (_RWSTD_NO_INT_ATOMIC_OPS)
 
#      undef _RWSTD_NO_LONG_ATOMIC_OPS
 
#      if 6 == _RWSTD_HP_aCC_MAJOR
         // suppress HP aCC 64 bit migration remark: conversion from
         // "long *" to "int *" may cause target of pointers to have
         // a different size
#        pragma diag_suppress 4230
#      endif   // HP aCC 6
 
_RWSTD_NAMESPACE (__rw) {
 
inline long
__rw_atomic_preincrement (long &__x, bool)
{
    return __rw_atomic_preincrement (_RWSTD_REINTERPRET_CAST (int&, __x),
                                     false);
}
 
inline unsigned long
__rw_atomic_preincrement (unsigned long &__x, bool)
{
    return __rw_atomic_preincrement (_RWSTD_REINTERPRET_CAST (int&, __x),
                                     false);
}
 
inline long
__rw_atomic_predecrement (long &__x, bool)
{
    return __rw_atomic_predecrement (_RWSTD_REINTERPRET_CAST (int&, __x),
                                     false);
}
 
inline unsigned long
__rw_atomic_predecrement (unsigned long &__x, bool)
{
    return __rw_atomic_predecrement (_RWSTD_REINTERPRET_CAST (int&, __x),
                                     false);
}
 
inline long
__rw_atomic_exchange (long &__x, long __y, bool)
{
    return __rw_atomic_exchange (_RWSTD_REINTERPRET_CAST (int&, __x),
                                 _RWSTD_STATIC_CAST (int, __y),
                                 false);
}
 
inline unsigned long
__rw_atomic_exchange (unsigned long &__x,
                      unsigned long __y, bool)
{
    return __rw_atomic_exchange (_RWSTD_REINTERPRET_CAST (int&, __x),
                                 _RWSTD_STATIC_CAST (int, __y),
                                 false);
}
 
}   // namespace __rw
 
#      if 6 == _RWSTD_HP_aCC_MAJOR
#        pragma diag_default 4230
#      endif   // HP aCC 6
 
#    endif   // _RWSTD_LONG_SIZE == _RWSTD_INT_SIZE
 
 
 
#    if   defined (_RWSTD_LONG_LONG)            \
       && _RWSTD_LLONG_SIZE == _RWSTD_LONG_SIZE \
       && defined (_RWSTD_NO_LLONG_ATOMIC_OPS)  \
       && !defined (_RWSTD_NO_LONG_ATOMIC_OPS)
 
#      undef _RWSTD_NO_LLONG_ATOMIC_OPS
 
_RWSTD_NAMESPACE (__rw) {
    
inline _RWSTD_LONG_LONG
__rw_atomic_preincrement (_RWSTD_LONG_LONG &__x, bool)
{
    return __rw_atomic_preincrement (_RWSTD_REINTERPRET_CAST (long&, __x),
                                     false);
}
 
inline unsigned _RWSTD_LONG_LONG
__rw_atomic_preincrement (unsigned _RWSTD_LONG_LONG &__x, bool)
{
    return __rw_atomic_preincrement (_RWSTD_REINTERPRET_CAST (long&, __x),
                                     false);
}
 
inline _RWSTD_LONG_LONG
__rw_atomic_predecrement (_RWSTD_LONG_LONG &__x, bool)
{
    return __rw_atomic_predecrement (_RWSTD_REINTERPRET_CAST (long&, __x),
                                     false);
}
 
inline unsigned _RWSTD_LONG_LONG
__rw_atomic_predecrement (unsigned _RWSTD_LONG_LONG &__x, bool)
{
    return __rw_atomic_predecrement (_RWSTD_REINTERPRET_CAST (long&, __x),
                                     false);
}
 
inline _RWSTD_LONG_LONG
__rw_atomic_exchange (_RWSTD_LONG_LONG &__x, _RWSTD_LONG_LONG __y, bool)
{
    return __rw_atomic_exchange (_RWSTD_REINTERPRET_CAST (long&, __x),
                                 _RWSTD_STATIC_CAST (long, __y),
                                 false);
}
 
inline unsigned _RWSTD_LONG_LONG
__rw_atomic_exchange (unsigned _RWSTD_LONG_LONG &__x,
                      unsigned _RWSTD_LONG_LONG __y, bool)
{
    return __rw_atomic_exchange (_RWSTD_REINTERPRET_CAST (long&, __x),
                                 _RWSTD_STATIC_CAST (long, __y),
                                 false);
}
 
}   // namespace __rw
 
#    endif   // _RWSTD_LONG_LONG && _RWSTD_LLONG_SIZE == _RWSTD_LONG_SIZE
 
#  endif   // _RWSTD_NO_ATOMIC_OPS
 
#else   // if !defined (_RWSTD_REENTRANT)
 
_RWSTD_NAMESPACE (__rw) {
    
// atomic in a single-threaded environment
template <class _TypeT, class _TypeU>
inline
_TypeT __rw_atomic_exchange (_TypeT &__t, const _TypeU &__u, bool)
{
    _TypeT __tmp = __t;
    __t = _TypeT (__u);
    return __tmp;
}
 
}   // namespace __rw
 
#endif   // _RWSTD_REENTRANT
 
 
_RWSTD_NAMESPACE (__rw) {
 
// available in all environments (ST and MT), used along with
// __rw_atomic_exchange<>() from conditional expressions in iostreams
template <class _TypeT, class _TypeU>
inline
_TypeT __rw_ordinary_exchange (_TypeT &__t, const _TypeU &__u)
{
    _TypeT __tmp = __t;
    __t = __u;
    return __tmp;
}
 
}   // namespace __rw
 
 
#endif   // _RWSTD_RW_ATOMIC_H_INCLUDED