ACE/ace/Atomic_Op.inl

   1 // -*- C++ -*-
   2 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
   3 # include "ace/os_include/os_intrin.h"
   4 # pragma intrinsic (_InterlockedExchange, _InterlockedExchangeAdd, _InterlockedIncrement, _InterlockedDecrement)
   5 #endif /* ACE_HAS_INTRINSIC_INTERLOCKED */
   6
   7 #if defined (ACE_HAS_VXATOMICLIB)
   8 # include <vxAtomicLib.h>
   9 #endif
  10
  11 #if defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
  12 # include <atomic.h>
  13 #endif
  14
  15 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  16
  17 #if defined (ACE_HAS_BUILTIN_ATOMIC_OP)
  18
  19 ACE_INLINE
  20 ACE_Atomic_Op<ACE_Thread_Mutex, long>::ACE_Atomic_Op (void)
  21   : value_ (0)
  22 {
  23 }
  24
  25 ACE_INLINE
  26 ACE_Atomic_Op<ACE_Thread_Mutex, long>::ACE_Atomic_Op (long c)
  27   : value_ (c)
  28 {
  29 }
  30
  31 ACE_INLINE
  32 ACE_Atomic_Op<ACE_Thread_Mutex, long>::ACE_Atomic_Op (
  33   const ACE_Atomic_Op<ACE_Thread_Mutex, long> &rhs)
  34   : value_ (rhs.value_)
  35 {
  36 }
  37
  38 ACE_INLINE long
  39 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator++ (void)
  40 {
  41 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
  42   return ::_InterlockedIncrement (const_cast<long *> (&this->value_));
  43 #elif defined (WIN32)
  44   return ::InterlockedIncrement (const_cast<long *> (&this->value_));
  45 #elif defined (ACE_HAS_VXATOMICLIB)
  46   return ::vxAtomicInc (reinterpret_cast <atomic_t*>(const_cast<long *> (&this->value_))) + 1;
  47 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
  48   return ::atomic_inc_ulong_nv (reinterpret_cast<volatile unsigned long*>(&this->value_));
  49 #else /* WIN32 */
  50   return (*increment_fn_) (&this->value_);
  51 #endif /* WIN32 */
  52 }
  53
  54 ACE_INLINE long
  55 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator++ (int)
  56 {
  57   return ++*this - 1;
  58 }
  59
  60 ACE_INLINE long
  61 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator-- (void)
  62 {
  63 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
  64   return ::_InterlockedDecrement (const_cast<long *> (&this->value_));
  65 #elif defined (WIN32)
  66   return ::InterlockedDecrement (const_cast<long *> (&this->value_));
  67 #elif defined (ACE_HAS_VXATOMICLIB)
  68   return ::vxAtomicDec (reinterpret_cast <atomic_t*>(const_cast<long *> (&this->value_))) - 1;
  69 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
  70   return ::atomic_dec_ulong_nv (reinterpret_cast<volatile unsigned long*>(&this->value_));
  71 #else /* WIN32 */
  72   return (*decrement_fn_) (&this->value_);
  73 #endif /* WIN32 */
  74 }
  75
  76 ACE_INLINE long
  77 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator-- (int)
  78 {
  79   return --*this + 1;
  80 }
  81
  82 ACE_INLINE long
  83 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator+= (long rhs)
  84 {
  85 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
  86   return ::_InterlockedExchangeAdd (const_cast<long *> (&this->value_),
  87                                     rhs) + rhs;
  88 #elif defined (WIN32) && defined (ACE_HAS_INTERLOCKED_EXCHANGEADD)
  89   return ::InterlockedExchangeAdd (const_cast<long *> (&this->value_),
  90                                    rhs) + rhs;
  91 #elif defined (ACE_HAS_VXATOMICLIB)
  92   return ::vxAtomicAdd (reinterpret_cast <atomic_t*>(const_cast<long *> (&this->value_)), rhs) + rhs;
  93 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
  94   return ::atomic_add_long_nv (reinterpret_cast<volatile unsigned long*>(&this->value_), rhs);
  95 #else /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */
  96   return (*exchange_add_fn_) (&this->value_, rhs) + rhs;
  97 #endif /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */
  98 }
  99
 100 ACE_INLINE long
 101 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator-= (long rhs)
 102 {
 103 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
 104   return ::_InterlockedExchangeAdd (const_cast<long *> (&this->value_),
 105                                     -rhs) - rhs;
 106 #elif defined (WIN32) && defined (ACE_HAS_INTERLOCKED_EXCHANGEADD)
 107   return ::InterlockedExchangeAdd (const_cast<long *> (&this->value_),
 108                                    -rhs) - rhs;
 109 #elif defined (ACE_HAS_VXATOMICLIB)
 110   return ::vxAtomicSub (reinterpret_cast <atomic_t*>(const_cast<long *> (&this->value_)), rhs) - rhs;
 111 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
 112   return ::atomic_add_long_nv (reinterpret_cast<volatile unsigned long*>(&this->value_), -rhs);
 113 #else /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */
 114   return (*exchange_add_fn_) (&this->value_, -rhs) - rhs;
 115 #endif /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */
 116 }
 117
 118 ACE_INLINE bool
 119 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator== (long rhs) const
 120 {
 121   return (this->value_ == rhs);
 122 }
 123
 124 ACE_INLINE bool
 125 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator!= (long rhs) const
 126 {
 127   return (this->value_ != rhs);
 128 }
 129
 130 ACE_INLINE bool
 131 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator>= (long rhs) const
 132 {
 133   return (this->value_ >= rhs);
 134 }
 135
 136 ACE_INLINE bool
 137 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator> (long rhs) const
 138 {
 139   return (this->value_ > rhs);
 140 }
 141
 142 ACE_INLINE bool
 143 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator<= (long rhs) const
 144 {
 145   return (this->value_ <= rhs);
 146 }
 147
 148 ACE_INLINE bool
 149 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator< (long rhs) const
 150 {
 151   return (this->value_ < rhs);
 152 }
 153
 154 ACE_INLINE ACE_Atomic_Op<ACE_Thread_Mutex, long> &
 155 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator= (long rhs)
 156 {
 157 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
 158   ::_InterlockedExchange (const_cast<long *> (&this->value_), rhs);
 159 #elif defined (WIN32)
 160   ::InterlockedExchange (const_cast<long *> (&this->value_), rhs);
 161 #elif defined (ACE_HAS_VXATOMICLIB)
 162   ::vxAtomicSet (reinterpret_cast <atomic_t*>(const_cast<long *> (&this->value_)), rhs);
 163 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
 164   ::atomic_swap_ulong (reinterpret_cast<volatile unsigned long*>(&this->value_), rhs);
 165 #else /* WIN32 */
 166   (*exchange_fn_) (&this->value_, rhs);
 167 #endif /* WIN32 */
 168   return *this;
 169 }
 170
 171 ACE_INLINE ACE_Atomic_Op<ACE_Thread_Mutex, long> &
 172 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator= (
 173    const ACE_Atomic_Op<ACE_Thread_Mutex, long> &rhs)
 174 {
 175 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
 176   ::_InterlockedExchange (const_cast<long *> (&this->value_), rhs.value_);
 177 #elif defined (WIN32)
 178   ::InterlockedExchange (const_cast<long *> (&this->value_), rhs.value_);
 179 #elif defined (ACE_HAS_VXATOMICLIB)
 180   ::vxAtomicSet (reinterpret_cast <atomic_t*>(const_cast<long *> (&this->value_)), rhs.value_);
 181 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
 182   ::atomic_swap_ulong (reinterpret_cast<volatile unsigned long*>(&this->value_), rhs.value_);
 183 #else /* WIN32 */
 184   (*exchange_fn_) (&this->value_, rhs.value_);
 185 #endif /* WIN32 */
 186   return *this;
 187 }
 188
 189 ACE_INLINE long
 190 ACE_Atomic_Op<ACE_Thread_Mutex, long>::exchange (long newval)
 191 {
 192 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
 193   return ::_InterlockedExchange (const_cast<long *> (&this->value_), newval);
 194 #elif defined (WIN32)
 195   return ::InterlockedExchange (const_cast<long *> (&this->value_), newval);
 196 #elif defined (ACE_HAS_VXATOMICLIB)
 197   return ::vxAtomicSet (reinterpret_cast <atomic_t*>(const_cast<long *> (&this->value_)), newval);
 198 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
 199   return ::atomic_swap_ulong (reinterpret_cast<volatile unsigned long*>(&this->value_), newval);
 200 #else /* WIN32 */
 201   return (*exchange_fn_) (&this->value_, newval);
 202 #endif /* WIN32 */
 203 }
 204
 205 ACE_INLINE long
 206 ACE_Atomic_Op<ACE_Thread_Mutex, long>::value (void) const
 207 {
 208   return this->value_;
 209 }
 210
 211 ACE_INLINE volatile long &
 212 ACE_Atomic_Op<ACE_Thread_Mutex, long>::value_i (void)
 213 {
 214   return this->value_;
 215 }
 216
 217
 218 ACE_INLINE
 219 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::ACE_Atomic_Op (void)
 220   : value_ (0)
 221 {
 222 }
 223
 224 ACE_INLINE
 225 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::ACE_Atomic_Op (unsigned long c)
 226   : value_ (c)
 227 {
 228 }
 229
 230 ACE_INLINE
 231 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::ACE_Atomic_Op (
 232   const ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long> &rhs)
 233   : value_ (rhs.value_)
 234 {
 235 }
 236
 237 ACE_INLINE unsigned long
 238 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator++ (void)
 239 {
 240 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
 241   return static_cast<unsigned long> (::_InterlockedIncrement (const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_))));
 242 #elif defined (WIN32)
 243   return static_cast<unsigned long> (::InterlockedIncrement (const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_))));
 244 #elif defined (ACE_HAS_VXATOMICLIB)
 245   return static_cast<unsigned long> (::vxAtomicInc (reinterpret_cast <atomic_t*>(const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_))))) + 1;
 246 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
 247   return ::atomic_inc_ulong_nv (&this->value_);
 248 #else /* WIN32 */
 249   return static_cast<unsigned long> ((*increment_fn_) (reinterpret_cast<volatile long *> (&this->value_)));
 250 #endif /* WIN32 */
 251 }
 252
 253 ACE_INLINE unsigned long
 254 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator++ (int)
 255 {
 256   return ++*this - 1;
 257 }
 258
 259 ACE_INLINE unsigned long
 260 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator-- (void)
 261 {
 262 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
 263   return static_cast<unsigned long> (::_InterlockedDecrement (const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_))));
 264 #elif defined (WIN32)
 265   return static_cast<unsigned long> (::InterlockedDecrement (const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_))));
 266 #elif defined (ACE_HAS_VXATOMICLIB)
 267   return static_cast<unsigned long> (::vxAtomicDec (reinterpret_cast <atomic_t*>(const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_))))) - 1;
 268 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
 269   return ::atomic_dec_ulong_nv (&this->value_);
 270 #else /* WIN32 */
 271   return static_cast<unsigned long> ((*decrement_fn_) (reinterpret_cast<volatile long *> (&this->value_)));
 272 #endif /* WIN32 */
 273 }
 274
 275 ACE_INLINE unsigned long
 276 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator-- (int)
 277 {
 278   return --*this + 1;
 279 }
 280
 281 ACE_INLINE unsigned long
 282 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator+= (unsigned long rhs)
 283 {
 284 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
 285   return static_cast<unsigned long> (::_InterlockedExchangeAdd (const_cast<long *> (reinterpret_cast <volatile long *>(&this->value_)),
 286                                    rhs)) + rhs;
 287 #elif defined (WIN32) && defined (ACE_HAS_INTERLOCKED_EXCHANGEADD)
 288   return static_cast<unsigned long> (::InterlockedExchangeAdd (const_cast<long *> (reinterpret_cast <volatile long *>(&this->value_)),
 289                                    rhs)) + rhs;
 290 #elif defined (ACE_HAS_VXATOMICLIB)
 291   return static_cast<unsigned long> (::vxAtomicAdd (reinterpret_cast <atomic_t*>(const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_))), rhs)) + rhs;
 292 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
 293   return ::atomic_add_long_nv (&this->value_, rhs);
 294 #else /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */
 295   return static_cast<unsigned long> ((*exchange_add_fn_) (reinterpret_cast<volatile long *> (&this->value_), rhs)) + rhs;
 296 #endif /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */
 297 }
 298
 299 ACE_INLINE unsigned long
 300 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator-= (unsigned long rhs)
 301 {
 302 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
 303   return static_cast<unsigned long> (::_InterlockedExchangeAdd (const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_)),
 304                                    -static_cast<long>(rhs))) - rhs;
 305 #elif defined (WIN32) && defined (ACE_HAS_INTERLOCKED_EXCHANGEADD)
 306   return static_cast<unsigned long> (::InterlockedExchangeAdd (const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_)),
 307                                    -static_cast<long>(rhs))) - rhs;
 308 #elif defined (ACE_HAS_VXATOMICLIB)
 309   return static_cast<unsigned long> (::vxAtomicSub (reinterpret_cast <atomic_t*>(const_cast<long *> (reinterpret_cast<volatile long *>(&this->value_))), rhs)) - rhs;
 310 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
 311   return ::atomic_add_long_nv (&this->value_, -rhs);
 312 #else /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */
 313   long l_rhs = static_cast<long> (rhs);
 314   return static_cast<unsigned long> ((*exchange_add_fn_) (reinterpret_cast<volatile long *> (&this->value_), -l_rhs)) - rhs;
 315 #endif /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */
 316 }
 317
 318 ACE_INLINE bool
 319 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator== (unsigned long rhs) const
 320 {
 321   return (this->value_ == rhs);
 322 }
 323
 324 ACE_INLINE bool
 325 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator!= (unsigned long rhs) const
 326 {
 327   return (this->value_ != rhs);
 328 }
 329
 330 ACE_INLINE bool
 331 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator>= (unsigned long rhs) const
 332 {
 333   return (this->value_ >= rhs);
 334 }
 335
 336 ACE_INLINE bool
 337 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator> (unsigned long rhs) const
 338 {
 339   return (this->value_ > rhs);
 340 }
 341
 342 ACE_INLINE bool
 343 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator<= (unsigned long rhs) const
 344 {
 345   return (this->value_ <= rhs);
 346 }
 347
 348 ACE_INLINE bool
 349 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator< (unsigned long rhs) const
 350 {
 351   return (this->value_ < rhs);
 352 }
 353
 354 ACE_INLINE ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long> &
 355 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator= (unsigned long rhs)
 356 {
 357 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
 358   ::_InterlockedExchange (const_cast<long *> (reinterpret_cast<volatile long*> (&this->value_)), rhs);
 359 #elif defined (WIN32)
 360   ::InterlockedExchange (const_cast<long *> (reinterpret_cast<volatile long*> (&this->value_)), rhs);
 361 #elif defined (ACE_HAS_VXATOMICLIB)
 362   ::vxAtomicSet (reinterpret_cast <atomic_t*>(const_cast<long *> (reinterpret_cast<volatile long*> (&this->value_))), rhs);
 363 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
 364   ::atomic_swap_ulong (&this->value_, rhs);
 365 #else /* WIN32 */
 366   (*exchange_fn_) (reinterpret_cast<volatile long *> (&this->value_), rhs);
 367 #endif /* WIN32 */
 368   return *this;
 369 }
 370
 371 ACE_INLINE ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long> &
 372 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator= (
 373    const ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long> &rhs)
 374 {
 375 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
 376   ::_InterlockedExchange (const_cast<long *> (reinterpret_cast<volatile long*> (&this->value_)), rhs.value_);
 377 #elif defined (WIN32)
 378   ::InterlockedExchange (const_cast<long *> (reinterpret_cast<volatile long*> (&this->value_)), rhs.value_);
 379 #elif defined (ACE_HAS_VXATOMICLIB)
 380   ::vxAtomicSet (reinterpret_cast <atomic_t*>(const_cast<long *> (reinterpret_cast<volatile long*> (&this->value_))), rhs.value_);
 381 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
 382   ::atomic_swap_ulong (&this->value_, rhs.value_);
 383 #else /* WIN32 */
 384   (*exchange_fn_) (reinterpret_cast<volatile long *> (&this->value_), rhs.value_);
 385 #endif /* WIN32 */
 386   return *this;
 387 }
 388
 389 ACE_INLINE unsigned long
 390 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::exchange (unsigned long newval)
 391 {
 392 #if defined (ACE_HAS_INTRINSIC_INTERLOCKED)
 393   return ::_InterlockedExchange (const_cast<long *> (reinterpret_cast<volatile long*> (&this->value_)), newval);
 394 #elif defined (WIN32)
 395   return ::InterlockedExchange (const_cast<long *> (reinterpret_cast<volatile long*> (&this->value_)), newval);
 396 #elif defined (ACE_HAS_VXATOMICLIB)
 397   return ::vxAtomicSet (reinterpret_cast <atomic_t*>(const_cast<long *> (reinterpret_cast<volatile long*> (&this->value_))), newval);
 398 #elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB)
 399   return ::atomic_swap_ulong (&this->value_, newval);
 400 #else /* WIN32 */
 401   return (*exchange_fn_) (reinterpret_cast<volatile long *> (&this->value_), newval);
 402 #endif /* WIN32 */
 403 }
 404
 405 ACE_INLINE unsigned long
 406 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::value (void) const
 407 {
 408   return this->value_;
 409 }
 410
 411 ACE_INLINE volatile unsigned long &
 412 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::value_i (void)
 413 {
 414   return this->value_;
 415 }
 416
 417 #endif /* ACE_HAS_BUILTIN_ATOMIC_OP */
 418
 419 #if defined (ACE_HAS_GCC_ATOMIC_BUILTINS) && (ACE_HAS_GCC_ATOMIC_BUILTINS == 1)
 420
 421 ACE_INLINE
 422 ACE_Atomic_Op<ACE_Thread_Mutex, int>::ACE_Atomic_Op (void) :
 423   ACE_Atomic_Op_GCC<int> ()
 424 {
 425 }
 426
 427 ACE_INLINE
 428 ACE_Atomic_Op<ACE_Thread_Mutex, int>::ACE_Atomic_Op (int c) :
 429   ACE_Atomic_Op_GCC<int>(c)
 430 {
 431 }
 432
 433 ACE_INLINE
 434 ACE_Atomic_Op<ACE_Thread_Mutex, int>::ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, int> &c) :
 435   ACE_Atomic_Op_GCC<int>(c)
 436 {
 437 }
 438
 439 ACE_INLINE
 440 ACE_Atomic_Op<ACE_Thread_Mutex, int>&
 441 ACE_Atomic_Op<ACE_Thread_Mutex, int>::operator= (int rhs)
 442 {
 443   ACE_Atomic_Op_GCC<int>::operator= (rhs);
 444   return *this;
 445 }
 446
 447
 448 ACE_INLINE
 449 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned int>::ACE_Atomic_Op (void) :
 450   ACE_Atomic_Op_GCC<unsigned int>()
 451 {
 452 }
 453
 454 ACE_INLINE
 455 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned int>::ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, unsigned int> &c) :
 456   ACE_Atomic_Op_GCC<unsigned int>(c)
 457 {
 458 }
 459
 460 ACE_INLINE
 461 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned int>::ACE_Atomic_Op (unsigned int c) :
 462   ACE_Atomic_Op_GCC<unsigned int>(c)
 463 {
 464 }
 465
 466 ACE_INLINE
 467 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned int>&
 468 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned int>::operator= (unsigned int rhs)
 469 {
 470   ACE_Atomic_Op_GCC<unsigned int>::operator= (rhs);
 471   return *this;
 472 }
 473
 474 ACE_INLINE
 475 ACE_Atomic_Op<ACE_Thread_Mutex, long>::ACE_Atomic_Op (void) :
 476   ACE_Atomic_Op_GCC<long>()
 477 {
 478 }
 479
 480 ACE_INLINE
 481 ACE_Atomic_Op<ACE_Thread_Mutex, long>::ACE_Atomic_Op (long c) :
 482   ACE_Atomic_Op_GCC<long>(c)
 483 {
 484 }
 485
 486 ACE_INLINE
 487 ACE_Atomic_Op<ACE_Thread_Mutex, long>::ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, long> &c) :
 488   ACE_Atomic_Op_GCC<long>(c)
 489 {
 490 }
 491
 492 ACE_INLINE
 493 ACE_Atomic_Op<ACE_Thread_Mutex, long>&
 494 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator= (long rhs)
 495 {
 496   ACE_Atomic_Op_GCC<long>::operator= (rhs);
 497   return *this;
 498 }
 499
 500 ACE_INLINE
 501 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::ACE_Atomic_Op (void) :
 502   ACE_Atomic_Op_GCC<unsigned long> ()
 503 {
 504 }
 505
 506 ACE_INLINE
 507 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::ACE_Atomic_Op (unsigned long c) :
 508   ACE_Atomic_Op_GCC<unsigned long>(c)
 509 {
 510 }
 511
 512 ACE_INLINE
 513 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long> &c) :
 514   ACE_Atomic_Op_GCC<unsigned long>(c)
 515 {
 516 }
 517
 518 ACE_INLINE
 519 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>&
 520 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::operator= (unsigned long rhs)
 521 {
 522   ACE_Atomic_Op_GCC<unsigned long>::operator= (rhs);
 523   return *this;
 524 }
 525
 526 // The long long intrinsics are not available on PPC
 527 #if !defined (__powerpc__)
 528 ACE_INLINE
 529 ACE_Atomic_Op<ACE_Thread_Mutex, long long>::ACE_Atomic_Op (void) :
 530   ACE_Atomic_Op_GCC<long long>()
 531 {
 532 }
 533
 534 ACE_INLINE
 535 ACE_Atomic_Op<ACE_Thread_Mutex, long long>::ACE_Atomic_Op (long long c) :
 536   ACE_Atomic_Op_GCC<long long>(c)
 537 {
 538 }
 539
 540 ACE_INLINE
 541 ACE_Atomic_Op<ACE_Thread_Mutex, long long>::ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, long long> &c) :
 542   ACE_Atomic_Op_GCC<long long>(c)
 543 {
 544 }
 545
 546 ACE_INLINE
 547 ACE_Atomic_Op<ACE_Thread_Mutex, long long>&
 548 ACE_Atomic_Op<ACE_Thread_Mutex, long long>::operator= (long long rhs)
 549 {
 550   ACE_Atomic_Op_GCC<long long>::operator= (rhs);
 551   return *this;
 552 }
 553
 554 ACE_INLINE
 555 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long long>::ACE_Atomic_Op (void) :
 556   ACE_Atomic_Op_GCC<unsigned long  long> ()
 557 {
 558 }
 559
 560 ACE_INLINE
 561 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long  long>::ACE_Atomic_Op (unsigned long long c) :
 562   ACE_Atomic_Op_GCC<unsigned long long>(c)
 563 {
 564 }
 565
 566 ACE_INLINE
 567 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long long>::ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long long> &c) :
 568   ACE_Atomic_Op_GCC<unsigned long long>(c)
 569 {
 570 }
 571
 572 ACE_INLINE
 573 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long long>&
 574 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long long>::operator= (unsigned long long rhs)
 575 {
 576   ACE_Atomic_Op_GCC<unsigned long long>::operator= (rhs);
 577   return *this;
 578 }
 579 #endif /* !__powerpc__ */
 580
 581 #if !defined (ACE_LACKS_GCC_ATOMIC_BUILTINS_2)
 582 ACE_INLINE
 583 ACE_Atomic_Op<ACE_Thread_Mutex, short>::ACE_Atomic_Op (void) :
 584   ACE_Atomic_Op_GCC<short>()
 585 {
 586 }
 587
 588 ACE_INLINE
 589 ACE_Atomic_Op<ACE_Thread_Mutex, short>::ACE_Atomic_Op (short c) :
 590   ACE_Atomic_Op_GCC<short>(c)
 591 {
 592 }
 593
 594 ACE_INLINE
 595 ACE_Atomic_Op<ACE_Thread_Mutex, short>::ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, short> &c) :
 596   ACE_Atomic_Op_GCC<short>(c)
 597 {
 598 }
 599
 600 ACE_INLINE
 601 ACE_Atomic_Op<ACE_Thread_Mutex, short>&
 602 ACE_Atomic_Op<ACE_Thread_Mutex, short>::operator= (short rhs)
 603 {
 604   ACE_Atomic_Op_GCC<short>::operator= (rhs);
 605   return *this;
 606 }
 607
 608 ACE_INLINE
 609 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned short>::ACE_Atomic_Op (void) :
 610   ACE_Atomic_Op_GCC<unsigned short> ()
 611 {
 612 }
 613
 614 ACE_INLINE
 615 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned short>::ACE_Atomic_Op (unsigned short c) :
 616   ACE_Atomic_Op_GCC<unsigned short>(c)
 617 {
 618 }
 619
 620 ACE_INLINE
 621 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned short>::ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, unsigned short> &c) :
 622   ACE_Atomic_Op_GCC<unsigned short>(c)
 623 {
 624 }
 625
 626 ACE_INLINE
 627 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned short>&
 628 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned short>::operator= (unsigned short rhs)
 629 {
 630   ACE_Atomic_Op_GCC<unsigned short>::operator= (rhs);
 631   return *this;
 632 }
 633 #endif
 634
 635 #if !defined (ACE_LACKS_GCC_ATOMIC_BUILTINS_1)
 636 ACE_INLINE
 637 ACE_Atomic_Op<ACE_Thread_Mutex, bool>::ACE_Atomic_Op (void) :
 638   ACE_Atomic_Op_GCC<bool> ()
 639 {
 640 }
 641
 642 ACE_INLINE
 643 ACE_Atomic_Op<ACE_Thread_Mutex, bool>::ACE_Atomic_Op (bool c) :
 644   ACE_Atomic_Op_GCC<bool>(c)
 645 {
 646 }
 647
 648 ACE_INLINE
 649 ACE_Atomic_Op<ACE_Thread_Mutex, bool>::ACE_Atomic_Op (const ACE_Atomic_Op<ACE_Thread_Mutex, bool> &c) :
 650   ACE_Atomic_Op_GCC<bool>(c)
 651 {
 652 }
 653
 654 ACE_INLINE
 655 ACE_Atomic_Op<ACE_Thread_Mutex, bool>&
 656 ACE_Atomic_Op<ACE_Thread_Mutex, bool>::operator= (bool rhs)
 657 {
 658   ACE_Atomic_Op_GCC<bool>::operator= (rhs);
 659   return *this;
 660 }
 661 #endif
 662
 663 #endif /* ACE_HAS_GCC_ATOMIC_BUILTINS==1 */
 664
 665 ACE_END_VERSIONED_NAMESPACE_DECL
 666