src/os_cpu/linux_x86/vm/atomic_linux_x86.hpp

rev 13449 : imported patch cmpxchg_template
rev 13456 : imported patch linux_x86
rev 13472 : imported patch coleen_review1
rev 13478 : imported patch cmpxchg_using_helper

*** 23,34 ****
   */
  
  #ifndef OS_CPU_LINUX_X86_VM_ATOMIC_LINUX_X86_HPP
  #define OS_CPU_LINUX_X86_VM_ATOMIC_LINUX_X86_HPP
  
- #include "runtime/os.hpp"
- 
  // Implementation of class atomic
  
  inline void Atomic::store    (jbyte    store_value, jbyte*    dest) { *dest = store_value; }
  inline void Atomic::store    (jshort   store_value, jshort*   dest) { *dest = store_value; }
  inline void Atomic::store    (jint     store_value, jint*     dest) { *dest = store_value; }
--- 23,32 ----
*** 79,98 ****
  
  inline void*    Atomic::xchg_ptr(void*    exchange_value, volatile void*     dest) {
    return (void*)xchg_ptr((intptr_t)exchange_value, (volatile intptr_t*)dest);
  }
  
! #define VM_HAS_SPECIALIZED_CMPXCHG_BYTE
! inline jbyte    Atomic::cmpxchg    (jbyte    exchange_value, volatile jbyte*    dest, jbyte    compare_value, cmpxchg_memory_order order) {
    __asm__ volatile ("lock cmpxchgb %1,(%3)"
                      : "=a" (exchange_value)
                      : "q" (exchange_value), "a" (compare_value), "r" (dest)
                      : "cc", "memory");
    return exchange_value;
  }
  
! inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value, cmpxchg_memory_order order) {
    __asm__ volatile ("lock cmpxchgl %1,(%3)"
                      : "=a" (exchange_value)
                      : "r" (exchange_value), "a" (compare_value), "r" (dest)
                      : "cc", "memory");
    return exchange_value;
--- 77,107 ----
  
  inline void*    Atomic::xchg_ptr(void*    exchange_value, volatile void*     dest) {
    return (void*)xchg_ptr((intptr_t)exchange_value, (volatile intptr_t*)dest);
  }
  
! template<>
! template<typename T>
! inline T Atomic::PlatformCmpxchg<1>::operator()(T exchange_value,
!                                                 T volatile* dest,
!                                                 T compare_value,
!                                                 cmpxchg_memory_order /* order */) const {
!   STATIC_ASSERT(1 == sizeof(T));
    __asm__ volatile ("lock cmpxchgb %1,(%3)"
                      : "=a" (exchange_value)
                      : "q" (exchange_value), "a" (compare_value), "r" (dest)
                      : "cc", "memory");
    return exchange_value;
  }
  
! template<>
! template<typename T>
! inline T Atomic::PlatformCmpxchg<4>::operator()(T exchange_value,
!                                                 T volatile* dest,
!                                                 T compare_value,
!                                                 cmpxchg_memory_order /* order */) const {
!   STATIC_ASSERT(4 == sizeof(T));
    __asm__ volatile ("lock cmpxchgl %1,(%3)"
                      : "=a" (exchange_value)
                      : "r" (exchange_value), "a" (compare_value), "r" (dest)
                      : "cc", "memory");
    return exchange_value;
*** 135,160 ****
                          : "0" (exchange_value), "r" (dest)
                          : "memory");
    return exchange_value;
  }
  
! inline jlong    Atomic::cmpxchg    (jlong    exchange_value, volatile jlong*    dest, jlong    compare_value, cmpxchg_memory_order order) {
    __asm__ __volatile__ ("lock cmpxchgq %1,(%3)"
                          : "=a" (exchange_value)
                          : "r" (exchange_value), "a" (compare_value), "r" (dest)
                          : "cc", "memory");
    return exchange_value;
  }
  
- inline intptr_t Atomic::cmpxchg_ptr(intptr_t exchange_value, volatile intptr_t* dest, intptr_t compare_value, cmpxchg_memory_order order) {
-   return (intptr_t)cmpxchg((jlong)exchange_value, (volatile jlong*)dest, (jlong)compare_value, order);
- }
- 
- inline void*    Atomic::cmpxchg_ptr(void*    exchange_value, volatile void*     dest, void*    compare_value, cmpxchg_memory_order order) {
-   return (void*)cmpxchg((jlong)exchange_value, (volatile jlong*)dest, (jlong)compare_value, order);
- }
- 
  inline jlong Atomic::load(const volatile jlong* src) { return *src; }
  
  #else // !AMD64
  
  inline intptr_t Atomic::add_ptr(intptr_t add_value, volatile intptr_t* dest) {
--- 144,167 ----
                          : "0" (exchange_value), "r" (dest)
                          : "memory");
    return exchange_value;
  }
  
! template<>
! template<typename T>
! inline T Atomic::PlatformCmpxchg<8>::operator()(T exchange_value,
!                                                 T volatile* dest,
!                                                 T compare_value,
!                                                 cmpxchg_memory_order /* order */) const {
!   STATIC_ASSERT(8 == sizeof(T));
    __asm__ __volatile__ ("lock cmpxchgq %1,(%3)"
                          : "=a" (exchange_value)
                          : "r" (exchange_value), "a" (compare_value), "r" (dest)
                          : "cc", "memory");
    return exchange_value;
  }
  
  inline jlong Atomic::load(const volatile jlong* src) { return *src; }
  
  #else // !AMD64
  
  inline intptr_t Atomic::add_ptr(intptr_t add_value, volatile intptr_t* dest) {
*** 182,201 ****
    // defined in linux_x86.s
    jlong _Atomic_cmpxchg_long(jlong, volatile jlong*, jlong);
    void _Atomic_move_long(const volatile jlong* src, volatile jlong* dst);
  }
  
! inline jlong    Atomic::cmpxchg    (jlong    exchange_value, volatile jlong*    dest, jlong    compare_value, cmpxchg_memory_order order) {
!   return _Atomic_cmpxchg_long(exchange_value, dest, compare_value);
! }
! 
! inline intptr_t Atomic::cmpxchg_ptr(intptr_t exchange_value, volatile intptr_t* dest, intptr_t compare_value, cmpxchg_memory_order order) {
!   return (intptr_t)cmpxchg((jint)exchange_value, (volatile jint*)dest, (jint)compare_value, order);
! }
! 
! inline void*    Atomic::cmpxchg_ptr(void*    exchange_value, volatile void*     dest, void*    compare_value, cmpxchg_memory_order order) {
!   return (void*)cmpxchg((jint)exchange_value, (volatile jint*)dest, (jint)compare_value, order);
  }
  
  inline jlong Atomic::load(const volatile jlong* src) {
    volatile jlong dest;
    _Atomic_move_long(src, &dest);
--- 189,206 ----
    // defined in linux_x86.s
    jlong _Atomic_cmpxchg_long(jlong, volatile jlong*, jlong);
    void _Atomic_move_long(const volatile jlong* src, volatile jlong* dst);
  }
  
! template<>
! template<typename T>
! inline T Atomic::PlatformCmpxchg<8>::operator()(T exchange_value,
!                                                 T volatile* dest,
!                                                 T compare_value,
!                                                 cmpxchg_memory_order order) const {
!   STATIC_ASSERT(8 == sizeof(T));
!   return cmpxchg_using_helper<jlong>(_Atomic_cmpxchg_long, exchange_value, dest, compare_value);
  }
  
  inline jlong Atomic::load(const volatile jlong* src) {
    volatile jlong dest;
    _Atomic_move_long(src, &dest);