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