1 /*
   2  * Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef 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 
  30 // Implementation of class atomic
  31 
  32 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; }
  34 inline void Atomic::store    (jint     store_value, jint*     dest) { *dest = store_value; }
  35 inline void Atomic::store_ptr(intptr_t store_value, intptr_t* dest) { *dest = store_value; }
  36 inline void Atomic::store_ptr(void*    store_value, void*     dest) { *(void**)dest = store_value; }
  37 
  38 inline void Atomic::store    (jbyte    store_value, volatile jbyte*    dest) { *dest = store_value; }
  39 inline void Atomic::store    (jshort   store_value, volatile jshort*   dest) { *dest = store_value; }
  40 inline void Atomic::store    (jint     store_value, volatile jint*     dest) { *dest = store_value; }
  41 inline void Atomic::store_ptr(intptr_t store_value, volatile intptr_t* dest) { *dest = store_value; }
  42 inline void Atomic::store_ptr(void*    store_value, volatile void*     dest) { *(void* volatile *)dest = store_value; }
  43 
  44 inline void Atomic::inc    (volatile jint*     dest) { (void)add    (1, dest); }
  45 inline void Atomic::inc_ptr(volatile intptr_t* dest) { (void)add_ptr(1, dest); }
  46 inline void Atomic::inc_ptr(volatile void*     dest) { (void)add_ptr(1, dest); }
  47 
  48 inline void Atomic::dec    (volatile jint*     dest) { (void)add    (-1, dest); }
  49 inline void Atomic::dec_ptr(volatile intptr_t* dest) { (void)add_ptr(-1, dest); }
  50 inline void Atomic::dec_ptr(volatile void*     dest) { (void)add_ptr(-1, dest); }
  51 
  52 
  53 inline void Atomic::store(jlong store_value, jlong* dest) { *dest = store_value; }
  54 inline void Atomic::store(jlong store_value, volatile jlong* dest) { *dest = store_value; }
  55 inline jlong Atomic::load(const volatile jlong* src) { return *src; }
  56 
  57 #ifdef _GNU_SOURCE
  58 
  59 inline jint     Atomic::add    (jint     add_value, volatile jint*     dest) {
  60   intptr_t rv;
  61   __asm__ volatile(
  62     "1: \n\t"
  63     " ld     [%2], %%o2\n\t"
  64     " add    %1, %%o2, %%o3\n\t"
  65     " cas    [%2], %%o2, %%o3\n\t"
  66     " cmp    %%o2, %%o3\n\t"
  67     " bne    1b\n\t"
  68     "  nop\n\t"
  69     " add    %1, %%o2, %0\n\t"
  70     : "=r" (rv)
  71     : "r" (add_value), "r" (dest)
  72     : "memory", "o2", "o3");
  73   return rv;
  74 }
  75 
  76 inline intptr_t Atomic::add_ptr(intptr_t add_value, volatile intptr_t* dest) {
  77   intptr_t rv;
  78   __asm__ volatile(
  79     "1: \n\t"
  80     " ldx    [%2], %%o2\n\t"
  81     " add    %0, %%o2, %%o3\n\t"
  82     " casx   [%2], %%o2, %%o3\n\t"
  83     " cmp    %%o2, %%o3\n\t"
  84     " bne    %%xcc, 1b\n\t"
  85     "  nop\n\t"
  86     " add    %0, %%o2, %0\n\t"
  87     : "=r" (rv)
  88     : "r" (add_value), "r" (dest)
  89     : "memory", "o2", "o3");
  90   return rv;
  91 }
  92 
  93 inline void*    Atomic::add_ptr(intptr_t add_value, volatile void*     dest) {
  94   return (void*)add_ptr((intptr_t)add_value, (volatile intptr_t*)dest);
  95 }
  96 
  97 
  98 inline jint     Atomic::xchg    (jint     exchange_value, volatile jint*     dest) {
  99   intptr_t rv = exchange_value;
 100   __asm__ volatile(
 101     " swap   [%2],%1\n\t"
 102     : "=r" (rv)
 103     : "0" (exchange_value) /* we use same register as for return value */, "r" (dest)
 104     : "memory");
 105   return rv;
 106 }
 107 
 108 inline intptr_t Atomic::xchg_ptr(intptr_t exchange_value, volatile intptr_t* dest) {
 109   intptr_t rv = exchange_value;
 110   __asm__ volatile(
 111     "1:\n\t"
 112     " mov    %1, %%o3\n\t"
 113     " ldx    [%2], %%o2\n\t"
 114     " casx   [%2], %%o2, %%o3\n\t"
 115     " cmp    %%o2, %%o3\n\t"
 116     " bne    %%xcc, 1b\n\t"
 117     "  nop\n\t"
 118     " mov    %%o2, %0\n\t"
 119     : "=r" (rv)
 120     : "r" (exchange_value), "r" (dest)
 121     : "memory", "o2", "o3");
 122   return rv;
 123 }
 124 
 125 inline void*    Atomic::xchg_ptr(void*    exchange_value, volatile void*     dest) {
 126   return (void*)xchg_ptr((intptr_t)exchange_value, (volatile intptr_t*)dest);
 127 }
 128 
 129 
 130 inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value, cmpxchg_memory_order order) {
 131   jint rv;
 132   __asm__ volatile(
 133     " cas    [%2], %3, %0"
 134     : "=r" (rv)
 135     : "0" (exchange_value), "r" (dest), "r" (compare_value)
 136     : "memory");
 137   return rv;
 138 }
 139 
 140 inline jlong    Atomic::cmpxchg    (jlong    exchange_value, volatile jlong*    dest, jlong    compare_value, cmpxchg_memory_order order) {
 141   jlong rv;
 142   __asm__ volatile(
 143     " casx   [%2], %3, %0"
 144     : "=r" (rv)
 145     : "0" (exchange_value), "r" (dest), "r" (compare_value)
 146     : "memory");
 147   return rv;
 148 }
 149 
 150 inline intptr_t Atomic::cmpxchg_ptr(intptr_t exchange_value, volatile intptr_t* dest, intptr_t compare_value, cmpxchg_memory_order order) {
 151   intptr_t rv;
 152   __asm__ volatile(
 153     " casx    [%2], %3, %0"
 154     : "=r" (rv)
 155     : "0" (exchange_value), "r" (dest), "r" (compare_value)
 156     : "memory");
 157   return rv;
 158 }
 159 
 160 inline void*    Atomic::cmpxchg_ptr(void*    exchange_value, volatile void*     dest, void*    compare_value, cmpxchg_memory_order order) {
 161   return (void*)cmpxchg_ptr((intptr_t)exchange_value, (volatile intptr_t*)dest, (intptr_t)compare_value, order);
 162 }
 163 
 164 #else // _GNU_SOURCE
 165 
 166 // This is the interface to the atomic instructions in solaris_sparc.il.
 167 // It's very messy because we need to support v8 and these instructions
 168 // are illegal there.  When sparc v8 is dropped, we can drop out lots of
 169 // this code.  Also compiler2 does not support v8 so the conditional code
 170 // omits the instruction set check.
 171 
 172 extern "C" jint     _Atomic_swap32(jint     exchange_value, volatile jint*     dest);
 173 extern "C" intptr_t _Atomic_swap64(intptr_t exchange_value, volatile intptr_t* dest);
 174 
 175 extern "C" jint     _Atomic_cas32(jint     exchange_value, volatile jint*     dest, jint     compare_value);
 176 extern "C" intptr_t _Atomic_cas64(intptr_t exchange_value, volatile intptr_t* dest, intptr_t compare_value);
 177 extern "C" jlong    _Atomic_casl (jlong    exchange_value, volatile jlong*    dest, jlong    compare_value);
 178 
 179 extern "C" jint     _Atomic_add32(jint     inc,       volatile jint*     dest);
 180 extern "C" intptr_t _Atomic_add64(intptr_t add_value, volatile intptr_t* dest);
 181 
 182 
 183 inline jint     Atomic::add     (jint    add_value, volatile jint*     dest) {
 184   return _Atomic_add32(add_value, dest);
 185 }
 186 
 187 inline intptr_t Atomic::add_ptr(intptr_t add_value, volatile intptr_t* dest) {
 188   return _Atomic_add64(add_value, dest);
 189 }
 190 
 191 inline void*    Atomic::add_ptr(intptr_t add_value, volatile void*     dest) {
 192   return (void*)add_ptr((intptr_t)add_value, (volatile intptr_t*)dest);
 193 }
 194 
 195 
 196 inline jint     Atomic::xchg    (jint     exchange_value, volatile jint*     dest) {
 197   return _Atomic_swap32(exchange_value, dest);
 198 }
 199 
 200 inline intptr_t Atomic::xchg_ptr(intptr_t exchange_value, volatile intptr_t* dest) {
 201   return _Atomic_swap64(exchange_value, dest);
 202 }
 203 
 204 inline void*    Atomic::xchg_ptr(void*    exchange_value, volatile void*     dest) {
 205   return (void*)xchg_ptr((intptr_t)exchange_value, (volatile intptr_t*)dest);
 206 }
 207 
 208 
 209 inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value, cmpxchg_memory_order order) {
 210   return _Atomic_cas32(exchange_value, dest, compare_value);
 211 }
 212 
 213 inline jlong    Atomic::cmpxchg    (jlong    exchange_value, volatile jlong*    dest, jlong    compare_value, cmpxchg_memory_order order) {
 214   // Return 64 bit value in %o0
 215   return _Atomic_cas64((intptr_t)exchange_value, (intptr_t *)dest, (intptr_t)compare_value);
 216 }
 217 
 218 inline intptr_t Atomic::cmpxchg_ptr(intptr_t exchange_value, volatile intptr_t* dest, intptr_t compare_value, cmpxchg_memory_order order) {
 219   return _Atomic_cas64(exchange_value, dest, compare_value);
 220 }
 221 
 222 inline void*    Atomic::cmpxchg_ptr(void*    exchange_value, volatile void*     dest, void*    compare_value, cmpxchg_memory_order order) {
 223   return (void*)cmpxchg_ptr((intptr_t)exchange_value, (volatile intptr_t*)dest, (intptr_t)compare_value, order);
 224 }
 225 
 226 #endif // _GNU_SOURCE
 227 
 228 #endif // OS_CPU_SOLARIS_SPARC_VM_ATOMIC_SOLARIS_SPARC_HPP