< prev index next >

src/os_cpu/solaris_sparc/vm/atomic_solaris_sparc.hpp

Print this page
rev 13452 : [mq]: coleen_review1


  84 }
  85 
  86 inline intptr_t Atomic::xchg_ptr(intptr_t exchange_value, volatile intptr_t* dest) {
  87   return _Atomic_swap64(exchange_value, dest);
  88 }
  89 
  90 inline void*    Atomic::xchg_ptr(void*    exchange_value, volatile void*     dest) {
  91   return (void*)xchg_ptr((intptr_t)exchange_value, (volatile intptr_t*)dest);
  92 }
  93 
  94 // No direct support for cmpxchg of bytes; emulate using int.
  95 template<>
  96 struct Atomic::PlatformCmpxchg<1> : Atomic::CmpxchgByteUsingInt {};
  97 
  98 template<>
  99 template<typename T>
 100 inline T Atomic::PlatformCmpxchg<4>::operator()(T exchange_value,
 101                                                 T volatile* dest,
 102                                                 T compare_value,
 103                                                 cmpxchg_memory_order order) const {

 104   T rv;
 105   __asm__ volatile(
 106     " cas    [%2], %3, %0"
 107     : "=r" (rv)
 108     : "0" (exchange_value), "r" (dest), "r" (compare_value)
 109     : "memory");
 110   return rv;
 111 }
 112 
 113 template<>
 114 template<typename T>
 115 inline T Atomic::PlatformCmpxchg<8>::operator()(T exchange_value,
 116                                                 T volatile* dest,
 117                                                 T compare_value,
 118                                                 cmpxchg_memory_order order) const {

 119   T rv;
 120   __asm__ volatile(
 121     " casx   [%2], %3, %0"
 122     : "=r" (rv)
 123     : "0" (exchange_value), "r" (dest), "r" (compare_value)
 124     : "memory");
 125   return rv;
 126 }
 127 
 128 #endif // OS_CPU_SOLARIS_SPARC_VM_ATOMIC_SOLARIS_SPARC_HPP


  84 }
  85 
  86 inline intptr_t Atomic::xchg_ptr(intptr_t exchange_value, volatile intptr_t* dest) {
  87   return _Atomic_swap64(exchange_value, dest);
  88 }
  89 
  90 inline void*    Atomic::xchg_ptr(void*    exchange_value, volatile void*     dest) {
  91   return (void*)xchg_ptr((intptr_t)exchange_value, (volatile intptr_t*)dest);
  92 }
  93 
  94 // No direct support for cmpxchg of bytes; emulate using int.
  95 template<>
  96 struct Atomic::PlatformCmpxchg<1> : Atomic::CmpxchgByteUsingInt {};
  97 
  98 template<>
  99 template<typename T>
 100 inline T Atomic::PlatformCmpxchg<4>::operator()(T exchange_value,
 101                                                 T volatile* dest,
 102                                                 T compare_value,
 103                                                 cmpxchg_memory_order order) const {
 104   STATIC_ASSERT(4 == sizeof(T));
 105   T rv;
 106   __asm__ volatile(
 107     " cas    [%2], %3, %0"
 108     : "=r" (rv)
 109     : "0" (exchange_value), "r" (dest), "r" (compare_value)
 110     : "memory");
 111   return rv;
 112 }
 113 
 114 template<>
 115 template<typename T>
 116 inline T Atomic::PlatformCmpxchg<8>::operator()(T exchange_value,
 117                                                 T volatile* dest,
 118                                                 T compare_value,
 119                                                 cmpxchg_memory_order order) const {
 120   STATIC_ASSERT(8 == sizeof(T));
 121   T rv;
 122   __asm__ volatile(
 123     " casx   [%2], %3, %0"
 124     : "=r" (rv)
 125     : "0" (exchange_value), "r" (dest), "r" (compare_value)
 126     : "memory");
 127   return rv;
 128 }
 129 
 130 #endif // OS_CPU_SOLARIS_SPARC_VM_ATOMIC_SOLARIS_SPARC_HPP
< prev index next >