src/hotspot/os_cpu/bsd_x86/atomic_bsd_x86.hpp
changeset 47552 8a3599d60996
parent 47216 71c04702a3d5
child 47578 09c41c4913d9
equal deleted inserted replaced
47551:4d034d861e13 47552:8a3599d60996
    59                     : "0" (add_value), "r" (dest)
    59                     : "0" (add_value), "r" (dest)
    60                     : "cc", "memory");
    60                     : "cc", "memory");
    61   return old_value;
    61   return old_value;
    62 }
    62 }
    63 
    63 
    64 inline void Atomic::inc    (volatile jint*     dest) {
       
    65   __asm__ volatile (  "lock addl $1,(%0)" :
       
    66                     : "r" (dest) : "cc", "memory");
       
    67 }
       
    68 
       
    69 inline void Atomic::inc_ptr(volatile void*     dest) {
       
    70   inc_ptr((volatile intptr_t*)dest);
       
    71 }
       
    72 
       
    73 inline void Atomic::dec    (volatile jint*     dest) {
       
    74   __asm__ volatile (  "lock subl $1,(%0)" :
       
    75                     : "r" (dest) : "cc", "memory");
       
    76 }
       
    77 
       
    78 inline void Atomic::dec_ptr(volatile void*     dest) {
       
    79   dec_ptr((volatile intptr_t*)dest);
       
    80 }
       
    81 
       
    82 inline jint     Atomic::xchg    (jint     exchange_value, volatile jint*     dest) {
    64 inline jint     Atomic::xchg    (jint     exchange_value, volatile jint*     dest) {
    83   __asm__ volatile (  "xchgl (%2),%0"
    65   __asm__ volatile (  "xchgl (%2),%0"
    84                     : "=r" (exchange_value)
    66                     : "=r" (exchange_value)
    85                     : "0" (exchange_value), "r" (dest)
    67                     : "0" (exchange_value), "r" (dest)
    86                     : "memory");
    68                     : "memory");
   134                         : "0" (add_value), "r" (dest)
   116                         : "0" (add_value), "r" (dest)
   135                         : "cc", "memory");
   117                         : "cc", "memory");
   136   return old_value;
   118   return old_value;
   137 }
   119 }
   138 
   120 
   139 inline void Atomic::inc_ptr(volatile intptr_t* dest) {
       
   140   __asm__ __volatile__ (  "lock addq $1,(%0)"
       
   141                         :
       
   142                         : "r" (dest)
       
   143                         : "cc", "memory");
       
   144 }
       
   145 
       
   146 inline void Atomic::dec_ptr(volatile intptr_t* dest) {
       
   147   __asm__ __volatile__ (  "lock subq $1,(%0)"
       
   148                         :
       
   149                         : "r" (dest)
       
   150                         : "cc", "memory");
       
   151 }
       
   152 
       
   153 inline intptr_t Atomic::xchg_ptr(intptr_t exchange_value, volatile intptr_t* dest) {
   121 inline intptr_t Atomic::xchg_ptr(intptr_t exchange_value, volatile intptr_t* dest) {
   154   __asm__ __volatile__ ("xchgq (%2),%0"
   122   __asm__ __volatile__ ("xchgq (%2),%0"
   155                         : "=r" (exchange_value)
   123                         : "=r" (exchange_value)
   156                         : "0" (exchange_value), "r" (dest)
   124                         : "0" (exchange_value), "r" (dest)
   157                         : "memory");
   125                         : "memory");
   173 }
   141 }
   174 
   142 
   175 inline jlong Atomic::load(const volatile jlong* src) { return *src; }
   143 inline jlong Atomic::load(const volatile jlong* src) { return *src; }
   176 
   144 
   177 #else // !AMD64
   145 #else // !AMD64
   178 
       
   179 inline void Atomic::inc_ptr(volatile intptr_t* dest) {
       
   180   inc((volatile jint*)dest);
       
   181 }
       
   182 
       
   183 inline void Atomic::dec_ptr(volatile intptr_t* dest) {
       
   184   dec((volatile jint*)dest);
       
   185 }
       
   186 
   146 
   187 inline intptr_t Atomic::xchg_ptr(intptr_t exchange_value, volatile intptr_t* dest) {
   147 inline intptr_t Atomic::xchg_ptr(intptr_t exchange_value, volatile intptr_t* dest) {
   188   return (intptr_t)xchg((jint)exchange_value, (volatile jint*)dest);
   148   return (intptr_t)xchg((jint)exchange_value, (volatile jint*)dest);
   189 }
   149 }
   190 
   150