Mercurial > jdk8-mips64-public > hotspot / annotate

src/os_cpu/solaris_sparc/vm/atomic_solaris_sparc.inline.hpp@d0994e5bebce (annotated)

src/os_cpu/solaris_sparc/vm/atomic_solaris_sparc.inline.hpp

Thu, 26 Mar 2009 14:31:45 -0700

author
never
date
Thu, 26 Mar 2009 14:31:45 -0700
changeset 1106
d0994e5bebce
parent 435
a61af66fc99e
child 1329
665be97e8704
permissions
-rw-r--r--

6822204: volatile fences should prefer lock:addl to actual mfence instructions
Reviewed-by: kvn, phh

duke@435 1 /*
duke@435 2 * Copyright 1999-2007 Sun Microsystems, Inc. All Rights Reserved.
duke@435 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435 4 *
duke@435 5 * This code is free software; you can redistribute it and/or modify it
duke@435 6 * under the terms of the GNU General Public License version 2 only, as
duke@435 7 * published by the Free Software Foundation.
duke@435 8 *
duke@435 9 * This code is distributed in the hope that it will be useful, but WITHOUT
duke@435 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@435 12 * version 2 for more details (a copy is included in the LICENSE file that
duke@435 13 * accompanied this code).
duke@435 14 *
duke@435 15 * You should have received a copy of the GNU General Public License version
duke@435 16 * 2 along with this work; if not, write to the Free Software Foundation,
duke@435 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435 18 *
duke@435 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
duke@435 20 * CA 95054 USA or visit www.sun.com if you need additional information or
duke@435 21 * have any questions.
duke@435 22 *
duke@435 23 */
duke@435 24
duke@435 25 // Implementation of class atomic
duke@435 26
duke@435 27 inline void Atomic::store (jbyte store_value, jbyte* dest) { *dest = store_value; }
duke@435 28 inline void Atomic::store (jshort store_value, jshort* dest) { *dest = store_value; }
duke@435 29 inline void Atomic::store (jint store_value, jint* dest) { *dest = store_value; }
duke@435 30 inline void Atomic::store (jlong store_value, jlong* dest) { *dest = store_value; }
duke@435 31 inline void Atomic::store_ptr(intptr_t store_value, intptr_t* dest) { *dest = store_value; }
duke@435 32 inline void Atomic::store_ptr(void* store_value, void* dest) { *(void**)dest = store_value; }
duke@435 33
duke@435 34 inline void Atomic::store (jbyte store_value, volatile jbyte* dest) { *dest = store_value; }
duke@435 35 inline void Atomic::store (jshort store_value, volatile jshort* dest) { *dest = store_value; }
duke@435 36 inline void Atomic::store (jint store_value, volatile jint* dest) { *dest = store_value; }
duke@435 37 inline void Atomic::store (jlong store_value, volatile jlong* dest) { *dest = store_value; }
duke@435 38 inline void Atomic::store_ptr(intptr_t store_value, volatile intptr_t* dest) { *dest = store_value; }
duke@435 39 inline void Atomic::store_ptr(void* store_value, volatile void* dest) { *(void* volatile *)dest = store_value; }
duke@435 40
duke@435 41 inline void Atomic::inc (volatile jint* dest) { (void)add (1, dest); }
duke@435 42 inline void Atomic::inc_ptr(volatile intptr_t* dest) { (void)add_ptr(1, dest); }
duke@435 43 inline void Atomic::inc_ptr(volatile void* dest) { (void)add_ptr(1, dest); }
duke@435 44
duke@435 45 inline void Atomic::dec (volatile jint* dest) { (void)add (-1, dest); }
duke@435 46 inline void Atomic::dec_ptr(volatile intptr_t* dest) { (void)add_ptr(-1, dest); }
duke@435 47 inline void Atomic::dec_ptr(volatile void* dest) { (void)add_ptr(-1, dest); }
duke@435 48
duke@435 49 #ifdef _GNU_SOURCE
duke@435 50
duke@435 51 inline jint Atomic::add (jint add_value, volatile jint* dest) {
duke@435 52 intptr_t rv;
duke@435 53 __asm__ volatile(
duke@435 54 "1: \n\t"
duke@435 55 " ld [%2], %%o2\n\t"
duke@435 56 " add %1, %%o2, %%o3\n\t"
duke@435 57 " cas [%2], %%o2, %%o3\n\t"
duke@435 58 " cmp %%o2, %%o3\n\t"
duke@435 59 " bne 1b\n\t"
duke@435 60 " nop\n\t"
duke@435 61 " add %1, %%o2, %0\n\t"
duke@435 62 : "=r" (rv)
duke@435 63 : "r" (add_value), "r" (dest)
duke@435 64 : "memory", "o2", "o3");
duke@435 65 return rv;
duke@435 66 }
duke@435 67
duke@435 68 inline intptr_t Atomic::add_ptr(intptr_t add_value, volatile intptr_t* dest) {
duke@435 69 intptr_t rv;
duke@435 70 #ifdef _LP64
duke@435 71 __asm__ volatile(
duke@435 72 "1: \n\t"
duke@435 73 " ldx [%2], %%o2\n\t"
duke@435 74 " add %0, %%o2, %%o3\n\t"
duke@435 75 " casx [%2], %%o2, %%o3\n\t"
duke@435 76 " cmp %%o2, %%o3\n\t"
duke@435 77 " bne %%xcc, 1b\n\t"
duke@435 78 " nop\n\t"
duke@435 79 " add %0, %%o2, %0\n\t"
duke@435 80 : "=r" (rv)
duke@435 81 : "r" (add_value), "r" (dest)
duke@435 82 : "memory", "o2", "o3");
duke@435 83 #else //_LP64
duke@435 84 __asm__ volatile(
duke@435 85 "1: \n\t"
duke@435 86 " ld [%2], %%o2\n\t"
duke@435 87 " add %1, %%o2, %%o3\n\t"
duke@435 88 " cas [%2], %%o2, %%o3\n\t"
duke@435 89 " cmp %%o2, %%o3\n\t"
duke@435 90 " bne 1b\n\t"
duke@435 91 " nop\n\t"
duke@435 92 " add %1, %%o2, %0\n\t"
duke@435 93 : "=r" (rv)
duke@435 94 : "r" (add_value), "r" (dest)
duke@435 95 : "memory", "o2", "o3");
duke@435 96 #endif // _LP64
duke@435 97 return rv;
duke@435 98 }
duke@435 99
duke@435 100 inline void* Atomic::add_ptr(intptr_t add_value, volatile void* dest) {
duke@435 101 return (void*)add_ptr((intptr_t)add_value, (volatile intptr_t*)dest);
duke@435 102 }
duke@435 103
duke@435 104
duke@435 105 inline jint Atomic::xchg (jint exchange_value, volatile jint* dest) {
duke@435 106 intptr_t rv = exchange_value;
duke@435 107 __asm__ volatile(
duke@435 108 " swap [%2],%1\n\t"
duke@435 109 : "=r" (rv)
duke@435 110 : "0" (exchange_value) /* we use same register as for return value */, "r" (dest)
duke@435 111 : "memory");
duke@435 112 return rv;
duke@435 113 }
duke@435 114
duke@435 115 inline intptr_t Atomic::xchg_ptr(intptr_t exchange_value, volatile intptr_t* dest) {
duke@435 116 intptr_t rv = exchange_value;
duke@435 117 #ifdef _LP64
duke@435 118 __asm__ volatile(
duke@435 119 "1:\n\t"
duke@435 120 " mov %1, %%o3\n\t"
duke@435 121 " ldx [%2], %%o2\n\t"
duke@435 122 " casx [%2], %%o2, %%o3\n\t"
duke@435 123 " cmp %%o2, %%o3\n\t"
duke@435 124 " bne %%xcc, 1b\n\t"
duke@435 125 " nop\n\t"
duke@435 126 " mov %%o2, %0\n\t"
duke@435 127 : "=r" (rv)
duke@435 128 : "r" (exchange_value), "r" (dest)
duke@435 129 : "memory", "o2", "o3");
duke@435 130 #else //_LP64
duke@435 131 __asm__ volatile(
duke@435 132 "swap [%2],%1\n\t"
duke@435 133 : "=r" (rv)
duke@435 134 : "0" (exchange_value) /* we use same register as for return value */, "r" (dest)
duke@435 135 : "memory");
duke@435 136 #endif // _LP64
duke@435 137 return rv;
duke@435 138 }
duke@435 139
duke@435 140 inline void* Atomic::xchg_ptr(void* exchange_value, volatile void* dest) {
duke@435 141 return (void*)xchg_ptr((intptr_t)exchange_value, (volatile intptr_t*)dest);
duke@435 142 }
duke@435 143
duke@435 144
duke@435 145 inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint compare_value) {
duke@435 146 jint rv;
duke@435 147 __asm__ volatile(
duke@435 148 " cas [%2], %3, %0"
duke@435 149 : "=r" (rv)
duke@435 150 : "0" (exchange_value), "r" (dest), "r" (compare_value)
duke@435 151 : "memory");
duke@435 152 return rv;
duke@435 153 }
duke@435 154
duke@435 155 inline jlong Atomic::cmpxchg (jlong exchange_value, volatile jlong* dest, jlong compare_value) {
duke@435 156 #ifdef _LP64
duke@435 157 jlong rv;
duke@435 158 __asm__ volatile(
duke@435 159 " casx [%2], %3, %0"
duke@435 160 : "=r" (rv)
duke@435 161 : "0" (exchange_value), "r" (dest), "r" (compare_value)
duke@435 162 : "memory");
duke@435 163 return rv;
duke@435 164 #else //_LP64
duke@435 165 assert(VM_Version::v9_instructions_work(), "cas only supported on v9");
duke@435 166 volatile jlong_accessor evl, cvl, rv;
duke@435 167 evl.long_value = exchange_value;
duke@435 168 cvl.long_value = compare_value;
duke@435 169
duke@435 170 __asm__ volatile(
duke@435 171 " sllx %2, 32, %2\n\t"
duke@435 172 " srl %3, 0, %3\n\t"
duke@435 173 " or %2, %3, %2\n\t"
duke@435 174 " sllx %5, 32, %5\n\t"
duke@435 175 " srl %6, 0, %6\n\t"
duke@435 176 " or %5, %6, %5\n\t"
duke@435 177 " casx [%4], %5, %2\n\t"
duke@435 178 " srl %2, 0, %1\n\t"
duke@435 179 " srlx %2, 32, %0\n\t"
duke@435 180 : "=r" (rv.words[0]), "=r" (rv.words[1])
duke@435 181 : "r" (evl.words[0]), "r" (evl.words[1]), "r" (dest), "r" (cvl.words[0]), "r" (cvl.words[1])
duke@435 182 : "memory");
duke@435 183
duke@435 184 return rv.long_value;
duke@435 185 #endif //_LP64
duke@435 186 }
duke@435 187
duke@435 188 inline intptr_t Atomic::cmpxchg_ptr(intptr_t exchange_value, volatile intptr_t* dest, intptr_t compare_value) {
duke@435 189 intptr_t rv;
duke@435 190 #ifdef _LP64
duke@435 191 __asm__ volatile(
duke@435 192 " casx [%2], %3, %0"
duke@435 193 : "=r" (rv)
duke@435 194 : "0" (exchange_value), "r" (dest), "r" (compare_value)
duke@435 195 : "memory");
duke@435 196 #else //_LP64
duke@435 197 __asm__ volatile(
duke@435 198 " cas [%2], %3, %0"
duke@435 199 : "=r" (rv)
duke@435 200 : "0" (exchange_value), "r" (dest), "r" (compare_value)
duke@435 201 : "memory");
duke@435 202 #endif // _LP64
duke@435 203 return rv;
duke@435 204 }
duke@435 205
duke@435 206 inline void* Atomic::cmpxchg_ptr(void* exchange_value, volatile void* dest, void* compare_value) {
duke@435 207 return (void*)cmpxchg_ptr((intptr_t)exchange_value, (volatile intptr_t*)dest, (intptr_t)compare_value);
duke@435 208 }
duke@435 209
duke@435 210 #else // _GNU_SOURCE
duke@435 211
duke@435 212 #if defined(COMPILER2) || defined(_LP64)
duke@435 213
duke@435 214 // This is the interface to the atomic instructions in solaris_sparc.il.
duke@435 215 // It's very messy because we need to support v8 and these instructions
duke@435 216 // are illegal there. When sparc v8 is dropped, we can drop out lots of
duke@435 217 // this code. Also compiler2 does not support v8 so the conditional code
duke@435 218 // omits the instruction set check.
duke@435 219
duke@435 220 extern "C" jint _Atomic_swap32(jint exchange_value, volatile jint* dest);
duke@435 221 extern "C" intptr_t _Atomic_swap64(intptr_t exchange_value, volatile intptr_t* dest);
duke@435 222
duke@435 223 extern "C" jint _Atomic_cas32(jint exchange_value, volatile jint* dest, jint compare_value);
duke@435 224 extern "C" intptr_t _Atomic_cas64(intptr_t exchange_value, volatile intptr_t* dest, intptr_t compare_value);
duke@435 225 extern "C" jlong _Atomic_casl (jlong exchange_value, volatile jlong* dest, jlong compare_value);
duke@435 226
duke@435 227 extern "C" jint _Atomic_add32(jint inc, volatile jint* dest);
duke@435 228 extern "C" intptr_t _Atomic_add64(intptr_t add_value, volatile intptr_t* dest);
duke@435 229
duke@435 230
duke@435 231 inline jint Atomic::add (jint add_value, volatile jint* dest) {
duke@435 232 return _Atomic_add32(add_value, dest);
duke@435 233 }
duke@435 234
duke@435 235 inline intptr_t Atomic::add_ptr(intptr_t add_value, volatile intptr_t* dest) {
duke@435 236 #ifdef _LP64
duke@435 237 return _Atomic_add64(add_value, dest);
duke@435 238 #else //_LP64
duke@435 239 return _Atomic_add32(add_value, dest);
duke@435 240 #endif // _LP64
duke@435 241 }
duke@435 242
duke@435 243 inline void* Atomic::add_ptr(intptr_t add_value, volatile void* dest) {
duke@435 244 return (void*)add_ptr((intptr_t)add_value, (volatile intptr_t*)dest);
duke@435 245 }
duke@435 246
duke@435 247
duke@435 248 inline jint Atomic::xchg (jint exchange_value, volatile jint* dest) {
duke@435 249 return _Atomic_swap32(exchange_value, dest);
duke@435 250 }
duke@435 251
duke@435 252 inline intptr_t Atomic::xchg_ptr(intptr_t exchange_value, volatile intptr_t* dest) {
duke@435 253 #ifdef _LP64
duke@435 254 return _Atomic_swap64(exchange_value, dest);
duke@435 255 #else // _LP64
duke@435 256 return _Atomic_swap32(exchange_value, dest);
duke@435 257 #endif // _LP64
duke@435 258 }
duke@435 259
duke@435 260 inline void* Atomic::xchg_ptr(void* exchange_value, volatile void* dest) {
duke@435 261 return (void*)xchg_ptr((intptr_t)exchange_value, (volatile intptr_t*)dest);
duke@435 262 }
duke@435 263
duke@435 264
duke@435 265 inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint compare_value) {
duke@435 266 return _Atomic_cas32(exchange_value, dest, compare_value);
duke@435 267 }
duke@435 268
duke@435 269 inline jlong Atomic::cmpxchg (jlong exchange_value, volatile jlong* dest, jlong compare_value) {
duke@435 270 #ifdef _LP64
duke@435 271 // Return 64 bit value in %o0
duke@435 272 return _Atomic_cas64((intptr_t)exchange_value, (intptr_t *)dest, (intptr_t)compare_value);
duke@435 273 #else // _LP64
duke@435 274 assert (VM_Version::v9_instructions_work(), "only supported on v9");
duke@435 275 // Return 64 bit value in %o0,%o1 by hand
duke@435 276 return _Atomic_casl(exchange_value, dest, compare_value);
duke@435 277 #endif // _LP64
duke@435 278 }
duke@435 279
duke@435 280 inline intptr_t Atomic::cmpxchg_ptr(intptr_t exchange_value, volatile intptr_t* dest, intptr_t compare_value) {
duke@435 281 #ifdef _LP64
duke@435 282 return _Atomic_cas64(exchange_value, dest, compare_value);
duke@435 283 #else // _LP64
duke@435 284 return _Atomic_cas32(exchange_value, dest, compare_value);
duke@435 285 #endif // _LP64
duke@435 286 }
duke@435 287
duke@435 288 inline void* Atomic::cmpxchg_ptr(void* exchange_value, volatile void* dest, void* compare_value) {
duke@435 289 return (void*)cmpxchg_ptr((intptr_t)exchange_value, (volatile intptr_t*)dest, (intptr_t)compare_value);
duke@435 290 }
duke@435 291
duke@435 292
duke@435 293 #else // _LP64 || COMPILER2
duke@435 294
duke@435 295
duke@435 296 // 32-bit compiler1 only
duke@435 297
duke@435 298 inline jint Atomic::add (jint add_value, volatile jint* dest) {
duke@435 299 return (*os::atomic_add_func)(add_value, dest);
duke@435 300 }
duke@435 301
duke@435 302 inline intptr_t Atomic::add_ptr(intptr_t add_value, volatile intptr_t* dest) {
duke@435 303 return (intptr_t)add((jint)add_value, (volatile jint*)dest);
duke@435 304 }
duke@435 305
duke@435 306 inline void* Atomic::add_ptr(intptr_t add_value, volatile void* dest) {
duke@435 307 return (void*)add((jint)add_value, (volatile jint*)dest);
duke@435 308 }
duke@435 309
duke@435 310
duke@435 311 inline jint Atomic::xchg (jint exchange_value, volatile jint* dest) {
duke@435 312 return (*os::atomic_xchg_func)(exchange_value, dest);
duke@435 313 }
duke@435 314
duke@435 315 inline intptr_t Atomic::xchg_ptr(intptr_t exchange_value, volatile intptr_t* dest) {
duke@435 316 return (intptr_t)xchg((jint)exchange_value, (volatile jint*)dest);
duke@435 317 }
duke@435 318
duke@435 319 inline void* Atomic::xchg_ptr(void* exchange_value, volatile void* dest) {
duke@435 320 return (void*)xchg((jint)exchange_value, (volatile jint*)dest);
duke@435 321 }
duke@435 322
duke@435 323
duke@435 324 inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint compare_value) {
duke@435 325 return (*os::atomic_cmpxchg_func)(exchange_value, dest, compare_value);
duke@435 326 }
duke@435 327
duke@435 328 inline jlong Atomic::cmpxchg (jlong exchange_value, volatile jlong* dest, jlong compare_value) {
duke@435 329 return (*os::atomic_cmpxchg_long_func)(exchange_value, dest, compare_value);
duke@435 330 }
duke@435 331
duke@435 332 inline intptr_t Atomic::cmpxchg_ptr(intptr_t exchange_value, volatile intptr_t* dest, intptr_t compare_value) {
duke@435 333 return (intptr_t)cmpxchg((jint)exchange_value, (volatile jint*)dest, (jint)compare_value);
duke@435 334 }
duke@435 335
duke@435 336 inline void* Atomic::cmpxchg_ptr(void* exchange_value, volatile void* dest, void* compare_value) {
duke@435 337 return (void*)cmpxchg((jint)exchange_value, (volatile jint*)dest, (jint)compare_value);
duke@435 338 }
duke@435 339
duke@435 340 #endif // _LP64 || COMPILER2
duke@435 341
duke@435 342 #endif // _GNU_SOURCE

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial