src/hotspot/os_cpu/bsd_x86/atomic_bsd_x86.hpp
changeset 59252 623722a6aeb9
parent 59251 4cbfa5077d68
equal deleted inserted replaced
59251:4cbfa5077d68 59252:623722a6aeb9
    62   return exchange_value;
    62   return exchange_value;
    63 }
    63 }
    64 
    64 
    65 template<>
    65 template<>
    66 template<typename T>
    66 template<typename T>
    67 inline T Atomic::PlatformCmpxchg<1>::operator()(T exchange_value,
    67 inline T Atomic::PlatformCmpxchg<1>::operator()(T volatile* dest,
    68                                                 T volatile* dest,
    68                                                 T compare_value,
    69                                                 T compare_value,
    69                                                 T exchange_value,
    70                                                 atomic_memory_order /* order */) const {
    70                                                 atomic_memory_order /* order */) const {
    71   STATIC_ASSERT(1 == sizeof(T));
    71   STATIC_ASSERT(1 == sizeof(T));
    72   __asm__ volatile (  "lock cmpxchgb %1,(%3)"
    72   __asm__ volatile (  "lock cmpxchgb %1,(%3)"
    73                     : "=a" (exchange_value)
    73                     : "=a" (exchange_value)
    74                     : "q" (exchange_value), "a" (compare_value), "r" (dest)
    74                     : "q" (exchange_value), "a" (compare_value), "r" (dest)
    76   return exchange_value;
    76   return exchange_value;
    77 }
    77 }
    78 
    78 
    79 template<>
    79 template<>
    80 template<typename T>
    80 template<typename T>
    81 inline T Atomic::PlatformCmpxchg<4>::operator()(T exchange_value,
    81 inline T Atomic::PlatformCmpxchg<4>::operator()(T volatile* dest,
    82                                                 T volatile* dest,
    82                                                 T compare_value,
    83                                                 T compare_value,
    83                                                 T exchange_value,
    84                                                 atomic_memory_order /* order */) const {
    84                                                 atomic_memory_order /* order */) const {
    85   STATIC_ASSERT(4 == sizeof(T));
    85   STATIC_ASSERT(4 == sizeof(T));
    86   __asm__ volatile (  "lock cmpxchgl %1,(%3)"
    86   __asm__ volatile (  "lock cmpxchgl %1,(%3)"
    87                     : "=a" (exchange_value)
    87                     : "=a" (exchange_value)
    88                     : "r" (exchange_value), "a" (compare_value), "r" (dest)
    88                     : "r" (exchange_value), "a" (compare_value), "r" (dest)
   118   return exchange_value;
   118   return exchange_value;
   119 }
   119 }
   120 
   120 
   121 template<>
   121 template<>
   122 template<typename T>
   122 template<typename T>
   123 inline T Atomic::PlatformCmpxchg<8>::operator()(T exchange_value,
   123 inline T Atomic::PlatformCmpxchg<8>::operator()(T volatile* dest,
   124                                                 T volatile* dest,
   124                                                 T compare_value,
   125                                                 T compare_value,
   125                                                 T exchange_value,
   126                                                 atomic_memory_order /* order */) const {
   126                                                 atomic_memory_order /* order */) const {
   127   STATIC_ASSERT(8 == sizeof(T));
   127   STATIC_ASSERT(8 == sizeof(T));
   128   __asm__ __volatile__ (  "lock cmpxchgq %1,(%3)"
   128   __asm__ __volatile__ (  "lock cmpxchgq %1,(%3)"
   129                         : "=a" (exchange_value)
   129                         : "=a" (exchange_value)
   130                         : "r" (exchange_value), "a" (compare_value), "r" (dest)
   130                         : "r" (exchange_value), "a" (compare_value), "r" (dest)
   140   void _Atomic_move_long(const volatile int64_t* src, volatile int64_t* dst);
   140   void _Atomic_move_long(const volatile int64_t* src, volatile int64_t* dst);
   141 }
   141 }
   142 
   142 
   143 template<>
   143 template<>
   144 template<typename T>
   144 template<typename T>
   145 inline T Atomic::PlatformCmpxchg<8>::operator()(T exchange_value,
   145 inline T Atomic::PlatformCmpxchg<8>::operator()(T volatile* dest,
   146                                                 T volatile* dest,
   146                                                 T compare_value,
   147                                                 T compare_value,
   147                                                 T exchange_value,
   148                                                 atomic_memory_order /* order */) const {
   148                                                 atomic_memory_order /* order */) const {
   149   STATIC_ASSERT(8 == sizeof(T));
   149   STATIC_ASSERT(8 == sizeof(T));
   150   return cmpxchg_using_helper<int64_t>(_Atomic_cmpxchg_long, exchange_value, dest, compare_value);
   150   return cmpxchg_using_helper<int64_t>(_Atomic_cmpxchg_long, dest, compare_value, exchange_value);
   151 }
   151 }
   152 
   152 
   153 template<>
   153 template<>
   154 template<typename T>
   154 template<typename T>
   155 inline T Atomic::PlatformLoad<8>::operator()(T const volatile* src) const {
   155 inline T Atomic::PlatformLoad<8>::operator()(T const volatile* src) const {