hotspot/src/os_cpu/solaris_sparc/vm/atomic_solaris_sparc.hpp
changeset 46958 a13bd8c6b7a2
parent 46534 025dfc75204d
child 46993 dd0f91c85ffc
equal deleted inserted replaced
46953:39063b484ec2 46958:a13bd8c6b7a2
    22  *
    22  *
    23  */
    23  */
    24 
    24 
    25 #ifndef OS_CPU_SOLARIS_SPARC_VM_ATOMIC_SOLARIS_SPARC_HPP
    25 #ifndef OS_CPU_SOLARIS_SPARC_VM_ATOMIC_SOLARIS_SPARC_HPP
    26 #define OS_CPU_SOLARIS_SPARC_VM_ATOMIC_SOLARIS_SPARC_HPP
    26 #define OS_CPU_SOLARIS_SPARC_VM_ATOMIC_SOLARIS_SPARC_HPP
    27 
       
    28 #include "runtime/os.hpp"
       
    29 
    27 
    30 // Implementation of class atomic
    28 // Implementation of class atomic
    31 
    29 
    32 inline void Atomic::store    (jbyte    store_value, jbyte*    dest) { *dest = store_value; }
    30 inline void Atomic::store    (jbyte    store_value, jbyte*    dest) { *dest = store_value; }
    33 inline void Atomic::store    (jshort   store_value, jshort*   dest) { *dest = store_value; }
    31 inline void Atomic::store    (jshort   store_value, jshort*   dest) { *dest = store_value; }
    62 // omits the instruction set check.
    60 // omits the instruction set check.
    63 
    61 
    64 extern "C" jint     _Atomic_swap32(jint     exchange_value, volatile jint*     dest);
    62 extern "C" jint     _Atomic_swap32(jint     exchange_value, volatile jint*     dest);
    65 extern "C" intptr_t _Atomic_swap64(intptr_t exchange_value, volatile intptr_t* dest);
    63 extern "C" intptr_t _Atomic_swap64(intptr_t exchange_value, volatile intptr_t* dest);
    66 
    64 
    67 extern "C" jint     _Atomic_cas32(jint     exchange_value, volatile jint*     dest, jint     compare_value);
       
    68 extern "C" intptr_t _Atomic_cas64(intptr_t exchange_value, volatile intptr_t* dest, intptr_t compare_value);
       
    69 extern "C" jlong    _Atomic_casl (jlong    exchange_value, volatile jlong*    dest, jlong    compare_value);
       
    70 
       
    71 extern "C" jint     _Atomic_add32(jint     inc,       volatile jint*     dest);
    65 extern "C" jint     _Atomic_add32(jint     inc,       volatile jint*     dest);
    72 extern "C" intptr_t _Atomic_add64(intptr_t add_value, volatile intptr_t* dest);
    66 extern "C" intptr_t _Atomic_add64(intptr_t add_value, volatile intptr_t* dest);
    73 
    67 
    74 
    68 
    75 inline jint     Atomic::add     (jint    add_value, volatile jint*     dest) {
    69 inline jint     Atomic::add     (jint    add_value, volatile jint*     dest) {
    95 
    89 
    96 inline void*    Atomic::xchg_ptr(void*    exchange_value, volatile void*     dest) {
    90 inline void*    Atomic::xchg_ptr(void*    exchange_value, volatile void*     dest) {
    97   return (void*)xchg_ptr((intptr_t)exchange_value, (volatile intptr_t*)dest);
    91   return (void*)xchg_ptr((intptr_t)exchange_value, (volatile intptr_t*)dest);
    98 }
    92 }
    99 
    93 
       
    94 // No direct support for cmpxchg of bytes; emulate using int.
       
    95 template<>
       
    96 struct Atomic::PlatformCmpxchg<1> : Atomic::CmpxchgByteUsingInt {};
   100 
    97 
   101 inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value, cmpxchg_memory_order order) {
    98 template<>
   102   return _Atomic_cas32(exchange_value, dest, compare_value);
    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;
   103 }
   112 }
   104 
   113 
   105 inline jlong    Atomic::cmpxchg    (jlong    exchange_value, volatile jlong*    dest, jlong    compare_value, cmpxchg_memory_order order) {
   114 template<>
   106   // Return 64 bit value in %o0
   115 template<typename T>
   107   return _Atomic_cas64((intptr_t)exchange_value, (intptr_t *)dest, (intptr_t)compare_value);
   116 inline T Atomic::PlatformCmpxchg<8>::operator()(T exchange_value,
   108 }
   117                                                 T volatile* dest,
   109 
   118                                                 T compare_value,
   110 inline intptr_t Atomic::cmpxchg_ptr(intptr_t exchange_value, volatile intptr_t* dest, intptr_t compare_value, cmpxchg_memory_order order) {
   119                                                 cmpxchg_memory_order order) const {
   111   return _Atomic_cas64(exchange_value, dest, compare_value);
   120   STATIC_ASSERT(8 == sizeof(T));
   112 }
   121   T rv;
   113 
   122   __asm__ volatile(
   114 inline void*    Atomic::cmpxchg_ptr(void*    exchange_value, volatile void*     dest, void*    compare_value, cmpxchg_memory_order order) {
   123     " casx   [%2], %3, %0"
   115   return (void*)cmpxchg_ptr((intptr_t)exchange_value, (volatile intptr_t*)dest, (intptr_t)compare_value, order);
   124     : "=r" (rv)
       
   125     : "0" (exchange_value), "r" (dest), "r" (compare_value)
       
   126     : "memory");
       
   127   return rv;
   116 }
   128 }
   117 
   129 
   118 #endif // OS_CPU_SOLARIS_SPARC_VM_ATOMIC_SOLARIS_SPARC_HPP
   130 #endif // OS_CPU_SOLARIS_SPARC_VM_ATOMIC_SOLARIS_SPARC_HPP