Mercurial > jdk8-mips64-public > hotspot / annotate

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

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

Thu, 21 Oct 2010 11:55:10 -0700

author
never
date
Thu, 21 Oct 2010 11:55:10 -0700
changeset 2262
1e9a9d2e6509
parent 1907
c18cbe5936b8
child 2314
f95d63e2154a
permissions
-rw-r--r--

6970683: improvements to hs_err output
Reviewed-by: kvn, jrose, dholmes, coleenp

duke@435 1 /*
trims@1907 2 * Copyright (c) 1999, 2009, Oracle and/or its affiliates. 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 *
trims@1907 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1907 20 * or visit www.oracle.com if you need additional information or have any
trims@1907 21 * 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
kvn@1329 49 inline jlong Atomic::load(volatile jlong* src) { return *src; }
kvn@1329 50
duke@435 51 #ifdef _GNU_SOURCE
duke@435 52
duke@435 53 inline jint Atomic::add (jint add_value, volatile jint* dest) {
duke@435 54 intptr_t rv;
duke@435 55 __asm__ volatile(
duke@435 56 "1: \n\t"
duke@435 57 " ld [%2], %%o2\n\t"
duke@435 58 " add %1, %%o2, %%o3\n\t"
duke@435 59 " cas [%2], %%o2, %%o3\n\t"
duke@435 60 " cmp %%o2, %%o3\n\t"
duke@435 61 " bne 1b\n\t"
duke@435 62 " nop\n\t"
duke@435 63 " add %1, %%o2, %0\n\t"
duke@435 64 : "=r" (rv)
duke@435 65 : "r" (add_value), "r" (dest)
duke@435 66 : "memory", "o2", "o3");
duke@435 67 return rv;
duke@435 68 }
duke@435 69
duke@435 70 inline intptr_t Atomic::add_ptr(intptr_t add_value, volatile intptr_t* dest) {
duke@435 71 intptr_t rv;
duke@435 72 #ifdef _LP64
duke@435 73 __asm__ volatile(
duke@435 74 "1: \n\t"
duke@435 75 " ldx [%2], %%o2\n\t"
duke@435 76 " add %0, %%o2, %%o3\n\t"
duke@435 77 " casx [%2], %%o2, %%o3\n\t"
duke@435 78 " cmp %%o2, %%o3\n\t"
duke@435 79 " bne %%xcc, 1b\n\t"
duke@435 80 " nop\n\t"
duke@435 81 " add %0, %%o2, %0\n\t"
duke@435 82 : "=r" (rv)
duke@435 83 : "r" (add_value), "r" (dest)
duke@435 84 : "memory", "o2", "o3");
duke@435 85 #else //_LP64
duke@435 86 __asm__ volatile(
duke@435 87 "1: \n\t"
duke@435 88 " ld [%2], %%o2\n\t"
duke@435 89 " add %1, %%o2, %%o3\n\t"
duke@435 90 " cas [%2], %%o2, %%o3\n\t"
duke@435 91 " cmp %%o2, %%o3\n\t"
duke@435 92 " bne 1b\n\t"
duke@435 93 " nop\n\t"
duke@435 94 " add %1, %%o2, %0\n\t"
duke@435 95 : "=r" (rv)
duke@435 96 : "r" (add_value), "r" (dest)
duke@435 97 : "memory", "o2", "o3");
duke@435 98 #endif // _LP64
duke@435 99 return rv;
duke@435 100 }
duke@435 101
duke@435 102 inline void* Atomic::add_ptr(intptr_t add_value, volatile void* dest) {
duke@435 103 return (void*)add_ptr((intptr_t)add_value, (volatile intptr_t*)dest);
duke@435 104 }
duke@435 105
duke@435 106
duke@435 107 inline jint Atomic::xchg (jint exchange_value, volatile jint* dest) {
duke@435 108 intptr_t rv = exchange_value;
duke@435 109 __asm__ volatile(
duke@435 110 " swap [%2],%1\n\t"
duke@435 111 : "=r" (rv)
duke@435 112 : "0" (exchange_value) /* we use same register as for return value */, "r" (dest)
duke@435 113 : "memory");
duke@435 114 return rv;
duke@435 115 }
duke@435 116
duke@435 117 inline intptr_t Atomic::xchg_ptr(intptr_t exchange_value, volatile intptr_t* dest) {
duke@435 118 intptr_t rv = exchange_value;
duke@435 119 #ifdef _LP64
duke@435 120 __asm__ volatile(
duke@435 121 "1:\n\t"
duke@435 122 " mov %1, %%o3\n\t"
duke@435 123 " ldx [%2], %%o2\n\t"
duke@435 124 " casx [%2], %%o2, %%o3\n\t"
duke@435 125 " cmp %%o2, %%o3\n\t"
duke@435 126 " bne %%xcc, 1b\n\t"
duke@435 127 " nop\n\t"
duke@435 128 " mov %%o2, %0\n\t"
duke@435 129 : "=r" (rv)
duke@435 130 : "r" (exchange_value), "r" (dest)
duke@435 131 : "memory", "o2", "o3");
duke@435 132 #else //_LP64
duke@435 133 __asm__ volatile(
duke@435 134 "swap [%2],%1\n\t"
duke@435 135 : "=r" (rv)
duke@435 136 : "0" (exchange_value) /* we use same register as for return value */, "r" (dest)
duke@435 137 : "memory");
duke@435 138 #endif // _LP64
duke@435 139 return rv;
duke@435 140 }
duke@435 141
duke@435 142 inline void* Atomic::xchg_ptr(void* exchange_value, volatile void* dest) {
duke@435 143 return (void*)xchg_ptr((intptr_t)exchange_value, (volatile intptr_t*)dest);
duke@435 144 }
duke@435 145
duke@435 146
duke@435 147 inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint compare_value) {
duke@435 148 jint rv;
duke@435 149 __asm__ volatile(
duke@435 150 " cas [%2], %3, %0"
duke@435 151 : "=r" (rv)
duke@435 152 : "0" (exchange_value), "r" (dest), "r" (compare_value)
duke@435 153 : "memory");
duke@435 154 return rv;
duke@435 155 }
duke@435 156
duke@435 157 inline jlong Atomic::cmpxchg (jlong exchange_value, volatile jlong* dest, jlong compare_value) {
duke@435 158 #ifdef _LP64
duke@435 159 jlong rv;
duke@435 160 __asm__ volatile(
duke@435 161 " casx [%2], %3, %0"
duke@435 162 : "=r" (rv)
duke@435 163 : "0" (exchange_value), "r" (dest), "r" (compare_value)
duke@435 164 : "memory");
duke@435 165 return rv;
duke@435 166 #else //_LP64
duke@435 167 assert(VM_Version::v9_instructions_work(), "cas only supported on v9");
duke@435 168 volatile jlong_accessor evl, cvl, rv;
duke@435 169 evl.long_value = exchange_value;
duke@435 170 cvl.long_value = compare_value;
duke@435 171
duke@435 172 __asm__ volatile(
duke@435 173 " sllx %2, 32, %2\n\t"
duke@435 174 " srl %3, 0, %3\n\t"
duke@435 175 " or %2, %3, %2\n\t"
duke@435 176 " sllx %5, 32, %5\n\t"
duke@435 177 " srl %6, 0, %6\n\t"
duke@435 178 " or %5, %6, %5\n\t"
duke@435 179 " casx [%4], %5, %2\n\t"
duke@435 180 " srl %2, 0, %1\n\t"
duke@435 181 " srlx %2, 32, %0\n\t"
duke@435 182 : "=r" (rv.words[0]), "=r" (rv.words[1])
duke@435 183 : "r" (evl.words[0]), "r" (evl.words[1]), "r" (dest), "r" (cvl.words[0]), "r" (cvl.words[1])
duke@435 184 : "memory");
duke@435 185
duke@435 186 return rv.long_value;
duke@435 187 #endif //_LP64
duke@435 188 }
duke@435 189
duke@435 190 inline intptr_t Atomic::cmpxchg_ptr(intptr_t exchange_value, volatile intptr_t* dest, intptr_t compare_value) {
duke@435 191 intptr_t rv;
duke@435 192 #ifdef _LP64
duke@435 193 __asm__ volatile(
duke@435 194 " casx [%2], %3, %0"
duke@435 195 : "=r" (rv)
duke@435 196 : "0" (exchange_value), "r" (dest), "r" (compare_value)
duke@435 197 : "memory");
duke@435 198 #else //_LP64
duke@435 199 __asm__ volatile(
duke@435 200 " cas [%2], %3, %0"
duke@435 201 : "=r" (rv)
duke@435 202 : "0" (exchange_value), "r" (dest), "r" (compare_value)
duke@435 203 : "memory");
duke@435 204 #endif // _LP64
duke@435 205 return rv;
duke@435 206 }
duke@435 207
duke@435 208 inline void* Atomic::cmpxchg_ptr(void* exchange_value, volatile void* dest, void* compare_value) {
duke@435 209 return (void*)cmpxchg_ptr((intptr_t)exchange_value, (volatile intptr_t*)dest, (intptr_t)compare_value);
duke@435 210 }
duke@435 211
duke@435 212 #else // _GNU_SOURCE
duke@435 213
duke@435 214 #if defined(COMPILER2) || defined(_LP64)
duke@435 215
duke@435 216 // This is the interface to the atomic instructions in solaris_sparc.il.
duke@435 217 // It's very messy because we need to support v8 and these instructions
duke@435 218 // are illegal there. When sparc v8 is dropped, we can drop out lots of
duke@435 219 // this code. Also compiler2 does not support v8 so the conditional code
duke@435 220 // omits the instruction set check.
duke@435 221
duke@435 222 extern "C" jint _Atomic_swap32(jint exchange_value, volatile jint* dest);
duke@435 223 extern "C" intptr_t _Atomic_swap64(intptr_t exchange_value, volatile intptr_t* dest);
duke@435 224
duke@435 225 extern "C" jint _Atomic_cas32(jint exchange_value, volatile jint* dest, jint compare_value);
duke@435 226 extern "C" intptr_t _Atomic_cas64(intptr_t exchange_value, volatile intptr_t* dest, intptr_t compare_value);
duke@435 227 extern "C" jlong _Atomic_casl (jlong exchange_value, volatile jlong* dest, jlong compare_value);
duke@435 228
duke@435 229 extern "C" jint _Atomic_add32(jint inc, volatile jint* dest);
duke@435 230 extern "C" intptr_t _Atomic_add64(intptr_t add_value, volatile intptr_t* dest);
duke@435 231
duke@435 232
duke@435 233 inline jint Atomic::add (jint add_value, volatile jint* dest) {
duke@435 234 return _Atomic_add32(add_value, dest);
duke@435 235 }
duke@435 236
duke@435 237 inline intptr_t Atomic::add_ptr(intptr_t add_value, volatile intptr_t* dest) {
duke@435 238 #ifdef _LP64
duke@435 239 return _Atomic_add64(add_value, dest);
duke@435 240 #else //_LP64
duke@435 241 return _Atomic_add32(add_value, dest);
duke@435 242 #endif // _LP64
duke@435 243 }
duke@435 244
duke@435 245 inline void* Atomic::add_ptr(intptr_t add_value, volatile void* dest) {
duke@435 246 return (void*)add_ptr((intptr_t)add_value, (volatile intptr_t*)dest);
duke@435 247 }
duke@435 248
duke@435 249
duke@435 250 inline jint Atomic::xchg (jint exchange_value, volatile jint* dest) {
duke@435 251 return _Atomic_swap32(exchange_value, dest);
duke@435 252 }
duke@435 253
duke@435 254 inline intptr_t Atomic::xchg_ptr(intptr_t exchange_value, volatile intptr_t* dest) {
duke@435 255 #ifdef _LP64
duke@435 256 return _Atomic_swap64(exchange_value, dest);
duke@435 257 #else // _LP64
duke@435 258 return _Atomic_swap32(exchange_value, dest);
duke@435 259 #endif // _LP64
duke@435 260 }
duke@435 261
duke@435 262 inline void* Atomic::xchg_ptr(void* exchange_value, volatile void* dest) {
duke@435 263 return (void*)xchg_ptr((intptr_t)exchange_value, (volatile intptr_t*)dest);
duke@435 264 }
duke@435 265
duke@435 266
duke@435 267 inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint compare_value) {
duke@435 268 return _Atomic_cas32(exchange_value, dest, compare_value);
duke@435 269 }
duke@435 270
duke@435 271 inline jlong Atomic::cmpxchg (jlong exchange_value, volatile jlong* dest, jlong compare_value) {
duke@435 272 #ifdef _LP64
duke@435 273 // Return 64 bit value in %o0
duke@435 274 return _Atomic_cas64((intptr_t)exchange_value, (intptr_t *)dest, (intptr_t)compare_value);
duke@435 275 #else // _LP64
duke@435 276 assert (VM_Version::v9_instructions_work(), "only supported on v9");
duke@435 277 // Return 64 bit value in %o0,%o1 by hand
duke@435 278 return _Atomic_casl(exchange_value, dest, compare_value);
duke@435 279 #endif // _LP64
duke@435 280 }
duke@435 281
duke@435 282 inline intptr_t Atomic::cmpxchg_ptr(intptr_t exchange_value, volatile intptr_t* dest, intptr_t compare_value) {
duke@435 283 #ifdef _LP64
duke@435 284 return _Atomic_cas64(exchange_value, dest, compare_value);
duke@435 285 #else // _LP64
duke@435 286 return _Atomic_cas32(exchange_value, dest, compare_value);
duke@435 287 #endif // _LP64
duke@435 288 }
duke@435 289
duke@435 290 inline void* Atomic::cmpxchg_ptr(void* exchange_value, volatile void* dest, void* compare_value) {
duke@435 291 return (void*)cmpxchg_ptr((intptr_t)exchange_value, (volatile intptr_t*)dest, (intptr_t)compare_value);
duke@435 292 }
duke@435 293
duke@435 294
duke@435 295 #else // _LP64 || COMPILER2
duke@435 296
duke@435 297
duke@435 298 // 32-bit compiler1 only
duke@435 299
duke@435 300 inline jint Atomic::add (jint add_value, volatile jint* dest) {
duke@435 301 return (*os::atomic_add_func)(add_value, dest);
duke@435 302 }
duke@435 303
duke@435 304 inline intptr_t Atomic::add_ptr(intptr_t add_value, volatile intptr_t* dest) {
duke@435 305 return (intptr_t)add((jint)add_value, (volatile jint*)dest);
duke@435 306 }
duke@435 307
duke@435 308 inline void* Atomic::add_ptr(intptr_t add_value, volatile void* dest) {
duke@435 309 return (void*)add((jint)add_value, (volatile jint*)dest);
duke@435 310 }
duke@435 311
duke@435 312
duke@435 313 inline jint Atomic::xchg (jint exchange_value, volatile jint* dest) {
duke@435 314 return (*os::atomic_xchg_func)(exchange_value, dest);
duke@435 315 }
duke@435 316
duke@435 317 inline intptr_t Atomic::xchg_ptr(intptr_t exchange_value, volatile intptr_t* dest) {
duke@435 318 return (intptr_t)xchg((jint)exchange_value, (volatile jint*)dest);
duke@435 319 }
duke@435 320
duke@435 321 inline void* Atomic::xchg_ptr(void* exchange_value, volatile void* dest) {
duke@435 322 return (void*)xchg((jint)exchange_value, (volatile jint*)dest);
duke@435 323 }
duke@435 324
duke@435 325
duke@435 326 inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint compare_value) {
duke@435 327 return (*os::atomic_cmpxchg_func)(exchange_value, dest, compare_value);
duke@435 328 }
duke@435 329
duke@435 330 inline jlong Atomic::cmpxchg (jlong exchange_value, volatile jlong* dest, jlong compare_value) {
duke@435 331 return (*os::atomic_cmpxchg_long_func)(exchange_value, dest, compare_value);
duke@435 332 }
duke@435 333
duke@435 334 inline intptr_t Atomic::cmpxchg_ptr(intptr_t exchange_value, volatile intptr_t* dest, intptr_t compare_value) {
duke@435 335 return (intptr_t)cmpxchg((jint)exchange_value, (volatile jint*)dest, (jint)compare_value);
duke@435 336 }
duke@435 337
duke@435 338 inline void* Atomic::cmpxchg_ptr(void* exchange_value, volatile void* dest, void* compare_value) {
duke@435 339 return (void*)cmpxchg((jint)exchange_value, (volatile jint*)dest, (jint)compare_value);
duke@435 340 }
duke@435 341
duke@435 342 #endif // _LP64 || COMPILER2
duke@435 343
duke@435 344 #endif // _GNU_SOURCE

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial